@i18nprune/core 0.1.0

package/dist/sync.js

@@ -0,0 +1,4971 @@
+// 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/reference/paths.ts
+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 isPlainObject2(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 (isPlainObject2(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 (isPlainObject2(template)) {
+    const tObj = isPlainObject2(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);
+}
+
+// src/shared/json/prune.ts
+function isPlainObject3(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 (!isPlainObject3(template)) return target;
+  if (!isPlainObject3(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/json/sortKeys.ts
+function isPlainObject4(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function sortJsonObjectKeysAsc(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonObjectKeysAsc(item));
+  }
+  if (!isPlainObject4(value)) return value;
+  const sorted = {};
+  for (const key of Object.keys(value).sort()) {
+    sorted[key] = sortJsonObjectKeysAsc(value[key]);
+  }
+  return sorted;
+}
+function localeJsonContentEquals(a, b) {
+  return JSON.stringify(sortJsonObjectKeysAsc(a)) === JSON.stringify(sortJsonObjectKeysAsc(b));
+}
+
+// src/sync/apply.ts
+function computeSyncedLocaleJson(template, cur, preserve, mergeOpts) {
+  let next = mergeToTemplateShape(template, cur, preserve, mergeOpts);
+  next = pruneToTemplateShape(template, next, mergeOpts);
+  const wouldChange = !localeJsonContentEquals(cur, next);
+  return { next, wouldChange };
+}
+function isPlainObject5(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function stripStructuredLeafMetadata(root) {
+  if (Array.isArray(root)) return root.map((v) => stripStructuredLeafMetadata(v));
+  if (!isPlainObject5(root)) return root;
+  if (typeof root.value === "string") return root.value;
+  const out = {};
+  for (const [k, v] of Object.entries(root)) {
+    out[k] = stripStructuredLeafMetadata(v);
+  }
+  return out;
+}
+
+// src/shared/json/localeLeafPath.ts
+function isPlainObject6(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isLiteralDottedObjectKey(key) {
+  return key.includes(".");
+}
+function getLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject6(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    return root[pathStr];
+  }
+  return getAtPath(root, pathStr);
+}
+function deleteLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject6(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    const clone = deepClone(root);
+    delete clone[pathStr];
+    return clone;
+  }
+  return deleteAtPath(root, pathStr);
+}
+function stripLiteralDottedKeysAtLevel(root) {
+  if (!isPlainObject6(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 (!isPlainObject6(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) && isPlainObject6(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" };
+}
+
+// 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 isPlainObject7(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isStructuredLocaleLeafNode(x) {
+  return isPlainObject7(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 (isPlainObject7(root)) {
+    for (const k of Object.keys(root)) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      collectTranslationSurfaceLeaves(root[k], p, out, fileOrigin);
+    }
+  }
+  return out;
+}
+
+// src/extractor/bindings/ident.ts
+var IMPORT_BINDING_IDENT_PATTERN = String.raw`[$_\p{ID_Start}][$_\p{ID_Continue}]*`;
+
+// src/extractor/bindings/expand.ts
+var RX_SAFE_BRACKET_METHOD = new RegExp(String.raw`^` + IMPORT_BINDING_IDENT_PATTERN + String.raw`$`, "u");
+function isRuntimeBinding(b) {
+  return b.isTypeOnly !== true;
+}
+function isSafeBracketMethodKey(method) {
+  if (method.length === 0) return false;
+  if (/['"\\\s\n\r]/.test(method)) return false;
+  return RX_SAFE_BRACKET_METHOD.test(method);
+}
+function addMemberCallVariants(effective, objectLocal, method) {
+  effective.add(`${objectLocal}.${method}`);
+  effective.add(`${objectLocal}?.${method}`);
+  if (isSafeBracketMethodKey(method)) {
+    effective.add(`${objectLocal}['${method}']`);
+    effective.add(`${objectLocal}?.['${method}']`);
+    effective.add(`${objectLocal}["${method}"]`);
+    effective.add(`${objectLocal}?.["${method}"]`);
+  }
+}
+function methodSuffixesForModuleExpansion(configuredSet, simpleRoots, bindings) {
+  const suffixes = new Set(simpleRoots);
+  for (const b of bindings) {
+    if (!isRuntimeBinding(b) || b.kind !== "named") continue;
+    if (configuredSet.has(b.imported) || configuredSet.has(b.local)) {
+      suffixes.add(b.imported);
+      suffixes.add(b.local);
+    }
+  }
+  return suffixes;
+}
+function expandFunctionsWithBindings(configuredFunctions, bindings) {
+  const uniqConfigured = [...new Set(configuredFunctions)];
+  const configuredSet = new Set(uniqConfigured);
+  const effective = new Set(uniqConfigured);
+  const simpleRoots = uniqConfigured.filter((f) => !f.includes("."));
+  for (const b of bindings) {
+    if (!isRuntimeBinding(b)) continue;
+    if (b.kind === "named" && (configuredSet.has(b.imported) || configuredSet.has(b.local))) {
+      effective.add(b.local);
+    }
+  }
+  const methodSuffixes = methodSuffixesForModuleExpansion(configuredSet, simpleRoots, bindings);
+  for (const method of methodSuffixes) {
+    for (const b of bindings) {
+      if (!isRuntimeBinding(b)) continue;
+      if (b.kind === "module") {
+        addMemberCallVariants(effective, b.local, method);
+      }
+    }
+  }
+  const discovered = [...effective].filter((f) => !configuredSet.has(f));
+  discovered.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return [...uniqConfigured, ...discovered];
+}
+
+// src/extractor/shared/jslikeTextRanges.ts
+function skipString(text, start, quote) {
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    i += 1;
+  }
+  return text.length;
+}
+function skipTemplate(text, start) {
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") return i + 1;
+    if (ch === "$" && text[i + 1] === "{") {
+      i += 2;
+      let depth = 1;
+      while (i < text.length && depth > 0) {
+        const c2 = text[i];
+        if (c2 === "{") depth += 1;
+        else if (c2 === "}") depth -= 1;
+        i += 1;
+      }
+      continue;
+    }
+    i += 1;
+  }
+  return text.length;
+}
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  const out = [];
+  let cur = sorted[0];
+  for (let k = 1; k < sorted.length; k += 1) {
+    const n = sorted[k];
+    if (n.start <= cur.end) {
+      cur = { start: cur.start, end: Math.max(cur.end, n.end) };
+    } else {
+      out.push(cur);
+      cur = n;
+    }
+  }
+  out.push(cur);
+  return out;
+}
+function commentRangesForJsLikeText(text) {
+  const ranges = [];
+  let i = 0;
+  const len = text.length;
+  while (i < len) {
+    const c = text[i];
+    if (c === "/" && text[i + 1] === "/") {
+      const start = i;
+      i += 2;
+      while (i < len && text[i] !== "\n") i += 1;
+      ranges.push({ start, end: i });
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      const start = i;
+      i += 2;
+      while (i + 1 < len) {
+        if (text[i] === "*" && text[i + 1] === "/") {
+          i += 2;
+          ranges.push({ start, end: i });
+          break;
+        }
+        i += 1;
+      }
+      if (i >= len && start >= 0 && !ranges.some((r) => r.start === start)) {
+        ranges.push({ start, end: len });
+      }
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      i = skipString(text, i, c);
+      continue;
+    }
+    if (c === "`") {
+      i = skipTemplate(text, i);
+      continue;
+    }
+    i += 1;
+  }
+  return mergeRanges(ranges);
+}
+function literalRangesForJsLikeText(text) {
+  const ranges = [];
+  let i = 0;
+  const len = text.length;
+  while (i < len) {
+    const c = text[i];
+    if (c === "/" && text[i + 1] === "/") {
+      i += 2;
+      while (i < len && text[i] !== "\n") i += 1;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < len) {
+        if (text[i] === "*" && text[i + 1] === "/") {
+          i += 2;
+          break;
+        }
+        i += 1;
+      }
+      if (i >= len) break;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const start = i;
+      i = skipString(text, i, c);
+      if (i > start + 1) ranges.push({ start: start + 1, end: i - 1 });
+      continue;
+    }
+    if (c === "`") {
+      const start = i;
+      i = skipTemplate(text, i);
+      if (i > start + 1) ranges.push({ start: start + 1, end: i - 1 });
+      continue;
+    }
+    i += 1;
+  }
+  return mergeRanges(ranges);
+}
+function importBindingScanBlankRanges(text) {
+  return mergeRanges([...commentRangesForJsLikeText(text), ...literalRangesForJsLikeText(text)]);
+}
+function offsetInCommentRanges(offset, ranges) {
+  for (const r of ranges) {
+    if (offset >= r.start && offset < r.end) return true;
+  }
+  return false;
+}
+
+// src/extractor/bindings/imports.ts
+var U = "gu";
+var IMPORT_TYPE_NAMESPACE_RX = new RegExp(
+  String.raw`import\s+type\s*\*\s*as\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var IMPORT_TYPE_NAMED_RX = new RegExp(
+  String.raw`import\s+type\s+\{([^}]*)\}\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var IMPORT_TYPE_DEFAULT_RX = new RegExp(
+  String.raw`import\s+type\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var TS_IMPORT_EQUALS_RX = new RegExp(
+  String.raw`import\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s*=\s*require\s*\(\s*(['"])(?:(?!\2).|\\.)*\2\s*\)`,
+  U
+);
+var NAMESPACE_IMPORT_RX = new RegExp(
+  String.raw`import\s*\*\s*as\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var DEFAULT_AND_NAMED_IMPORT_RX = new RegExp(
+  String.raw`import\s+(?!type\b)(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s*,\s*\{([^}]*)\}\s+from\s*(['"])(?:(?!\3).|\\.)*\3`,
+  U
+);
+var NAMED_IMPORT_ONLY_RX = new RegExp(
+  String.raw`import\s+(?:type\s+)?\{([^}]*)\}\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var DEFAULT_IMPORT_ONLY_RX = new RegExp(
+  String.raw`import\s+(?!type\b)(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s+from\s*(['"])(?:(?!\2).|\\.)*\2`,
+  U
+);
+var CJS_REQUIRE_DESTRUCT_RX = new RegExp(
+  String.raw`(?:const|let|var)\s*\{([^}]*)\}\s*=\s*require\s*\(\s*(['"])(?:(?!\2).|\\.)*\2\s*\)`,
+  U
+);
+var CJS_REQUIRE_MODULE_RX = new RegExp(
+  String.raw`(?:const|let|var)\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s*=\s*require\s*\(\s*(['"])(?:(?!\2).|\\.)*\2\s*\)`,
+  U
+);
+var DYNAMIC_IMPORT_DESTRUCT_RX = new RegExp(
+  String.raw`(?:const|let|var)\s*\{([^}]*)\}\s*=\s*(?:await\s+)?import\s*\(\s*(['"])(?:(?!\2).|\\.)*\2\s*\)`,
+  U
+);
+var DYNAMIC_IMPORT_MODULE_RX = new RegExp(
+  String.raw`(?:const|let|var)\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s*=\s*(?:await\s+)?import\s*\(\s*(['"])(?:(?!\2).|\\.)*\2\s*\)`,
+  U
+);
+var RX_AS_PAIR = new RegExp(String.raw`^(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s+as\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)$`, "u");
+var RX_IDENT_ONLY = new RegExp(String.raw`^(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)$`, "u");
+var RX_TYPE_INLINE = new RegExp(String.raw`^type\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)$`, "u");
+var RX_DEFAULT_AS_SEGMENT = new RegExp(String.raw`^default\s+as\s+(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)$`, "u");
+var RX_CJS_RENAME = new RegExp(String.raw`^(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)\s*:\s*(` + IMPORT_BINDING_IDENT_PATTERN + String.raw`)$`, "u");
+function isTypeOnlyImportStatement(statement) {
+  return /^import\s+type\s+/.test(statement.trimStart());
+}
+function blankScanTextForImportBindings(text) {
+  const ranges = importBindingScanBlankRanges(text);
+  if (ranges.length === 0) return text;
+  const chars = [...text];
+  for (const r of ranges) {
+    for (let i = r.start; i < r.end; i += 1) chars[i] = " ";
+  }
+  return chars.join("");
+}
+function splitImportSpecifiers(clause) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (let i = 0; i < clause.length; i += 1) {
+    const c = clause[i];
+    if (c === "{" || c === "[" || c === "(") depth += 1;
+    else if (c === "}" || c === "]" || c === ")") depth -= 1;
+    else if (c === "," && depth === 0) {
+      const t = cur.trim();
+      if (t) out.push(t);
+      cur = "";
+      continue;
+    }
+    cur += c;
+  }
+  const tail = cur.trim();
+  if (tail) out.push(tail);
+  return out;
+}
+function parseEsmDefaultAsLocals(clause) {
+  const out = [];
+  for (const raw of splitImportSpecifiers(clause)) {
+    const seg = raw.trim();
+    if (!seg) continue;
+    const m = seg.match(RX_DEFAULT_AS_SEGMENT);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+function parseEsmNamedImportClause(clause) {
+  const pairs = [];
+  for (const raw of splitImportSpecifiers(clause)) {
+    const seg = raw.trim();
+    if (!seg) continue;
+    if (RX_TYPE_INLINE.test(seg)) continue;
+    if (RX_DEFAULT_AS_SEGMENT.test(seg)) continue;
+    const asMatch = seg.match(RX_AS_PAIR);
+    if (asMatch) {
+      pairs.push({ imported: asMatch[1], local: asMatch[2] });
+      continue;
+    }
+    const ident = seg.match(RX_IDENT_ONLY);
+    if (ident) {
+      const name = ident[1];
+      pairs.push({ imported: name, local: name });
+    }
+  }
+  return pairs;
+}
+function parseCjsDestructuringClause(clause) {
+  const pairs = [];
+  for (const raw of splitImportSpecifiers(clause)) {
+    const seg = raw.trim();
+    if (!seg) continue;
+    const rename = seg.match(RX_CJS_RENAME);
+    if (rename) {
+      pairs.push({ imported: rename[1], local: rename[2] });
+      continue;
+    }
+    const ident = seg.match(RX_IDENT_ONLY);
+    if (ident) {
+      const name = ident[1];
+      pairs.push({ imported: name, local: name });
+    }
+  }
+  return pairs;
+}
+function pushNamed(out, imported, local, source, typeOnly) {
+  out.push(
+    typeOnly === true ? { kind: "named", imported, local, source, isTypeOnly: true } : { kind: "named", imported, local, source }
+  );
+}
+function pushModule(out, local, moduleKind, source, typeOnly) {
+  out.push(
+    typeOnly === true ? { kind: "module", local, moduleKind, source, isTypeOnly: true } : { kind: "module", local, moduleKind, source }
+  );
+}
+function scanImportBindings(text) {
+  const scanText = blankScanTextForImportBindings(text);
+  const out = [];
+  let m;
+  const typeNsRe = new RegExp(IMPORT_TYPE_NAMESPACE_RX.source, U);
+  while ((m = typeNsRe.exec(scanText)) !== null) {
+    pushModule(out, m[1], "namespace", "esm", true);
+  }
+  const typeNamedRe = new RegExp(IMPORT_TYPE_NAMED_RX.source, U);
+  while ((m = typeNamedRe.exec(scanText)) !== null) {
+    const clause = m[1];
+    for (const pair of parseEsmNamedImportClause(clause)) {
+      pushNamed(out, pair.imported, pair.local, "esm", true);
+    }
+    for (const local of parseEsmDefaultAsLocals(clause)) {
+      pushModule(out, local, "default", "esm", true);
+    }
+  }
+  const typeDefRe = new RegExp(IMPORT_TYPE_DEFAULT_RX.source, U);
+  while ((m = typeDefRe.exec(scanText)) !== null) {
+    pushModule(out, m[1], "default", "esm", true);
+  }
+  const tsEqRe = new RegExp(TS_IMPORT_EQUALS_RX.source, U);
+  while ((m = tsEqRe.exec(scanText)) !== null) {
+    pushModule(out, m[1], "default", "ts_import_equals");
+  }
+  const nsRe = new RegExp(NAMESPACE_IMPORT_RX.source, U);
+  while ((m = nsRe.exec(scanText)) !== null) {
+    const stmt = m[0];
+    if (isTypeOnlyImportStatement(stmt)) continue;
+    pushModule(out, m[1], "namespace", "esm");
+  }
+  const dnRe = new RegExp(DEFAULT_AND_NAMED_IMPORT_RX.source, U);
+  while ((m = dnRe.exec(scanText)) !== null) {
+    const stmt = m[0];
+    if (isTypeOnlyImportStatement(stmt)) continue;
+    pushModule(out, m[1], "default", "esm");
+    const clause = m[2];
+    for (const pair of parseEsmNamedImportClause(clause)) {
+      pushNamed(out, pair.imported, pair.local, "esm");
+    }
+    for (const local of parseEsmDefaultAsLocals(clause)) {
+      pushModule(out, local, "default", "esm");
+    }
+  }
+  const namedRe = new RegExp(NAMED_IMPORT_ONLY_RX.source, U);
+  while ((m = namedRe.exec(scanText)) !== null) {
+    const stmt = m[0];
+    if (isTypeOnlyImportStatement(stmt)) continue;
+    const clause = m[1];
+    for (const pair of parseEsmNamedImportClause(clause)) {
+      pushNamed(out, pair.imported, pair.local, "esm");
+    }
+    for (const local of parseEsmDefaultAsLocals(clause)) {
+      pushModule(out, local, "default", "esm");
+    }
+  }
+  const defRe = new RegExp(DEFAULT_IMPORT_ONLY_RX.source, U);
+  while ((m = defRe.exec(scanText)) !== null) {
+    const stmt = m[0];
+    if (isTypeOnlyImportStatement(stmt)) continue;
+    pushModule(out, m[1], "default", "esm");
+  }
+  const cjsDestRe = new RegExp(CJS_REQUIRE_DESTRUCT_RX.source, U);
+  while ((m = cjsDestRe.exec(scanText)) !== null) {
+    for (const pair of parseCjsDestructuringClause(m[1])) {
+      pushNamed(out, pair.imported, pair.local, "cjs_require");
+    }
+  }
+  const cjsModRe = new RegExp(CJS_REQUIRE_MODULE_RX.source, U);
+  while ((m = cjsModRe.exec(scanText)) !== null) {
+    const clauseStart = m.index;
+    const pre = scanText.slice(Math.max(0, clauseStart - 32), clauseStart + 1);
+    if (/\{\s*$/u.test(pre)) continue;
+    pushModule(out, m[1], "default", "cjs_require");
+  }
+  const dynDestRe = new RegExp(DYNAMIC_IMPORT_DESTRUCT_RX.source, U);
+  while ((m = dynDestRe.exec(scanText)) !== null) {
+    for (const pair of parseCjsDestructuringClause(m[1])) {
+      pushNamed(out, pair.imported, pair.local, "dynamic_import");
+    }
+  }
+  const dynModRe = new RegExp(DYNAMIC_IMPORT_MODULE_RX.source, U);
+  while ((m = dynModRe.exec(scanText)) !== null) {
+    const clauseStart = m.index;
+    const pre = scanText.slice(Math.max(0, clauseStart - 32), clauseStart + 1);
+    if (/\{\s*$/u.test(pre)) continue;
+    pushModule(out, m[1], "default", "dynamic_import");
+  }
+  return dedupeBindings(out);
+}
+function dedupeBindings(bindings) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const b of bindings) {
+    const key = b.kind === "named" ? `named:${b.source}:${b.imported}:${b.local}:${b.isTypeOnly === true ? "t" : "r"}` : `module:${b.source}:${b.local}:${b.moduleKind}:${b.isTypeOnly === true ? "t" : "r"}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(b);
+  }
+  return out;
+}
+
+// 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;
+  }
+};
+var DOCS_ISSUES_PAGE_PATH = "/issues";
+
+// src/shared/docs/issueAnchors.ts
+var DOC_ISSUE_PARENT_SEGMENTS = /* @__PURE__ */ new Set([
+  "cli",
+  "cleanup",
+  "config",
+  "context",
+  "doctor",
+  "generate",
+  "io",
+  "languages",
+  "locale",
+  "locales",
+  "missing",
+  "patching",
+  "paths",
+  "project",
+  "quality",
+  "report",
+  "scan",
+  "share",
+  "sync",
+  "translate",
+  "validate"
+]);
+function issueDocHeadingSlug(raw) {
+  return raw.toLowerCase().replace(/[.\s_]+/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function splitIssueCode(code) {
+  return code.trim().split(".");
+}
+function buildIssueCodeDocLinkParts(code) {
+  const trimmed = code.trim();
+  const parts = splitIssueCode(trimmed);
+  let parent = null;
+  if (parts.length >= 3 && parts[0] === "i18nprune") {
+    const p = parts[1];
+    if (DOC_ISSUE_PARENT_SEGMENTS.has(p)) parent = p;
+  }
+  let anchor;
+  if (parent) {
+    anchor = issueDocHeadingSlug(parts.slice(2).join("."));
+  } else {
+    anchor = issueDocHeadingSlug(trimmed.includes(".") ? trimmed.replace(/\./g, "_") : trimmed);
+  }
+  const sitePagePath = parent ? `${DOCS_ISSUES_PAGE_PATH}/${parent}` : DOCS_ISSUES_PAGE_PATH;
+  const repoDocPath = parent ? `issues/${parent}` : "issues";
+  return { parent, anchor, sitePagePath, repoDocPath };
+}
+function issueCodeRepoDocPathForIssueCode(code) {
+  return buildIssueCodeDocLinkParts(code).repoDocPath;
+}
+
+// src/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_SCAN_DYNAMIC_KEY_SITES = "i18nprune.scan.dynamic_key_sites";
+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_IO_READ_FAILED = "i18nprune.io.read_failed";
+
+// 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/options/runOptions.ts
+var run = {
+  json: false,
+  jsonPretty: true,
+  quiet: false,
+  silent: false,
+  debugScan: false,
+  debugCache: false,
+  onScanDebug: void 0
+};
+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();
+  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/extractor/shared/projectScan.ts
+function resolveScanIo(input) {
+  const { readFile, listFiles, runtime, path: pathOverride } = input;
+  const pathPort = runtime?.path ?? pathOverride;
+  if (readFile && listFiles) {
+    if (!pathPort) {
+      throw new I18nPruneError(
+        "scanProjectSourceFiles: with custom `readFile`/`listFiles`, pass `runtime` or `path` for display paths.",
+        "USAGE"
+      );
+    }
+    if (input.cwd !== void 0) {
+      return { cwd: input.cwd, listFiles, readFile, pathPort };
+    }
+    if (runtime) {
+      return { cwd: input.cwd ?? runtime.system.cwd(), listFiles, readFile, pathPort };
+    }
+    throw new I18nPruneError(
+      "scanProjectSourceFiles: when using custom `readFile` and `listFiles`, set `cwd` or pass `runtime` for `system.cwd()`.",
+      "USAGE"
+    );
+  }
+  if (readFile || listFiles) {
+    throw new I18nPruneError(
+      "scanProjectSourceFiles: provide both `readFile` and `listFiles`, or omit both and pass `runtime`.",
+      "USAGE"
+    );
+  }
+  if (!runtime) {
+    throw new I18nPruneError(
+      "scanProjectSourceFiles: pass `runtime` ({ fs, path, system }) or both `readFile` and `listFiles`.",
+      "USAGE"
+    );
+  }
+  const cwd = input.cwd ?? runtime.system.cwd();
+  return {
+    cwd,
+    listFiles: (srcRoot) => listSourceFiles(runtime, srcRoot, input.exclude, input.scanDebug ? { onScanDebug: input.scanDebug } : void 0),
+    readFile: (filePath) => readRuntimeFsTextSync(filePath, runtime.fs),
+    pathPort: runtime.path
+  };
+}
+function scanProjectSourceFiles(input) {
+  const { cwd, listFiles, readFile, pathPort } = resolveScanIo(input);
+  const files = listFiles(input.srcRoot);
+  const out = [];
+  for (const filePath of files) {
+    let text;
+    try {
+      text = readFile(filePath);
+    } catch {
+      continue;
+    }
+    const relFromSrc = pathPort.relative(input.srcRoot, filePath).replace(/\\/g, "/");
+    const displayPath = relFromSrc && !relFromSrc.startsWith("..") ? relFromSrc : (() => {
+      const relCwd = pathPort.relative(cwd, filePath);
+      return relCwd && !relCwd.startsWith("..") ? relCwd.replace(/\\/g, "/") : filePath;
+    })();
+    const rows = input.scanFile({ filePath, displayPath, text });
+    out.push(...rows);
+  }
+  return out;
+}
+
+// src/extractor/constmap/build.ts
+function buildConstStringMap(source) {
+  const map = {};
+  const re = /\bconst\s+([A-Za-z_$][\w$]*)(?:\s*:\s*[^=]+)?\s*=\s*(['"`])([^'"`]+)\2\s*;?/g;
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    map[m[1]] = m[3];
+  }
+  return map;
+}
+
+// src/extractor/shared/pattern.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildFunctionsPattern(functions) {
+  const parts = functions.map((f) => {
+    const escaped = escapeRegex(f);
+    return escaped.replace(/\\\./g, "\\.");
+  });
+  return `(?:${parts.join("|")})`;
+}
+
+// src/extractor/shared/calls.ts
+function findTranslationCallSites(text, functions) {
+  const out = [];
+  if (functions.length === 0) return out;
+  const fn = buildFunctionsPattern(functions);
+  const callStart = new RegExp(`\\b(${fn})\\s*\\(`, "g");
+  let m;
+  while ((m = callStart.exec(text)) !== null) {
+    const functionName = m[1];
+    const matchIndex = m.index;
+    const fnEsc = escapeRegex(functionName);
+    const decl = new RegExp(`\\b(?:export\\s+)?function\\s+${fnEsc}\\s*\\(`);
+    if (decl.test(text.slice(Math.max(0, matchIndex - 64), matchIndex + functionName.length + 2))) {
+      continue;
+    }
+    const openParenIndex = matchIndex + m[0].length - 1;
+    const closeParenIndex = findMatchingCloseParen(text, openParenIndex);
+    if (closeParenIndex === -1) continue;
+    const first = parseFirstArgument(text, openParenIndex, closeParenIndex);
+    if (!first.empty && firstArgLooksLikeAsciiLowercaseProse(first.raw)) {
+      continue;
+    }
+    out.push({
+      functionName,
+      matchIndex,
+      openParenIndex,
+      closeParenIndex,
+      firstArgStart: first.start,
+      firstArgEnd: first.end,
+      firstArgRaw: first.raw,
+      isEmptyCall: first.empty,
+      isMultilineCall: text.slice(matchIndex, closeParenIndex + 1).includes("\n")
+    });
+  }
+  return out;
+}
+function firstArgLooksLikeAsciiLowercaseProse(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return false;
+  if (!/\s/.test(trimmed)) return false;
+  const parts = trimmed.split(/\s+/).filter(Boolean);
+  if (parts.length < 2) return false;
+  for (const p of parts) {
+    if (!/^[a-z]+$/.test(p)) return false;
+  }
+  return true;
+}
+function findMatchingCloseParen(text, openParenIndex) {
+  let i = openParenIndex + 1;
+  let depth = 1;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "'" || c === '"') {
+      i = skipString2(text, i, c);
+      continue;
+    }
+    if (c === "`") {
+      i = skipTemplate2(text, i);
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      i = skipLineComment(text, i);
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i = skipBlockComment(text, i);
+      continue;
+    }
+    if (c === "(") depth += 1;
+    else if (c === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+    i += 1;
+  }
+  return -1;
+}
+function parseFirstArgument(text, openParenIndex, closeParenIndex) {
+  let i = skipTrivia(text, openParenIndex + 1, closeParenIndex);
+  if (i >= closeParenIndex) return { start: i, end: i, raw: "", empty: true };
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  const start = i;
+  while (i < closeParenIndex) {
+    const c = text[i];
+    if (c === "'" || c === '"') {
+      i = skipString2(text, i, c);
+      continue;
+    }
+    if (c === "`") {
+      i = skipTemplate2(text, i);
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      i = skipLineComment(text, i);
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i = skipBlockComment(text, i);
+      continue;
+    }
+    if (c === "(") parenDepth += 1;
+    else if (c === ")") {
+      if (parenDepth > 0) parenDepth -= 1;
+    } else if (c === "[") bracketDepth += 1;
+    else if (c === "]") {
+      if (bracketDepth > 0) bracketDepth -= 1;
+    } else if (c === "{") braceDepth += 1;
+    else if (c === "}") {
+      if (braceDepth > 0) braceDepth -= 1;
+    } else if (c === "," && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      break;
+    }
+    i += 1;
+  }
+  const end = rtrimIndex(text, start, i);
+  return {
+    start,
+    end,
+    raw: text.slice(start, end),
+    empty: false
+  };
+}
+function skipTrivia(text, start, end) {
+  let i = start;
+  while (i < end) {
+    const c = text[i];
+    if (/\s/.test(c)) {
+      i += 1;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      i = skipLineComment(text, i);
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i = skipBlockComment(text, i);
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function rtrimIndex(text, start, end) {
+  let i = end;
+  while (i > start && /\s/.test(text[i - 1])) i -= 1;
+  return i;
+}
+function skipLineComment(text, start) {
+  let i = start + 2;
+  while (i < text.length && text[i] !== "\n") i += 1;
+  return i;
+}
+function skipBlockComment(text, start) {
+  let i = start + 2;
+  while (i + 1 < text.length) {
+    if (text[i] === "*" && text[i + 1] === "/") return i + 2;
+    i += 1;
+  }
+  return text.length;
+}
+function skipString2(text, start, quote) {
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+    i += 1;
+  }
+  return text.length;
+}
+function skipTemplate2(text, start) {
+  let i = start + 1;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") return i + 1;
+    if (ch === "$" && text[i + 1] === "{") {
+      i += 2;
+      let depth = 1;
+      while (i < text.length && depth > 0) {
+        const c2 = text[i];
+        if (c2 === "'" || c2 === '"') {
+          i = skipString2(text, i, c2);
+          continue;
+        }
+        if (c2 === "`") {
+          i = skipTemplate2(text, i);
+          continue;
+        }
+        if (c2 === "/" && text[i + 1] === "/") {
+          i = skipLineComment(text, i);
+          continue;
+        }
+        if (c2 === "/" && text[i + 1] === "*") {
+          i = skipBlockComment(text, i);
+          continue;
+        }
+        if (c2 === "{") depth += 1;
+        else if (c2 === "}") depth -= 1;
+        i += 1;
+      }
+      continue;
+    }
+    i += 1;
+  }
+  return text.length;
+}
+
+// src/extractor/dynamic/helpers.ts
+function snippetRange(text, start, end, maxLen) {
+  const boundedEnd = Math.max(start, Math.min(end, text.length));
+  const slice = text.slice(start, boundedEnd).replace(/\s+/g, " ").trim();
+  if (slice.length <= maxLen) return slice;
+  return `${slice.slice(0, maxLen - 1)}\u2026`;
+}
+function offsetToLineColumn(text, offset) {
+  let line = 1;
+  let col = 1;
+  for (let i = 0; i < offset && i < text.length; i += 1) {
+    const c = text[i];
+    if (c === "\n") {
+      line += 1;
+      col = 1;
+    } else {
+      col += 1;
+    }
+  }
+  return { line, column: col };
+}
+
+// src/extractor/constmap/resolve.ts
+function resolveKeyPlaceholdersWithTrace(fragment, constMap) {
+  let out = fragment;
+  const substitutions = [];
+  const re = /\$\{([A-Za-z_$][\w$]*)\}/;
+  for (let i = 0; i < 64; i += 1) {
+    const m = re.exec(out);
+    if (!m) break;
+    const name = m[1];
+    const val = constMap[name];
+    if (val === void 0) {
+      return { resolved: null, substitutions, remainder: out };
+    }
+    substitutions.push({ identifier: name, value: val });
+    out = out.replace(m[0], val);
+  }
+  if (/\$\{[^}]+\}/.test(out)) {
+    return { resolved: null, substitutions, remainder: out };
+  }
+  return { resolved: out, substitutions, remainder: out };
+}
+
+// src/extractor/dynamic/rebuild.ts
+function tryRebuildTemplateKeyFromConsts(inner, constMap) {
+  return resolveKeyPlaceholdersWithTrace(inner, constMap).resolved;
+}
+function tryResolveTemplatePrefixBeforeUnknown(inner, constMap) {
+  const interpRe = /\$\{([^}]+)\}/g;
+  const matches = [...inner.matchAll(interpRe)];
+  if (matches.length === 0) {
+    const t = inner.trim();
+    return t.includes(".") ? t : null;
+  }
+  let cutIndex = -1;
+  for (const m of matches) {
+    const expr = m[1]?.trim();
+    const ident = expr?.match(/^[A-Za-z_$][\w$]*$/)?.[0];
+    if (!ident) {
+      cutIndex = m.index ?? -1;
+      break;
+    }
+    if (!Object.prototype.hasOwnProperty.call(constMap, ident)) {
+      cutIndex = m.index ?? -1;
+      break;
+    }
+  }
+  const prefix = (cutIndex === -1 ? inner : inner.slice(0, cutIndex)).trim();
+  const resolved = prefix.replace(/\$\{([^}]+)\}/g, (whole, innerExpr) => {
+    const ident = String(innerExpr).trim();
+    if (/^[A-Za-z_$][\w$]*$/.test(ident) && Object.prototype.hasOwnProperty.call(constMap, ident)) {
+      return constMap[ident];
+    }
+    return whole;
+  });
+  const trimmed = resolved.replace(/\.$/, "").trim();
+  if (!trimmed.includes(".")) return null;
+  return trimmed;
+}
+
+// src/extractor/dynamic/providers/javascript.ts
+var PREVIEW = 72;
+var JAVASCRIPT_LIKE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte"
+]);
+function isJavascriptLikePath(filePath) {
+  const lower = filePath.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  if (dot < 0) return false;
+  return JAVASCRIPT_LIKE_EXTENSIONS.has(lower.slice(dot));
+}
+function findDynamicKeySitesInJavascriptFile(text, functions, filePath) {
+  const commentRanges = commentRangesForJsLikeText(text);
+  const constMap = buildConstStringMap(text);
+  const raw = findDynamicKeySitesRaw(text, functions, constMap);
+  const out = [];
+  for (const site of raw) {
+    const at = site.matchIndex;
+    const commented = offsetInCommentRanges(at, commentRanges);
+    const { line, column } = offsetToLineColumn(text, at);
+    const kind = commented ? "commented" : site.kind;
+    out.push({
+      kind,
+      functionName: site.functionName,
+      preview: snippetRange(text, at, site.closeParenIndex + 1, PREVIEW),
+      filePath,
+      line,
+      column,
+      isMultilineCall: site.isMultilineCall,
+      isCommented: commented,
+      isSourceFile: true,
+      ...site.resolvedPrefix !== void 0 ? { resolvedPrefix: site.resolvedPrefix } : {}
+    });
+  }
+  return out;
+}
+function findDynamicKeySitesRaw(text, functions, constMap) {
+  const out = [];
+  const calls = findTranslationCallSites(text, functions);
+  for (const call of calls) {
+    const at = call.matchIndex;
+    if (call.isEmptyCall) {
+      out.push({
+        kind: "empty_call",
+        functionName: call.functionName,
+        matchIndex: at,
+        closeParenIndex: call.closeParenIndex,
+        isMultilineCall: call.isMultilineCall
+      });
+      continue;
+    }
+    const arg = call.firstArgRaw.trim();
+    const first = arg[0];
+    if (first === "'" || first === '"') continue;
+    if (first === "`" && arg.endsWith("`")) {
+      const inner = arg.slice(1, -1);
+      if (!/\$\{/.test(inner)) continue;
+      const rebuilt = tryRebuildTemplateKeyFromConsts(inner, constMap);
+      if (rebuilt !== null) continue;
+      const resolvedPrefix = tryResolveTemplatePrefixBeforeUnknown(inner, constMap) ?? void 0;
+      out.push({
+        kind: "template_interpolation",
+        functionName: call.functionName,
+        matchIndex: at,
+        closeParenIndex: call.closeParenIndex,
+        isMultilineCall: call.isMultilineCall,
+        ...resolvedPrefix !== void 0 ? { resolvedPrefix } : {}
+      });
+      continue;
+    }
+    out.push({
+      kind: "non_literal",
+      functionName: call.functionName,
+      matchIndex: at,
+      closeParenIndex: call.closeParenIndex,
+      isMultilineCall: call.isMultilineCall
+    });
+  }
+  return out;
+}
+
+// src/extractor/dynamic/providers/index.ts
+function findDynamicKeySitesForFile(filePath, content, functions) {
+  if (!isJavascriptLikePath(filePath)) {
+    return [];
+  }
+  return findDynamicKeySitesInJavascriptFile(content, functions, filePath);
+}
+
+// src/extractor/dynamic/orchestrate.ts
+function scanProjectDynamicKeySites(input) {
+  return scanProjectSourceFiles({
+    srcRoot: input.srcRoot,
+    cwd: input.cwd,
+    runtime: input.runtime,
+    path: input.path,
+    readFile: input.readFile,
+    listFiles: input.listFiles,
+    exclude: input.exclude,
+    scanFile: ({ filePath, displayPath, text }) => {
+      const functions = expandFunctionsWithBindings(input.functions, scanImportBindings(text));
+      const sites = findDynamicKeySitesForFile(filePath, text, functions);
+      return sites.map((site) => ({ ...site, filePath: displayPath }));
+    }
+  });
+}
+
+// src/extractor/keySites/line.ts
+function lineNumberAtIndex(text, index) {
+  if (index <= 0) return 1;
+  let line = 1;
+  const end = Math.min(index, text.length);
+  for (let i = 0; i < end; i++) {
+    if (text.charCodeAt(i) === 10) line += 1;
+  }
+  return line;
+}
+
+// src/extractor/keySites/scan.ts
+function spanAtOffset(text, offset, functionName, isMultilineCall) {
+  return {
+    line: lineNumberAtIndex(text, offset),
+    functionName,
+    isMultilineCall,
+    charOffset: offset
+  };
+}
+function scanKeyObservations(text, functions, constMap, options) {
+  const out = [];
+  const calls = findTranslationCallSites(text, functions);
+  const ranges = options?.commentRanges;
+  for (const call of calls) {
+    if (ranges?.length && offsetInCommentRanges(call.matchIndex, ranges)) continue;
+    if (call.isEmptyCall) continue;
+    const arg = call.firstArgRaw.trim();
+    const stringMatch = arg.match(/^(['"])([\s\S]*)\1$/);
+    if (stringMatch) {
+      const key = stringMatch[2];
+      out.push({
+        kind: "literal",
+        resolvedKey: key,
+        raw: key,
+        span: spanAtOffset(text, call.matchIndex, call.functionName, call.isMultilineCall)
+      });
+      continue;
+    }
+    const tplMatch = arg.match(/^`([\s\S]*)`$/);
+    if (!tplMatch) continue;
+    const templateRaw = tplMatch[1];
+    const trace = resolveKeyPlaceholdersWithTrace(templateRaw, constMap);
+    const span = spanAtOffset(text, call.matchIndex, call.functionName, call.isMultilineCall);
+    if (trace.resolved !== null) {
+      out.push({
+        kind: "template_resolved",
+        resolvedKey: trace.resolved,
+        templateRaw,
+        substitutions: trace.substitutions,
+        span
+      });
+    } else {
+      const unresolved = [];
+      const rem = trace.remainder;
+      const ph = /\$\{([A-Za-z_$][\w$]*)\}/g;
+      let pm;
+      while ((pm = ph.exec(rem)) !== null) {
+        unresolved.push(pm[1]);
+      }
+      const uncertainPrefix = tryResolveTemplatePrefixBeforeUnknown(templateRaw, constMap) ?? void 0;
+      out.push({
+        kind: "template_partial",
+        templateRaw,
+        substitutions: trace.substitutions,
+        unresolvedPlaceholders: unresolved,
+        span,
+        ...uncertainPrefix !== void 0 ? { uncertainPrefix } : {}
+      });
+    }
+  }
+  return out;
+}
+
+// src/extractor/keySites/orchestrate.ts
+function scanProjectKeyObservations(input) {
+  return scanProjectSourceFiles({
+    srcRoot: input.srcRoot,
+    cwd: input.cwd,
+    runtime: input.runtime,
+    path: input.path,
+    readFile: input.readFile,
+    listFiles: input.listFiles,
+    exclude: input.exclude,
+    scanFile: ({ text, displayPath }) => {
+      const functions = expandFunctionsWithBindings(input.functions, scanImportBindings(text));
+      const constMap = buildConstStringMap(text);
+      const commentRanges = commentRangesForJsLikeText(text);
+      const observations = scanKeyObservations(text, functions, constMap, {
+        commentRanges
+      });
+      return observations.map((obs) => ({
+        ...obs,
+        span: { ...obs.span, filePath: displayPath }
+      }));
+    }
+  });
+}
+
+// src/extractor/keySites/projectUsage.ts
+function topPathSegment(path) {
+  const first = path.split(/[.[\]]/).find(Boolean);
+  return first ?? null;
+}
+function literalKeyUsageFromObservations(observations) {
+  const resolvedKeys = /* @__PURE__ */ new Set();
+  const uncertainPrefixes = /* @__PURE__ */ new Set();
+  const usedRoots = /* @__PURE__ */ new Set();
+  for (const o of observations) {
+    if (o.kind === "literal" || o.kind === "template_resolved") {
+      resolvedKeys.add(o.resolvedKey);
+      const root = topPathSegment(o.resolvedKey);
+      if (root) usedRoots.add(root);
+      continue;
+    }
+    if (o.kind === "template_partial" && o.uncertainPrefix) {
+      uncertainPrefixes.add(o.uncertainPrefix);
+      const root = topPathSegment(o.uncertainPrefix);
+      if (root) usedRoots.add(root);
+    }
+  }
+  return { resolvedKeys, uncertainPrefixes, usedRoots };
+}
+
+// src/shared/reference/context.ts
+function pushUnique(out, v) {
+  if (!v || out.includes(v)) return;
+  out.push(v);
+}
+function includeDynamicSite(site, eff) {
+  if ((site.kind === "commented" || site.isCommented) && !eff.treatCommentedCallSitesAsRuntime) return false;
+  if (site.isSourceFile === false && !eff.treatNonSourceFileSitesAsRuntime) return false;
+  return true;
+}
+function collectUncertainPrefixesFromDynamic(sites, out, eff) {
+  for (const site of sites) {
+    if (!includeDynamicSite(site, eff)) continue;
+    if (site.resolvedPrefix) pushUnique(out, site.resolvedPrefix);
+  }
+}
+function buildKeyReferenceContextFromLiteralUsageAndDynamicSites(usage, dynamicSites, eff) {
+  const uncertainPrefixes = [];
+  for (const p of usage.uncertainPrefixes) pushUnique(uncertainPrefixes, p);
+  collectUncertainPrefixesFromDynamic([...dynamicSites], uncertainPrefixes, eff);
+  return { provenKeys: usage.resolvedKeys, uncertainPrefixes };
+}
+function buildKeyReferenceContextFromReportDetails(observations, dynamicSites, eff) {
+  const usage = literalKeyUsageFromObservations([...observations]);
+  return buildKeyReferenceContextFromLiteralUsageAndDynamicSites(usage, dynamicSites, eff);
+}
+
+// src/shared/reference/resolveConfig.ts
+var BASE = {
+  treatCommentedCallSitesAsRuntime: false,
+  treatNonSourceFileSitesAsRuntime: false,
+  uncertainKeyPolicy: "protect",
+  stringPresence: "guard",
+  stringPresenceMaxHitsPerKey: 5,
+  respectPreserve: true
+};
+function resolveReferenceConfig(operation, config) {
+  const ref = config.reference;
+  const d = ref?.defaults ?? {};
+  const cmds = ref?.commands;
+  const cmd = cmds?.[operation] ?? {};
+  const merged = { ...BASE, ...d, ...cmd };
+  return {
+    treatCommentedCallSitesAsRuntime: merged.treatCommentedCallSitesAsRuntime ?? BASE.treatCommentedCallSitesAsRuntime,
+    treatNonSourceFileSitesAsRuntime: merged.treatNonSourceFileSitesAsRuntime ?? BASE.treatNonSourceFileSitesAsRuntime,
+    uncertainKeyPolicy: merged.uncertainKeyPolicy ?? BASE.uncertainKeyPolicy,
+    stringPresence: merged.stringPresence ?? BASE.stringPresence,
+    stringPresenceMaxHitsPerKey: merged.stringPresenceMaxHitsPerKey ?? BASE.stringPresenceMaxHitsPerKey,
+    respectPreserve: merged.respectPreserve ?? BASE.respectPreserve
+  };
+}
+
+// src/shared/path/posix.ts
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/shared/path/platform.ts
+function normalizePathKeyForCache(projectRoot) {
+  return toPosixPath(projectRoot).normalize("NFC").toLowerCase();
+}
+
+// src/cache/io/hash.ts
+function fallbackHashText(text) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= BigInt(text.charCodeAt(i));
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function normalizeProjectRoot(projectRoot, pathPort) {
+  const resolved = pathPort ? pathPort.resolve(projectRoot) : projectRoot;
+  return normalizePathKeyForCache(resolved);
+}
+function computeCacheProjectId(projectRoot, input = {}) {
+  return (input.hashText ?? fallbackHashText)(normalizeProjectRoot(projectRoot, input.path)).slice(0, 16);
+}
+function computeCacheContentHash(text, hashText) {
+  return (hashText ?? fallbackHashText)(text);
+}
+
+// src/cache/io/helpers.ts
+function nowIso(runtime) {
+  return new Date(runtime?.system.now() ?? Date.now()).toISOString();
+}
+function textByteLength(text, runtime) {
+  return runtime.byteLength ? runtime.byteLength(text) : new TextEncoder().encode(text).length;
+}
+function readJsonFileWithLimit(filePath, maxBytes, runtime) {
+  try {
+    if (!assertSyncPortResult(runtime.fs.exists(filePath), "fs.exists", filePath)) return {};
+    const kind = assertSyncPortResult(runtime.fs.statKind(filePath), "fs.statKind", filePath);
+    if (kind !== "file") {
+      return {
+        warning: {
+          code: "cache_io_error",
+          message: "cache path is not a file; skipping",
+          path: filePath
+        }
+      };
+    }
+    const knownSize = runtime.fileSize?.(filePath);
+    if (knownSize !== void 0 && knownSize > maxBytes) {
+      return {
+        warning: {
+          code: "cache_oversize",
+          message: `cache file exceeds size limit (${String(knownSize)} > ${String(maxBytes)} bytes); skipping`,
+          path: filePath
+        }
+      };
+    }
+    const raw = assertSyncPortResult(runtime.fs.readText(filePath), "fs.readText", filePath);
+    const size = knownSize ?? textByteLength(raw, runtime);
+    if (size > maxBytes) {
+      return {
+        warning: {
+          code: "cache_oversize",
+          message: `cache file exceeds size limit (${String(size)} > ${String(maxBytes)} bytes); skipping`,
+          path: filePath
+        }
+      };
+    }
+    const parsed = tryParseJsonText(raw, { filePath, issueCode: "i18nprune.cache.json" });
+    if (!parsed.ok) {
+      return {
+        warning: {
+          code: "cache_malformed",
+          message: parsed.error.message,
+          path: filePath
+        }
+      };
+    }
+    return { data: parsed.data };
+  } catch (err) {
+    return {
+      warning: {
+        code: "cache_io_error",
+        message: `cache read error: ${err instanceof Error ? err.message : String(err)}`,
+        path: filePath
+      }
+    };
+  }
+}
+function writeJsonAtomic(filePath, data, runtime) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    if (runtime.writeTextAtomic) {
+      runtime.writeTextAtomic(filePath, content);
+      return void 0;
+    }
+    assertSyncPortResult(runtime.fs.mkdirp(runtime.path.dirname(filePath)), "fs.mkdirp", runtime.path.dirname(filePath));
+    assertSyncPortResult(runtime.fs.writeText(filePath, content), "fs.writeText", filePath);
+    return void 0;
+  } catch (err) {
+    return {
+      code: "cache_io_error",
+      message: `cache write error: ${err instanceof Error ? err.message : String(err)}`,
+      path: filePath
+    };
+  }
+}
+
+// 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 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/cache/setup/policy.ts
+function isProjectCacheWritable(state) {
+  return state.enabled && !state.readOnly;
+}
+function isFileRecordMap(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateProjectFilesPayload(data, _filePath) {
+  if (!data || typeof data !== "object") {
+    return { ok: false, message: "root is not an object" };
+  }
+  const o = data;
+  if (!isFileRecordMap(o.files)) {
+    return { ok: false, message: "missing or invalid field: files" };
+  }
+  if (o.localeSegments !== void 0 && !isFileRecordMap(o.localeSegments)) {
+    return { ok: false, message: "invalid field: localeSegments" };
+  }
+  if (o.localesLayout !== void 0) {
+    const layout = o.localesLayout;
+    if (!layout || typeof layout !== "object" || typeof layout.mode !== "string" || typeof layout.structure !== "string" || typeof layout.directory !== "string" || typeof layout.source !== "string") {
+      return { ok: false, message: "invalid field: localesLayout" };
+    }
+  }
+  if (o.version !== void 0 && o.version !== CACHE_SCHEMA_VERSION) {
+    return { ok: false, message: `unsupported cache schema version: ${String(o.version)}` };
+  }
+  return { ok: true, files: data };
+}
+function validateProjectRunEnvelope(data, _filePath) {
+  if (!data || typeof data !== "object") {
+    return { ok: false, message: "root is not an object" };
+  }
+  const o = data;
+  if (!("data" in o)) {
+    return { ok: false, message: "missing required field: data" };
+  }
+  if (o.inputFilesEpoch !== void 0 && typeof o.inputFilesEpoch !== "string") {
+    return { ok: false, message: "invalid field type: inputFilesEpoch" };
+  }
+  return { ok: true, run: data };
+}
+function loadProjectRunEnvelope(state, runtime) {
+  const warnings = [];
+  const filePath = state.analysisPath;
+  const { data, warning } = readJsonFileWithLimit(filePath, MAX_ANALYSIS_BYTES, runtime);
+  if (warning) {
+    warnings.push({ ...warning, path: filePath });
+    return { warnings };
+  }
+  if (data === void 0) return { warnings };
+  const validated = validateProjectRunEnvelope(data);
+  if (!validated.ok) {
+    warnings.push({
+      code: "cache_malformed",
+      message: `cache analysis envelope invalid (${validated.message})`,
+      path: filePath
+    });
+    return { warnings };
+  }
+  return { run: validated.run, warnings };
+}
+function tryDeleteCacheFile(runtime, filePath) {
+  try {
+    if (!assertSyncPortResult(runtime.fs.exists(filePath), "fs.exists", filePath)) return;
+    assertSyncPortResult(runtime.fs.deleteFile(filePath), "fs.deleteFile", filePath);
+  } catch {
+  }
+}
+
+// src/cache/io/projects.ts
+function defaultProjectsIndex(runtime) {
+  return {
+    version: CACHE_SCHEMA_VERSION,
+    updatedAt: nowIso(runtime),
+    projects: {},
+    maintenance: { runCount: 0, healEveryRuns: DEFAULT_HEAL_EVERY_RUNS }
+  };
+}
+function loadProjectsIndex(state, runtime) {
+  const warnings = [];
+  if (!state.enabled) return { index: defaultProjectsIndex(runtime), warnings };
+  const { data, warning } = readJsonFileWithLimit(state.metaPath, MAX_PROJECTS_INDEX_BYTES, runtime);
+  if (warning) warnings.push(warning);
+  if (!data || typeof data !== "object" || typeof data.projects !== "object" || typeof data.maintenance !== "object" || typeof data.maintenance.runCount !== "number" || typeof data.maintenance.healEveryRuns !== "number") {
+    return { index: defaultProjectsIndex(runtime), warnings };
+  }
+  return { index: data, warnings };
+}
+function saveProjectsIndex(state, index, runtime) {
+  if (!state.enabled) return void 0;
+  if (!isProjectCacheWritable(state)) {
+    return {
+      code: "cache_read_only",
+      message: "cache is read-only; skipped persisting meta index",
+      path: state.metaPath
+    };
+  }
+  return writeJsonAtomic(state.metaPath, { ...index, updatedAt: nowIso(runtime), version: CACHE_SCHEMA_VERSION }, runtime);
+}
+function normalizeProjectRootKey(projectRoot) {
+  const normalized = toPosixPath(projectRoot).normalize("NFC").replace(/\/+$/g, "");
+  return `${normalized}/`;
+}
+function touchProjectIndex(state, index, runtime) {
+  const next = {
+    ...index,
+    projects: { ...index.projects },
+    maintenance: { ...index.maintenance }
+  };
+  const key = normalizeProjectRootKey(state.projectRoot);
+  next.projects[key] = computeCacheProjectId(state.projectRoot, {
+    path: runtime?.path,
+    hashText: runtime?.hashText
+  });
+  next.maintenance.runCount += 1;
+  return next;
+}
+function shouldHeal(index) {
+  const every = Math.max(1, Math.trunc(index.maintenance.healEveryRuns || DEFAULT_HEAL_EVERY_RUNS));
+  return index.maintenance.runCount % every === 0;
+}
+function maybeHealCacheIndex(state, index, runtime) {
+  const warnings = [];
+  if (!state.enabled || !shouldHeal(index)) {
+    return { index, warnings, healed: false };
+  }
+  const next = {
+    ...index,
+    projects: { ...index.projects },
+    maintenance: { ...index.maintenance, lastHealAt: nowIso(runtime) }
+  };
+  const projectsRoot = runtime.path.join(state.rootDir, "projects");
+  for (const [projectRoot, id] of Object.entries(next.projects)) {
+    const projectDir = runtime.path.join(projectsRoot, id);
+    const kind = assertSyncPortResult(runtime.fs.statKind(projectDir), "fs.statKind", projectDir);
+    if (kind !== "directory") {
+      delete next.projects[projectRoot];
+    }
+  }
+  const referencedIds = new Set(Object.values(next.projects));
+  try {
+    if (assertSyncPortResult(runtime.fs.exists(projectsRoot), "fs.exists", projectsRoot)) {
+      const dirs = assertSyncPortResult(runtime.fs.listDir(projectsRoot), "fs.listDir", projectsRoot);
+      for (const entry of dirs) {
+        if (entry.kind !== "directory") continue;
+        if (referencedIds.has(entry.name)) continue;
+        const orphanDir = runtime.path.join(projectsRoot, entry.name);
+        if (!runtime.deleteDir) continue;
+        runtime.deleteDir(orphanDir);
+      }
+    }
+  } catch (err) {
+    warnings.push({
+      code: "cache_io_error",
+      message: `cache self-heal failed: ${err instanceof Error ? err.message : String(err)}`,
+      path: projectsRoot
+    });
+  }
+  return { index: next, warnings, healed: true };
+}
+
+// src/cache/io/state.ts
+function defaultProjectFilesState(runtime) {
+  return { version: CACHE_SCHEMA_VERSION, updatedAt: nowIso(runtime), files: {} };
+}
+function loadProjectFilesState(state, runtime) {
+  const warnings = [];
+  if (!state.enabled) return { files: defaultProjectFilesState(runtime), warnings };
+  const { data, warning } = readJsonFileWithLimit(state.filesPath, MAX_PROJECT_FILES_BYTES, runtime);
+  if (warning) warnings.push(warning);
+  if (data === void 0) {
+    return { files: defaultProjectFilesState(runtime), warnings };
+  }
+  const validated = validateProjectFilesPayload(data, state.filesPath);
+  if (!validated.ok) {
+    warnings.push({
+      code: "cache_malformed",
+      message: `cache files index invalid (${validated.message})`,
+      path: state.filesPath
+    });
+    return { files: defaultProjectFilesState(runtime), warnings };
+  }
+  return { files: validated.files, warnings };
+}
+function saveProjectFilesState(state, files, runtime) {
+  if (!state.enabled) return void 0;
+  if (!isProjectCacheWritable(state)) {
+    return {
+      code: "cache_read_only",
+      message: "cache is read-only; skipped persisting files index",
+      path: state.filesPath
+    };
+  }
+  return writeJsonAtomic(state.filesPath, { ...files, updatedAt: nowIso(runtime), version: CACHE_SCHEMA_VERSION }, runtime);
+}
+function loadProjectRunState(state, runtime) {
+  if (!state.enabled) return { warnings: [] };
+  return loadProjectRunEnvelope(state, runtime);
+}
+function saveProjectRunState(state, runtime, input) {
+  if (!state.enabled) return void 0;
+  if (!isProjectCacheWritable(state)) {
+    return {
+      code: "cache_read_only",
+      message: "cache is read-only; skipped persisting analysis cache",
+      path: state.analysisPath
+    };
+  }
+  const payload = {
+    version: CACHE_SCHEMA_VERSION,
+    updatedAt: nowIso(runtime),
+    projectId: state.projectId,
+    data: input.data,
+    ...input.inputFilesEpoch !== void 0 ? { inputFilesEpoch: input.inputFilesEpoch } : {}
+  };
+  return writeJsonAtomic(state.analysisPath, payload, runtime);
+}
+
+// src/translator/cache/l2Io.ts
+function isTranslationCacheEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const o = value;
+  return typeof o.text === "string" && typeof o.leafMeta === "object" && o.leafMeta !== null && typeof o.providerId === "string" && typeof o.createdAt === "string";
+}
+function isTranslationProviderId(value) {
+  return value === "google" || value === "mymemory" || value === "deepl" || value === "libre" || value === "llm";
+}
+function validateTranslationLocaleCacheFile(data, _filePath) {
+  if (!data || typeof data !== "object") {
+    return { ok: false, message: "root is not an object" };
+  }
+  const o = data;
+  if (typeof o.targetLang !== "string") {
+    return { ok: false, message: "missing or invalid field: targetLang" };
+  }
+  if (typeof o.translateConfigEpoch !== "string") {
+    return { ok: false, message: "missing or invalid field: translateConfigEpoch" };
+  }
+  if (typeof o.inputFilesEpoch !== "string") {
+    return { ok: false, message: "missing or invalid field: inputFilesEpoch" };
+  }
+  if (!o.entries || typeof o.entries !== "object" || Array.isArray(o.entries)) {
+    return { ok: false, message: "missing or invalid field: entries" };
+  }
+  for (const entry of Object.values(o.entries)) {
+    if (!isTranslationCacheEntry(entry)) {
+      return { ok: false, message: "invalid translation cache entry" };
+    }
+    if (!isTranslationProviderId(entry.providerId)) {
+      return { ok: false, message: "invalid translation cache entry providerId" };
+    }
+  }
+  if (o.version !== void 0 && o.version !== CACHE_SCHEMA_VERSION) {
+    return { ok: false, message: `unsupported cache schema version: ${String(o.version)}` };
+  }
+  return { ok: true, state: data };
+}
+function loadTranslationLocaleCacheFile(filePath, runtime) {
+  const warnings = [];
+  const { data, warning } = readJsonFileWithLimit(filePath, MAX_TRANSLATIONS_CACHE_BYTES, runtime);
+  if (warning) {
+    warnings.push({ ...warning, path: filePath });
+    return { warnings };
+  }
+  if (data === void 0) return { warnings };
+  const validated = validateTranslationLocaleCacheFile(data);
+  if (!validated.ok) {
+    warnings.push({
+      code: "cache_malformed",
+      message: `cache translations store invalid (${validated.message})`,
+      path: filePath
+    });
+    return { warnings };
+  }
+  return { locale: validated.state, warnings };
+}
+
+// src/translator/cache/paths.ts
+function resolveTranslationsDir(state, runtime) {
+  return runtime.path.join(state.projectDir, TRANSLATIONS_DIR);
+}
+
+// src/translator/cache/maintenance.ts
+function prepareTranslationCacheLayout(state, runtime) {
+  const warnings = [];
+  if (!state.enabled) return warnings;
+  const translationsDir = resolveTranslationsDir(state, runtime);
+  try {
+    assertSyncPortResult(runtime.fs.mkdirp(translationsDir), "fs.mkdirp", translationsDir);
+  } catch (err) {
+    warnings.push({
+      code: "cache_dir_unavailable",
+      message: `unable to create translations cache dir: ${err instanceof Error ? err.message : String(err)}`,
+      path: translationsDir
+    });
+    return warnings;
+  }
+  return [...warnings, ...healTranslationCacheFiles(state, runtime)];
+}
+function healTranslationCacheFiles(state, runtime) {
+  const warnings = [];
+  if (!state.enabled) return warnings;
+  const translationsDir = resolveTranslationsDir(state, runtime);
+  let entries = [];
+  try {
+    const kind = assertSyncPortResult(runtime.fs.statKind(translationsDir), "fs.statKind", translationsDir);
+    if (kind !== "directory") return warnings;
+    entries = assertSyncPortResult(runtime.fs.listDir(translationsDir), "fs.listDir", translationsDir);
+  } catch {
+    return warnings;
+  }
+  for (const entry of entries) {
+    if (entry.kind !== "file" || !entry.name.endsWith(".json")) continue;
+    const filePath = runtime.path.join(translationsDir, entry.name);
+    const loaded = loadTranslationLocaleCacheFile(filePath, runtime);
+    warnings.push(...loaded.warnings);
+    const invalid = loaded.warnings.some((w) => w.code === "cache_malformed" || w.code === "cache_oversize");
+    if (invalid) {
+      tryDeleteCacheFile(runtime, filePath);
+    }
+  }
+  return warnings;
+}
+
+// src/cache/setup/maintenance.ts
+function prepareCacheForRun(state, runtime) {
+  const warnings = [];
+  const loaded = loadProjectsIndex(state, runtime);
+  warnings.push(...loaded.warnings);
+  const touched = touchProjectIndex(state, loaded.index, runtime);
+  const healed = maybeHealCacheIndex(state, touched, runtime);
+  warnings.push(...healed.warnings);
+  const saveWarn = saveProjectsIndex(state, healed.index, runtime);
+  if (saveWarn) warnings.push(saveWarn);
+  try {
+    assertSyncPortResult(runtime.fs.mkdirp(state.projectDir), "fs.mkdirp", state.projectDir);
+  } catch (err) {
+    warnings.push({
+      code: "cache_dir_unavailable",
+      message: `unable to create cache project dir: ${err instanceof Error ? err.message : String(err)}`,
+      path: state.projectDir
+    });
+    return { index: healed.index, warnings };
+  }
+  const fileState = loadProjectFilesState(state, runtime);
+  warnings.push(...fileState.warnings);
+  const analysisState = loadProjectRunState(state, runtime);
+  warnings.push(...analysisState.warnings);
+  warnings.push(...prepareTranslationCacheLayout(state, runtime));
+  const hasInvalidFiles = fileState.warnings.some((w) => w.code === "cache_malformed" || w.code === "cache_oversize");
+  const hasInvalidAnalysis = analysisState.warnings.some((w) => w.code === "cache_malformed" || w.code === "cache_oversize");
+  if (hasInvalidFiles) {
+    try {
+      assertSyncPortResult(runtime.fs.deleteFile(state.filesPath), "fs.deleteFile", state.filesPath);
+    } catch {
+    }
+  }
+  if (hasInvalidAnalysis) {
+    tryDeleteCacheFile(runtime, state.analysisPath);
+  }
+  try {
+    assertSyncPortResult(runtime.fs.mkdirp(runtime.path.dirname(state.filesPath)), "fs.mkdirp", runtime.path.dirname(state.filesPath));
+  } catch {
+  }
+  return { index: healed.index, warnings };
+}
+
+// src/cache/engine.ts
+function computeInputFilesEpoch(files, hashText) {
+  const keys = Object.keys(files).sort();
+  const canonical = keys.map((k) => {
+    const r = files[k];
+    return `${k}	${r.hash}	${String(r.size)}
+`;
+  }).join("");
+  return computeCacheContentHash(canonical, hashText);
+}
+function diffProjectFiles(previous, current) {
+  const added = [];
+  const changed = [];
+  const deleted = [];
+  const unchanged = [];
+  for (const [k, next] of Object.entries(current)) {
+    const prev = previous[k];
+    if (!prev) {
+      added.push(k);
+      continue;
+    }
+    if (prev.hash !== next.hash || prev.size !== next.size || prev.mtimeMs !== next.mtimeMs) {
+      changed.push(k);
+    } else {
+      unchanged.push(k);
+    }
+  }
+  for (const k of Object.keys(previous)) {
+    if (!(k in current)) deleted.push(k);
+  }
+  return { added, changed, deleted, unchanged };
+}
+
+// src/cache/localesLayout.ts
+function resolveCachedLocalesLayout(locales) {
+  return {
+    mode: locales.mode ?? "flat_file",
+    structure: locales.structure ?? "locale_file",
+    directory: locales.directory,
+    source: locales.source
+  };
+}
+function layoutMatches(a, b) {
+  if (a === void 0) return false;
+  return a.mode === b.mode && a.structure === b.structure && a.directory === b.directory && a.source === b.source;
+}
+
+// src/shared/locales/diagnostics/structuralParity.ts
+function localeStructuralSlot(structure, relativePath) {
+  if (structure === "locale_per_dir") {
+    const slash = relativePath.indexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(slash + 1);
+    return slot.length > 0 ? slot : null;
+  }
+  if (structure === "feature_bundle") {
+    const slash = relativePath.lastIndexOf("/");
+    if (slash < 0) return null;
+    const slot = relativePath.slice(0, slash);
+    return slot.length > 0 ? slot : null;
+  }
+  return null;
+}
+function slotsByLocale(structure, segments) {
+  const byLocale = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const slot = localeStructuralSlot(structure, segment.relativePath);
+    if (slot === null) continue;
+    let set = byLocale.get(segment.locale);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      byLocale.set(segment.locale, set);
+    }
+    set.add(slot);
+  }
+  return byLocale;
+}
+function pickReferenceLocale(byLocale, preferred) {
+  if (preferred !== void 0 && byLocale.has(preferred)) return preferred;
+  let best = null;
+  let bestSize = -1;
+  for (const [locale, slots] of byLocale) {
+    if (slots.size > bestSize) {
+      best = locale;
+      bestSize = slots.size;
+    }
+  }
+  return best;
+}
+function collectLocaleStructuralParityDiagnostics(input) {
+  const { structure, segments } = input;
+  if (structure !== "locale_per_dir" && structure !== "feature_bundle") {
+    return [];
+  }
+  const byLocale = slotsByLocale(structure, segments);
+  if (byLocale.size < 2) return [];
+  const reference = pickReferenceLocale(byLocale, input.referenceLocale);
+  if (reference === null) return [];
+  const referenceSlots = byLocale.get(reference);
+  if (!referenceSlots || referenceSlots.size === 0) return [];
+  const diagnostics = [];
+  for (const [locale, slots] of byLocale) {
+    if (locale === reference) continue;
+    for (const slot of referenceSlots) {
+      if (!slots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_missing",
+          message: `locale ${locale} is missing segment slot ${slot} (present for reference locale ${reference})`
+        });
+      }
+    }
+    for (const slot of slots) {
+      if (!referenceSlots.has(slot)) {
+        diagnostics.push({
+          level: "warn",
+          code: "locale_structure_slot_extra",
+          message: `locale ${locale} has extra segment slot ${slot} (not present for reference locale ${reference})`
+        });
+      }
+    }
+  }
+  diagnostics.sort((a, b) => a.message.localeCompare(b.message));
+  return diagnostics;
+}
+
+// src/shared/constants/locales.ts
+var MAX_LOCALE_SEGMENT_TREE_DEPTH = 16;
+
+// src/shared/locales/enumerate/walkJsonTree.ts
+function posixRelative(pathApi, root, absolute) {
+  let rel = pathApi.relative(root, absolute);
+  if (rel.startsWith("..") || pathApi.isAbsolute(rel)) {
+    rel = pathApi.basename(absolute);
+  }
+  return rel.replace(/\\/g, "/");
+}
+function walkLocaleJsonSegments(input) {
+  const { fs, path, rootAbsolute, recursive } = input;
+  const maxDepth = input.maxDepth ?? MAX_LOCALE_SEGMENT_TREE_DEPTH;
+  const out = [];
+  function visit(dirAbsolute, depth) {
+    if (!existsRuntimeFsSync(dirAbsolute, fs)) return;
+    const entries = listRuntimeFsDirSync(dirAbsolute, fs);
+    for (const entry of entries) {
+      const childAbsolute = path.join(dirAbsolute, entry.name);
+      if (entry.kind === "file" && entry.name.endsWith(".json")) {
+        out.push({
+          absolutePath: childAbsolute,
+          relativePath: posixRelative(path, rootAbsolute, childAbsolute)
+        });
+      } else if (recursive && entry.kind === "directory" && depth < maxDepth) {
+        visit(childAbsolute, depth + 1);
+      }
+    }
+  }
+  visit(rootAbsolute, 0);
+  return out;
+}
+
+// src/shared/locales/enumerate/listLocaleSegments.ts
+function listLocaleSegments(input) {
+  const diagnostics = [];
+  const { layout, fs, path } = input;
+  const recursive = layout.structure !== "locale_file";
+  const walked = walkLocaleJsonSegments({
+    fs,
+    path,
+    rootAbsolute: layout.directoryAbsolute,
+    recursive
+  });
+  const segments = [];
+  for (const segment of walked) {
+    const locale = localeCodeForSegment(layout.structure, path, segment);
+    if (locale === null) continue;
+    segments.push({
+      locale,
+      relativePath: segment.relativePath,
+      absolutePath: segment.absolutePath
+    });
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  diagnostics.push(
+    ...collectLocaleStructuralParityDiagnostics({
+      structure: layout.structure,
+      segments
+    })
+  );
+  return { segments, diagnostics };
+}
+
+// src/shared/locales/layout/requireStructure.ts
+function localesMode(config) {
+  return config.mode ?? "flat_file";
+}
+function 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/cache/trackedFiles.ts
+var SYNTHETIC_SOURCE_LOCALE_KEY = "__source_locale__";
+function omitSyntheticSourceKey(files) {
+  if (!(SYNTHETIC_SOURCE_LOCALE_KEY in files)) return files;
+  const out = { ...files };
+  delete out[SYNTHETIC_SOURCE_LOCALE_KEY];
+  return out;
+}
+function mergeTrackedFileMaps(files, localeSegments) {
+  return { ...files, ...localeSegments };
+}
+function hashFileRecord(absPath, runtime, now) {
+  const content = readRuntimeFsTextSync(absPath, runtime.fs);
+  return {
+    hash: computeCacheContentHash(content, runtime.hashText),
+    size: textByteLength(content, runtime),
+    mtimeMs: 0,
+    updatedAt: now
+  };
+}
+function buildSrcFileRecords(input) {
+  const paths = listSourceFiles({ fs: input.runtime.fs, path: input.runtime.path }, input.srcRoot, input.exclude);
+  const now = new Date(input.runtime.system.now()).toISOString();
+  const out = {};
+  for (const absPath of paths) {
+    const rel = input.runtime.path.relative(input.srcRoot, absPath).replace(/\\/g, "/");
+    out[rel] = hashFileRecord(absPath, input.runtime, now);
+  }
+  return out;
+}
+function buildLocaleSegmentRecords(input) {
+  const layout = resolveLocalesLayout(input.locales, input.localesDir);
+  const { segments } = listLocaleSegments({ layout, fs: input.runtime.fs, path: input.runtime.path });
+  const now = new Date(input.runtime.system.now()).toISOString();
+  const out = {};
+  for (const segment of segments) {
+    out[segment.relativePath] = hashFileRecord(segment.absolutePath, input.runtime, now);
+  }
+  return out;
+}
+function buildTrackedProjectFilesCurrent(input) {
+  const localesLayout = resolveCachedLocalesLayout(input.locales);
+  const files = input.scanSrc ? buildSrcFileRecords(input) : omitSyntheticSourceKey(input.reuseSrcFiles ?? {});
+  const localeSegments = buildLocaleSegmentRecords(input);
+  return {
+    files,
+    localeSegments,
+    localesLayout,
+    merged: mergeTrackedFileMaps(files, localeSegments)
+  };
+}
+
+// src/types/cache/filesIndex.ts
+function filesIndexIsUsable(status) {
+  return status.kind === "ok";
+}
+
+// src/cache/deltaClassify.ts
+function normalizeRelPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function unionKeys(a, b) {
+  return /* @__PURE__ */ new Set([...a, ...b]);
+}
+function classifyCacheFileDelta(input) {
+  const src = { added: [], changed: [], deleted: [] };
+  const sourceLocale = [];
+  const targetLocale = [];
+  const sourceKey = normalizeRelPath(input.sourceLocaleSegmentKey);
+  const knownSrcKeys = unionKeys(input.currentSrcFileKeys, input.baselineSrcFileKeys);
+  const knownLocaleKeys = unionKeys(input.currentLocaleSegmentKeys, input.baselineLocaleSegmentKeys);
+  const classifyPath = (path, kind) => {
+    if (knownSrcKeys.has(path)) {
+      src[kind].push(path);
+      return;
+    }
+    if (knownLocaleKeys.has(path)) {
+      if (path === sourceKey) sourceLocale.push(path);
+      else targetLocale.push(path);
+    }
+  };
+  for (const path of input.delta.added.map(normalizeRelPath)) {
+    classifyPath(path, "added");
+  }
+  for (const path of input.delta.changed.map(normalizeRelPath)) {
+    classifyPath(path, "changed");
+  }
+  for (const path of input.delta.deleted.map(normalizeRelPath)) {
+    classifyPath(path, "deleted");
+  }
+  const layoutChanged = filesIndexIsUsable(input.filesIndexStatus) && !layoutMatches(input.previousLayout, input.currentLayout);
+  return {
+    src,
+    sourceLocale,
+    targetLocale,
+    layoutChanged,
+    filesIndexStatus: input.filesIndexStatus
+  };
+}
+function srcDeltaIsEmpty(src) {
+  return src.added.length + src.changed.length + src.deleted.length === 0;
+}
+function countSrcDeltaAffected(src) {
+  return src.added.length + src.changed.length + src.deleted.length;
+}
+
+// src/cache/filesIndexStatus.ts
+function isDefaultEmptyIndex(prev) {
+  const noSrc = Object.keys(prev.files).length === 0;
+  const noLocales = !prev.localeSegments || Object.keys(prev.localeSegments).length === 0;
+  const noLayout = prev.localesLayout === void 0;
+  return noSrc && noLocales && noLayout;
+}
+function resolveFilesIndexStatus(input) {
+  const indexWarnings = input.warnings.filter((w) => w.path === void 0 || w.path === input.filesPath);
+  if (indexWarnings.some((w) => w.code === "cache_malformed" || w.code === "cache_oversize")) {
+    return { kind: "malformed" };
+  }
+  const exists = input.runtime.fs.exists(input.filesPath);
+  if (!exists) {
+    return { kind: "missing" };
+  }
+  if (isDefaultEmptyIndex(input.prev)) {
+    return { kind: "empty" };
+  }
+  return { kind: "ok" };
+}
+
+// src/cache/resolveConfig.ts
+function clampThresholdPercent(value) {
+  if (value < 0) return 0;
+  if (value > 100) return 100;
+  return value;
+}
+function resolveCacheConfig(cache) {
+  const profileId = cache?.profile ?? DEFAULT_CACHE_PROFILE_ID;
+  const profile = CACHE_PROFILE_DEFAULTS[profileId] ?? CACHE_PROFILE_DEFAULTS[DEFAULT_CACHE_PROFILE_ID];
+  const threshold = cache?.fullRescanThresholdPercent !== void 0 ? clampThresholdPercent(cache.fullRescanThresholdPercent) : profile.fullRescanThresholdPercent;
+  return {
+    enabled: cache?.enabled ?? true,
+    profile: profileId,
+    mode: cache?.mode ?? profile.mode,
+    rebuild: cache?.rebuild ?? profile.rebuild,
+    fullRescanThresholdPercent: threshold,
+    ...cache?.dir !== void 0 ? { dir: cache.dir } : {}
+  };
+}
+function resolveCacheRebuildConfig(cache) {
+  const resolved = resolveCacheConfig(cache);
+  return {
+    rebuild: resolved.rebuild,
+    fullRescanThresholdPercent: resolved.fullRescanThresholdPercent
+  };
+}
+
+// src/cache/rebuildPolicy.ts
+function filesIndexRebuildReason(status) {
+  switch (status.kind) {
+    case "missing":
+      return "files_index_missing";
+    case "malformed":
+      return "files_index_malformed";
+    case "empty":
+      return "files_index_empty";
+    default:
+      return "files_index_missing";
+  }
+}
+function decideAnalysisRebuild(input) {
+  if (input.config.rebuild === "full") {
+    return { strategy: "full", reason: "config_rebuild_full" };
+  }
+  if (!input.hasPrevious) {
+    if (!filesIndexIsUsable(input.classified.filesIndexStatus)) {
+      return { strategy: "full", reason: filesIndexRebuildReason(input.classified.filesIndexStatus) };
+    }
+    return { strategy: "full", reason: "no_previous_cache" };
+  }
+  if (!filesIndexIsUsable(input.classified.filesIndexStatus)) {
+    return { strategy: "full", reason: "files_index_stale" };
+  }
+  if (input.classified.layoutChanged) {
+    return { strategy: "full", reason: "layout_changed" };
+  }
+  if (input.classified.sourceLocale.length > 0) {
+    const sourceOnly = input.classified.targetLocale.length === 0 && srcDeltaIsEmpty(input.classified.src);
+    if (sourceOnly) {
+      return { strategy: "partial", reason: "source_locale_partial" };
+    }
+    return { strategy: "full", reason: "source_locale_changed" };
+  }
+  if (input.classified.targetLocale.length > 0 && srcDeltaIsEmpty(input.classified.src)) {
+    return { strategy: "reuse", reason: "target_locale_only" };
+  }
+  if (srcDeltaIsEmpty(input.classified.src)) {
+    return { strategy: "full", reason: "locale_or_non_src_changed" };
+  }
+  const srcAffected = countSrcDeltaAffected(input.classified.src);
+  const trackedSrcCount = input.trackedSrcCount;
+  const threshold = input.config.fullRescanThresholdPercent;
+  const percent = trackedSrcCount > 0 ? srcAffected / trackedSrcCount * 100 : 100;
+  if (percent >= threshold) {
+    return {
+      strategy: "full",
+      reason: "src_threshold",
+      thresholdPercent: threshold,
+      srcAffected,
+      trackedSrcCount
+    };
+  }
+  return {
+    strategy: "partial",
+    reason: "src_partial",
+    srcAffected,
+    trackedSrcCount
+  };
+}
+
+// src/cache/dispatch.ts
+function assertLocalesInput(input) {
+  if (input.localesDir === void 0 || input.locales === void 0) {
+    throw new Error("cache dispatch requires localesDir and locales");
+  }
+}
+function baselineMergedFromDisk(prev) {
+  return mergeTrackedFileMaps(omitSyntheticSourceKey(prev.files), prev.localeSegments ?? {});
+}
+function resolveTrackedCurrent(input, prev) {
+  const locales = input.locales;
+  const localesDir = input.localesDir;
+  const hasCachedLayout = prev.localesLayout !== void 0;
+  const layoutMatch = layoutMatches(prev.localesLayout, resolveCachedLocalesLayout(locales));
+  const scanSrc = !hasCachedLayout || layoutMatch;
+  return buildTrackedProjectFilesCurrent({
+    runtime: input.runtime,
+    srcRoot: input.srcRoot,
+    exclude: input.exclude,
+    localesDir,
+    locales,
+    scanSrc,
+    ...scanSrc ? {} : { reuseSrcFiles: omitSyntheticSourceKey(prev.files) }
+  });
+}
+function sourceLocaleSegmentKey(input) {
+  return input.runtime.path.relative(input.localesDir, input.sourceLocalePath).replace(/\\/g, "/");
+}
+function buildProducerContext(input) {
+  const currentSrcFileKeys = new Set(Object.keys(omitSyntheticSourceKey(input.tracked.files)));
+  const baselineSrcFileKeys = new Set(Object.keys(omitSyntheticSourceKey(input.prev.files)));
+  const currentLocaleSegmentKeys = new Set(Object.keys(input.tracked.localeSegments));
+  const baselineLocaleSegmentKeys = new Set(Object.keys(input.prev.localeSegments ?? {}));
+  const classified = classifyCacheFileDelta({
+    delta: input.delta,
+    currentSrcFileKeys,
+    baselineSrcFileKeys,
+    currentLocaleSegmentKeys,
+    baselineLocaleSegmentKeys,
+    sourceLocaleSegmentKey: sourceLocaleSegmentKey(input.input),
+    previousLayout: input.prev.localesLayout,
+    currentLayout: input.tracked.localesLayout,
+    filesIndexStatus: input.filesIndexStatus
+  });
+  const rebuildConfig = input.input.rebuildConfig ?? resolveCacheRebuildConfig({ profile: "balanced" });
+  const trackedSrcCount = currentSrcFileKeys.size;
+  const analysisRebuild = {
+    ...decideAnalysisRebuild({
+      config: rebuildConfig,
+      classified,
+      hasPrevious: input.previous !== void 0,
+      trackedSrcCount
+    }),
+    srcDelta: classified.src
+  };
+  return {
+    delta: input.delta,
+    classified,
+    previous: input.previous,
+    trackedSrcCount,
+    rebuildConfig,
+    analysisRebuild
+  };
+}
+function persistFilesAndRunState(input) {
+  const saveFilesWarn = saveProjectFilesState(input.state, input.nextIndex, input.runtime);
+  if (saveFilesWarn) input.warnings.push(saveFilesWarn);
+  const saveRunWarn = saveProjectRunState(input.state, input.runtime, {
+    data: input.data,
+    inputFilesEpoch: input.inputFilesEpoch
+  });
+  if (saveRunWarn) input.warnings.push(saveRunWarn);
+}
+function getOrBuildCachedProjectData(input) {
+  const warnings = [];
+  const state = input.state;
+  const paths = {
+    meta: state.metaPath,
+    files: state.filesPath,
+    analysis: state.analysisPath,
+    projectDir: state.projectDir
+  };
+  const rebuildConfig = input.rebuildConfig ?? resolveCacheRebuildConfig({ profile: "balanced" });
+  if (!state.enabled) {
+    return {
+      data: input.producer(),
+      cache: {
+        status: state.reason === "cli_no_cache" ? "bypass" : "disabled",
+        reason: "no_cache",
+        warnings,
+        paths
+      }
+    };
+  }
+  const prepared = prepareCacheForRun(state, input.runtime);
+  warnings.push(...prepared.warnings);
+  const prevFiles = loadProjectFilesState(state, input.runtime);
+  warnings.push(...prevFiles.warnings);
+  const prev = prevFiles.files;
+  const filesIndexStatus = resolveFilesIndexStatus({
+    prev,
+    warnings: prevFiles.warnings,
+    filesPath: state.filesPath,
+    runtime: input.runtime
+  });
+  assertLocalesInput(input);
+  const tracked = resolveTrackedCurrent(input, prev);
+  const currentFiles = tracked.merged;
+  const baseline = input.baselineFiles ?? baselineMergedFromDisk(prev);
+  const delta = diffProjectFiles(baseline, currentFiles);
+  const hasFileChanges = delta.added.length + delta.changed.length + delta.deleted.length > 0;
+  const inputFilesEpoch = computeInputFilesEpoch(currentFiles, input.runtime.hashText);
+  const prevRun = loadProjectRunState(state, input.runtime);
+  warnings.push(...prevRun.warnings);
+  let previous;
+  if (prevRun.run?.data !== void 0 && input.parseCachedData) {
+    const parsedPrevious = input.parseCachedData(prevRun.run.data);
+    if (parsedPrevious.ok) previous = parsedPrevious.data;
+  }
+  const filesIndexRecoverable = !filesIndexIsUsable(filesIndexStatus) && hasFileChanges && previous !== void 0 && prevRun.run?.inputFilesEpoch === inputFilesEpoch;
+  if (filesIndexRecoverable && previous !== void 0) {
+    const nextIndex2 = {
+      ...prev,
+      files: tracked.files,
+      localeSegments: tracked.localeSegments,
+      localesLayout: tracked.localesLayout
+    };
+    persistFilesAndRunState({
+      state,
+      runtime: input.runtime,
+      nextIndex: nextIndex2,
+      data: previous,
+      inputFilesEpoch,
+      warnings
+    });
+    return {
+      data: previous,
+      cache: {
+        status: "hit",
+        reason: "files_index_recovered",
+        warnings,
+        delta,
+        paths,
+        analysisRebuild: { strategy: "reuse", reason: "files_index_recovered" },
+        filesIndexStatus
+      }
+    };
+  }
+  let missReason = hasFileChanges ? "files_changed" : "run_missing";
+  let inputFilesEpochDebug;
+  if (!hasFileChanges && prevRun.run?.data !== void 0) {
+    if (prevRun.run.inputFilesEpoch !== inputFilesEpoch) {
+      missReason = "run_binding_stale";
+      inputFilesEpochDebug = { cached: prevRun.run.inputFilesEpoch, current: inputFilesEpoch };
+    } else {
+      const parsed = input.parseCachedData ? input.parseCachedData(prevRun.run.data) : { ok: true, data: prevRun.run.data };
+      if (parsed.ok) {
+        return {
+          data: parsed.data,
+          cache: {
+            status: "hit",
+            reason: "cache_hit",
+            warnings,
+            delta,
+            paths
+          }
+        };
+      }
+      missReason = "run_invalid";
+    }
+  }
+  const producerCtx = buildProducerContext({
+    input: { ...input, rebuildConfig },
+    delta,
+    tracked,
+    prev,
+    previous,
+    filesIndexStatus
+  });
+  if (previous !== void 0 && producerCtx.analysisRebuild?.strategy === "reuse" && producerCtx.analysisRebuild.reason === "target_locale_only") {
+    const nextIndex2 = {
+      ...prev,
+      files: tracked.files,
+      localeSegments: tracked.localeSegments,
+      localesLayout: tracked.localesLayout
+    };
+    persistFilesAndRunState({
+      state,
+      runtime: input.runtime,
+      nextIndex: nextIndex2,
+      data: previous,
+      inputFilesEpoch,
+      warnings
+    });
+    return {
+      data: previous,
+      cache: {
+        status: "miss",
+        reason: missReason,
+        warnings,
+        delta,
+        paths,
+        analysisRebuild: producerCtx.analysisRebuild
+      }
+    };
+  }
+  const fresh = input.producer(producerCtx);
+  const nextIndex = {
+    ...prev,
+    files: tracked.files,
+    localeSegments: tracked.localeSegments,
+    localesLayout: tracked.localesLayout
+  };
+  persistFilesAndRunState({
+    state,
+    runtime: input.runtime,
+    nextIndex,
+    data: fresh,
+    inputFilesEpoch,
+    warnings
+  });
+  return {
+    data: fresh,
+    cache: {
+      status: "miss",
+      reason: missReason,
+      warnings,
+      delta,
+      paths,
+      analysisRebuild: producerCtx.analysisRebuild,
+      filesIndexStatus: filesIndexIsUsable(filesIndexStatus) ? void 0 : filesIndexStatus,
+      ...inputFilesEpochDebug !== void 0 ? { inputFilesEpochDebug } : {}
+    }
+  };
+}
+
+// src/shared/run/index.ts
+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();
+}
+
+// src/cache/events.ts
+function describeCacheInvalidation(reason) {
+  switch (reason) {
+    case "files_changed":
+      return "source files changed";
+    case "files_index_recovered":
+      return "files index rebuilt; analysis reused (project files unchanged)";
+    case "run_binding_stale":
+      return "stale (source files changed since last cache write)";
+    case "run_invalid":
+      return "cached data failed validation";
+    case "run_missing":
+      return "no cached data";
+    case "cache_unavailable":
+      return "cache unavailable";
+    case "no_cache":
+      return "cache disabled";
+    case "cache_hit":
+    case "producer_succeeded":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function emitCacheDetail(input) {
+  emitRunMessage(input.emit, {
+    op: input.op,
+    runId: input.runId,
+    channel: "cache",
+    level: "detail",
+    message: input.message
+  });
+}
+function emitCacheDeltaFiles(input) {
+  const limit = 12;
+  for (const file of input.files.slice(0, limit)) {
+    emitCacheDetail({ ...input, message: `    ${input.kind}: ${file}` });
+  }
+  if (input.files.length > limit) {
+    emitCacheDetail({ ...input, message: `    ${input.kind}: ... ${String(input.files.length - limit)} more` });
+  }
+}
+function emitCacheDispatchMessages(input) {
+  emitRunMessage(input.emit, {
+    op: input.op,
+    runId: input.runId,
+    channel: "cache",
+    level: "info",
+    message: `${input.label} cache ${input.cache.status} (${input.cache.reason})`
+  });
+  const invalidation = describeCacheInvalidation(input.cache.reason);
+  if (invalidation) {
+    emitCacheDetail({ ...input, message: `  invalidated: ${invalidation}` });
+  }
+  if (input.cache.paths) {
+    emitCacheDetail({ ...input, message: `  meta: ${input.cache.paths.meta}` });
+    emitCacheDetail({ ...input, message: `  project: ${input.cache.paths.projectDir}` });
+    emitCacheDetail({ ...input, message: `  files: ${input.cache.paths.files}` });
+    emitCacheDetail({ ...input, message: `  analysis: ${input.cache.paths.analysis}` });
+  }
+  if (input.cache.delta) {
+    const d = input.cache.delta;
+    emitCacheDetail({
+      ...input,
+      message: `  file delta: +${String(d.added.length)} ~${String(d.changed.length)} -${String(d.deleted.length)} =${String(d.unchanged.length)}`
+    });
+    emitCacheDeltaFiles({ ...input, kind: "added", files: d.added });
+    emitCacheDeltaFiles({ ...input, kind: "changed", files: d.changed });
+    emitCacheDeltaFiles({ ...input, kind: "deleted", files: d.deleted });
+  }
+  if (input.cache.analysisRebuild) {
+    const r = input.cache.analysisRebuild;
+    if (r.strategy === "reuse") {
+      const detail = r.reason === "target_locale_only" ? "target locale only (reusing analysis.json)" : "reusing analysis.json";
+      emitCacheDetail({ ...input, message: `  analysis rebuild: skipped (${detail})` });
+    } else if (r.strategy === "partial") {
+      if (r.reason === "source_locale_partial") {
+        emitCacheDetail({ ...input, message: "  analysis rebuild: partial (source locale only, missingKeys updated)" });
+      } else {
+        const src = r.srcDelta;
+        const changed = src?.changed.length ?? 0;
+        const added = src?.added.length ?? 0;
+        const deleted = src?.deleted.length ?? 0;
+        emitCacheDetail({
+          ...input,
+          message: `  analysis rebuild: partial (${String(changed)} changed, ${String(added)} added, ${String(deleted)} deleted)`
+        });
+      }
+    } else {
+      let detail = "config rebuild=full";
+      if (r.reason === "src_threshold") {
+        const pct = r.trackedSrcCount && r.trackedSrcCount > 0 ? Math.round((r.srcAffected ?? 0) / r.trackedSrcCount * 100) : 100;
+        detail = `threshold ${String(pct)}% (limit ${String(r.thresholdPercent ?? 40)}%)`;
+      } else if (r.reason === "layout_changed") {
+        detail = "layout changed";
+      } else if (r.reason === "source_locale_changed") {
+        detail = "source locale changed (with other deltas)";
+      } else if (r.reason === "locale_or_non_src_changed") {
+        detail = "locale or non-src delta";
+      } else if (r.reason === "no_previous_cache") {
+        detail = "no previous analysis cache";
+      } else if (r.reason === "files_index_missing") {
+        detail = "files.json missing";
+      } else if (r.reason === "files_index_malformed") {
+        detail = "files.json invalid or oversized";
+      } else if (r.reason === "files_index_empty") {
+        detail = "files.json empty";
+      } else if (r.reason === "files_index_stale") {
+        detail = "files index unusable and project files changed since last analysis";
+      }
+      emitCacheDetail({ ...input, message: `  analysis rebuild: full (${detail})` });
+    }
+  }
+  if (input.cache.filesIndexStatus !== void 0 && input.cache.filesIndexStatus.kind !== "ok") {
+    const kind = input.cache.filesIndexStatus.kind;
+    const note = kind === "missing" ? "files.json missing \u2014 rebuilding fingerprints from disk" : kind === "malformed" ? "files.json invalid or oversized \u2014 rebuilding fingerprints from disk" : "files.json empty \u2014 rebuilding fingerprints from disk";
+    emitCacheDetail({ ...input, message: `  files index: ${note}` });
+  }
+  for (const warn of input.cache.warnings) {
+    const path = warn.path ? ` (${warn.path})` : "";
+    emitRunMessage(input.emit, {
+      op: input.op,
+      runId: input.runId,
+      channel: "cache",
+      level: "info",
+      message: `warning: ${warn.message}${path}`
+    });
+  }
+}
+
+// src/validate/missingLiterals.ts
+function logicalPathsFromSourceLeaves(leaves) {
+  return new Set(leaves.map((l) => l.path));
+}
+function computeMissingLiteralKeysFromLeaves(sourceLeaves, resolvedKeys) {
+  const keySet = logicalPathsFromSourceLeaves(sourceLeaves);
+  return [...resolvedKeys].filter((k) => !keySet.has(k)).sort(compareDottedPathDepth);
+}
+function compareDottedPathDepth(a, b) {
+  const da = splitPath(a).length;
+  const db = splitPath(b).length;
+  if (da !== db) return da - db;
+  return a.localeCompare(b);
+}
+
+// src/shared/locales/read/flatFileSurface.ts
+function readFlatLocaleJsonSurface(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(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/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/read/bundle.ts
+function readLocaleBundle(input) {
+  const diagnostics = [];
+  const emit = (d) => {
+    diagnostics.push(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/languages/normalize.ts
+function normalizeLanguageCode(code) {
+  return code.trim().toLowerCase().replace(/_/g, "-");
+}
+
+// src/shared/locales/enumerate/fromContext.ts
+function listLocaleSegmentsFromContext(ctx) {
+  return listLocaleSegments({
+    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 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 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/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/analysis/rebuild.ts
+function normalizeRelPath2(path) {
+  return path.replace(/\\/g, "/");
+}
+function pathSet(paths) {
+  return new Set(paths.map(normalizeRelPath2));
+}
+function observationPath(obs) {
+  return obs.span.filePath !== void 0 ? normalizeRelPath2(obs.span.filePath) : void 0;
+}
+function sitePath(site) {
+  return site.filePath !== void 0 ? normalizeRelPath2(site.filePath) : void 0;
+}
+function filterByPaths(rows, pathOf, remove) {
+  return rows.filter((row) => {
+    const filePath = pathOf(row);
+    return filePath === void 0 || !remove.has(filePath);
+  });
+}
+function scanInputFromContext(ctx) {
+  return {
+    srcRoot: ctx.paths.srcRoot,
+    functions: ctx.config.functions,
+    runtime: ctx.adapters,
+    exclude: ctx.config.exclude
+  };
+}
+function absolutePathsForRel(ctx, relPaths) {
+  const { path, srcRoot } = { path: ctx.adapters.path, srcRoot: ctx.paths.srcRoot };
+  return relPaths.map((rel) => path.join(srcRoot, rel));
+}
+function partialScanIo(ctx, relPaths) {
+  const absPaths = absolutePathsForRel(ctx, relPaths);
+  return {
+    listFiles: () => absPaths,
+    readFile: (filePath) => readRuntimeFsTextSync(filePath, ctx.adapters.fs)
+  };
+}
+function scanKeyObservationsForPaths(ctx, relPaths) {
+  if (relPaths.length === 0) return [];
+  return scanProjectKeyObservations({
+    ...scanInputFromContext(ctx),
+    ...partialScanIo(ctx, relPaths)
+  });
+}
+function scanDynamicSitesForPaths(ctx, relPaths) {
+  if (relPaths.length === 0) return [];
+  return scanProjectDynamicKeySites({
+    ...scanInputFromContext(ctx),
+    ...partialScanIo(ctx, relPaths)
+  });
+}
+function patchProjectAnalysisFromSrcDelta(ctx, previous, srcDelta) {
+  const remove = pathSet([...srcDelta.deleted, ...srcDelta.changed]);
+  const rescan = [...srcDelta.added, ...srcDelta.changed];
+  const keyObservations = [
+    ...filterByPaths(previous.keyObservations, observationPath, remove),
+    ...scanKeyObservationsForPaths(ctx, rescan)
+  ];
+  const dynamicSites = [
+    ...filterByPaths(previous.dynamicSites, sitePath, remove),
+    ...scanDynamicSitesForPaths(ctx, rescan)
+  ];
+  const usage = literalKeyUsageFromObservations(keyObservations);
+  const sourceLeaves = readSourceLocaleLeaves(ctx);
+  const missingKeys = computeMissingLiteralKeysFromLeaves(sourceLeaves, usage.resolvedKeys);
+  const sourceFilesScanned = previous.counts.sourceFilesScanned + srcDelta.added.length - srcDelta.deleted.length;
+  return {
+    version: 1,
+    keyObservations,
+    dynamicSites,
+    missingKeys,
+    counts: {
+      keyObservations: keyObservations.length,
+      dynamicSites: dynamicSites.length,
+      sourceFilesScanned: Math.max(0, sourceFilesScanned),
+      missingKeys: missingKeys.length
+    }
+  };
+}
+function patchProjectAnalysisFromSourceLocaleDelta(ctx, previous) {
+  invalidateLocaleReadCacheForLocaleCode(ctx, sourceLocaleCodeFromContext(ctx));
+  const usage = literalKeyUsageFromObservations(previous.keyObservations);
+  const sourceLeaves = readSourceLocaleLeaves(ctx);
+  const missingKeys = computeMissingLiteralKeysFromLeaves(sourceLeaves, usage.resolvedKeys);
+  return {
+    ...previous,
+    missingKeys,
+    counts: {
+      ...previous.counts,
+      missingKeys: missingKeys.length
+    }
+  };
+}
+
+// src/analysis/project.ts
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function isAnalysisCounts(v) {
+  if (!isRecord(v)) return false;
+  return typeof v.keyObservations === "number" && typeof v.dynamicSites === "number" && typeof v.sourceFilesScanned === "number" && typeof v.missingKeys === "number";
+}
+function parseProjectAnalysisCacheData(data) {
+  if (!isRecord(data)) return { ok: false };
+  if (data.version !== 1) return { ok: false };
+  if (!Array.isArray(data.keyObservations) || !Array.isArray(data.dynamicSites)) return { ok: false };
+  if (!Array.isArray(data.missingKeys)) return { ok: false };
+  if (!isAnalysisCounts(data.counts)) return { ok: false };
+  return {
+    ok: true,
+    data: {
+      version: 1,
+      keyObservations: data.keyObservations,
+      dynamicSites: data.dynamicSites,
+      missingKeys: data.missingKeys,
+      counts: data.counts
+    }
+  };
+}
+function scanProjectAnalysis(ctx) {
+  invalidateLocaleReadCacheForLocaleCode(ctx, sourceLocaleCodeFromContext(ctx));
+  const scanInput = {
+    srcRoot: ctx.paths.srcRoot,
+    functions: ctx.config.functions,
+    runtime: ctx.adapters,
+    exclude: ctx.config.exclude
+  };
+  const keyObservations = scanProjectKeyObservations(scanInput);
+  const dynamicSites = scanProjectDynamicKeySites(scanInput);
+  const usage = literalKeyUsageFromObservations(keyObservations);
+  const sourceLeaves = readSourceLocaleLeaves(ctx);
+  const missingKeys = computeMissingLiteralKeysFromLeaves(sourceLeaves, usage.resolvedKeys);
+  const projectFs = { fs: ctx.adapters.fs, path: ctx.adapters.path };
+  const sourceFilesScanned = listSourceFiles(projectFs, ctx.paths.srcRoot, ctx.config.exclude).length;
+  return {
+    version: 1,
+    keyObservations,
+    dynamicSites,
+    missingKeys,
+    counts: {
+      keyObservations: keyObservations.length,
+      dynamicSites: dynamicSites.length,
+      sourceFilesScanned,
+      missingKeys: missingKeys.length
+    }
+  };
+}
+function produceProjectAnalysis(ctx, rebuild) {
+  if (rebuild?.previous !== void 0 && rebuild.analysisRebuild?.strategy === "reuse") {
+    return rebuild.previous;
+  }
+  if (rebuild?.previous !== void 0 && rebuild.analysisRebuild?.strategy === "partial") {
+    if (rebuild.analysisRebuild.reason === "source_locale_partial") {
+      return patchProjectAnalysisFromSourceLocaleDelta(ctx, rebuild.previous);
+    }
+    return patchProjectAnalysisFromSrcDelta(ctx, rebuild.previous, rebuild.classified.src);
+  }
+  return scanProjectAnalysis(ctx);
+}
+function withDerivedUsage(data, cache) {
+  return {
+    ...data,
+    usage: literalKeyUsageFromObservations(data.keyObservations),
+    ...cache !== void 0 ? { cache } : {}
+  };
+}
+function resolveProjectAnalysis(ctx, opts = {}) {
+  const cacheCtx = ctx.cache;
+  if (cacheCtx === void 0) {
+    return withDerivedUsage(scanProjectAnalysis(ctx));
+  }
+  const rebuildConfig = resolveCacheRebuildConfig(ctx.config.cache);
+  const result = getOrBuildCachedProjectData({
+    state: cacheCtx.state,
+    runtime: cacheCtx.runtime,
+    sourceLocalePath: ctx.paths.sourceLocale,
+    srcRoot: ctx.paths.srcRoot,
+    localesDir: ctx.paths.localesDir,
+    locales: ctx.config.locales,
+    exclude: ctx.config.exclude,
+    rebuildConfig,
+    producer: (rebuild) => produceProjectAnalysis(ctx, rebuild),
+    parseCachedData: parseProjectAnalysisCacheData,
+    baselineFiles: cacheCtx.baselineFiles
+  });
+  if (opts.emit !== void 0 && opts.op !== void 0) {
+    emitCacheDispatchMessages({
+      emit: opts.emit,
+      op: opts.op,
+      runId: opts.runId,
+      label: "project analysis",
+      cache: result.cache
+    });
+  }
+  return withDerivedUsage(result.data, result.cache);
+}
+
+// src/locales/source.ts
+function getSourceLocaleSlug(path, sourceLocalePath) {
+  return normalizeLanguageCode(path.basename(sourceLocalePath, ".json"));
+}
+function getDisplaySourceLocaleCode(ctx) {
+  return getSourceLocaleSlug(ctx.path, ctx.paths.sourceLocale);
+}
+function buildSourceLocaleTruthLabel(displaySlug) {
+  return `(${displaySlug} - source of truth)`;
+}
+function isSourceLocaleSlug(path, candidate, sourceLocalePath) {
+  return normalizeLanguageCode(candidate) === getSourceLocaleSlug(path, sourceLocalePath);
+}
+function assertNotSourceTargetLocale(command, lang, sourceLocalePath, ctx) {
+  if (!isSourceLocaleSlug(ctx.path, lang, sourceLocalePath)) return;
+  const display = getDisplaySourceLocaleCode(ctx);
+  throw new I18nPruneError(
+    `${command} does not apply to the source locale ${buildSourceLocaleTruthLabel(display)}. Pass a target language code.`,
+    "USAGE"
+  );
+}
+
+// src/locales/targets.ts
+var ALL_LOCALES_TOKEN = "all";
+function parseLocaleCodesList(raw) {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean).map((c) => normalizeLanguageCode(c));
+}
+function isAllLocaleToken(raw) {
+  return raw.trim().toLowerCase() === ALL_LOCALES_TOKEN;
+}
+function parseSyncLangSelection(lang) {
+  const primary = lang?.trim();
+  if (primary) {
+    if (isAllLocaleToken(primary)) return { mode: "all" };
+    return { mode: "codes", codes: parseLocaleCodesList(primary) };
+  }
+  return { mode: "all" };
+}
+
+// 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;
+}
+
+// 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/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
+  });
+}
+
+// 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.targetSegmentRelativePath;
+  const sourceAbsolutePath = resolvePairedSourceSegmentAbsolutePath(
+    ctx,
+    input.targetSegmentRelativePath);
+  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));
+}
+
+// src/shared/constants/missing.ts
+var DEFAULT_MISSING_LEAF_PLACEHOLDER = "__I18NPRUNE_MISSING__";
+
+// 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/sync/humanLeafSummary.ts
+function isPlainObject8(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function readLeafDisplayString(root, pathStr) {
+  const v = getLocaleLeafAtPath(root, pathStr);
+  if (typeof v === "string") return v;
+  if (isPlainObject8(v) && typeof v.value === "string") return v.value;
+  return void 0;
+}
+function canonicalTemplatePathForCollectedLeaf(leafPath, templatePaths) {
+  if (templatePaths.has(leafPath)) return leafPath;
+  if (leafPath.endsWith(".value")) {
+    const base = leafPath.slice(0, -".value".length);
+    if (templatePaths.has(base)) return base;
+  }
+  return null;
+}
+function summarizeSyncLeavesForHumanLog(sourceLeaves, cur, mergedLocaleJson) {
+  const templatePaths = new Set(sourceLeaves.map((l) => l.path));
+  let hydratedFromSource = 0;
+  let preservedExistingLeaves = 0;
+  for (const pathStr of templatePaths) {
+    const beforeStr = readLeafDisplayString(cur, pathStr);
+    if (beforeStr === void 0) hydratedFromSource++;
+    else preservedExistingLeaves++;
+  }
+  const beforeRawPaths = new Set(collectTranslationSurfaceLeaves(cur).map((leaf) => leaf.path));
+  const afterRawPaths = new Set(collectTranslationSurfaceLeaves(mergedLocaleJson).map((leaf) => leaf.path));
+  let prunedExtraLeaves = 0;
+  for (const p of beforeRawPaths) {
+    if (canonicalTemplatePathForCollectedLeaf(p, templatePaths) !== null) continue;
+    if (!afterRawPaths.has(p)) prunedExtraLeaves += 1;
+  }
+  return { hydratedFromSource, preservedExistingLeaves, prunedExtraLeaves };
+}
+
+// src/shared/constants/listDisplay.ts
+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/sync/humanEmit.ts
+function parseSyncReportKey(reportKey) {
+  const slash = reportKey.indexOf("/");
+  if (slash === -1) {
+    const base = reportKey.endsWith(".json") ? reportKey.slice(0, -5) : reportKey;
+    return { localeCode: base, segmentName: null };
+  }
+  return { localeCode: reportKey.slice(0, slash), segmentName: reportKey.slice(slash + 1) };
+}
+function buildSyncLocaleDisplayGroups(result) {
+  const groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < result.targets.length; i++) {
+    const reportKey = result.targets[i];
+    const fileLine = result.fileLines[i];
+    if (!fileLine) continue;
+    const { localeCode } = parseSyncReportKey(reportKey);
+    let group = groups.get(localeCode);
+    if (!group) {
+      group = { localeCode, reportKeys: [], fileLines: [], changedCount: 0, summaries: [] };
+      groups.set(localeCode, group);
+    }
+    group.reportKeys.push(reportKey);
+    group.fileLines.push(fileLine);
+    if (fileLine.changed) group.changedCount += 1;
+    const summary = result.humanLeafSummaryByLocaleFile[reportKey];
+    if (summary) group.summaries.push(summary);
+  }
+  return [...groups.values()].sort((a, b) => a.localeCode.localeCompare(b.localeCode));
+}
+function isSegmentedSyncLayout(groups) {
+  return groups.some((group) => group.reportKeys.length > 1);
+}
+function mergeSyncHumanLeafSummaries(summaries) {
+  return summaries.reduce(
+    (acc, summary) => ({
+      hydratedFromSource: acc.hydratedFromSource + summary.hydratedFromSource,
+      preservedExistingLeaves: acc.preservedExistingLeaves + summary.preservedExistingLeaves,
+      prunedExtraLeaves: acc.prunedExtraLeaves + summary.prunedExtraLeaves
+    }),
+    { hydratedFromSource: 0, preservedExistingLeaves: 0, prunedExtraLeaves: 0 }
+  );
+}
+function formatSyncLocaleFileDetailLine(group, segmented, dryRun) {
+  const total = group.fileLines.length;
+  if (!segmented || total === 1) {
+    const reportKey = group.reportKeys[0] ?? group.localeCode;
+    const fileLine = group.fileLines[0];
+    const mark = fileLine.changed ? "\u2713" : "\xB7";
+    const tail = fileLine.changed ? dryRun ? " (would write)" : " (written)" : " (unchanged)";
+    return `  ${mark} ${reportKey}${tail}`;
+  }
+  const unchanged = total - group.changedCount;
+  if (group.changedCount === 0) {
+    return `  \xB7 ${group.localeCode} \xB7 unchanged (${String(total)} segment files)`;
+  }
+  if (group.changedCount === total) {
+    const verb = dryRun ? "would change" : "updated";
+    return `  \u2713 ${group.localeCode} \xB7 ${verb} (${String(total)} segment files)`;
+  }
+  const updatedVerb = dryRun ? "would change" : "updated";
+  return `  \xB7 ${group.localeCode} \xB7 ${String(group.changedCount)} ${updatedVerb} \xB7 ${String(unchanged)} unchanged (${String(total)} segment files)`;
+}
+function formatSyncFileListOmittedLine(shownLocaleCount, omittedLocaleCount) {
+  if (omittedLocaleCount <= 0) return "";
+  const prefix = `  \xB7 ${String(shownLocaleCount)} locale(s) shown`;
+  return formatListShownOmitted(prefix, omittedLocaleCount);
+}
+function formatSyncLeafSummaryLabel(group, segmented) {
+  if (!segmented || group.reportKeys.length === 1) {
+    return group.reportKeys[0] ?? group.localeCode;
+  }
+  return group.localeCode;
+}
+
+// src/sync/run.ts
+function zeroByReason() {
+  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
+  };
+}
+function idleLocaleMetadataReportForSkippedSync(totalSourceLeafPaths) {
+  return {
+    mode: "legacy_string",
+    totalSourceLeafPaths,
+    unchangedLeaves: totalSourceLeafPaths,
+    structuredLeavesWritten: 0,
+    promotedLegacyLeaves: 0,
+    repairedCorruptLeaves: 0,
+    strippedStructuredLeaves: 0,
+    missingPathsHydratedFromSource: 0,
+    byReason: zeroByReason(),
+    changedPathsSample: [],
+    leafDecisions: []
+  };
+}
+function issuesFromDynamicScanCount(count) {
+  if (count <= 0) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_SCAN_DYNAMIC_KEY_SITES,
+      message: `${String(count)} translation call(s) use a non-literal key \u2014 static analysis cannot enumerate computed keys as fixed paths.`,
+      docPath: "dynamic/README"
+    }
+  ];
+}
+function issuesFromSyncMissingLocaleFiles(localeCodes) {
+  if (localeCodes.length === 0) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_SYNC_LOCALE_FILE_NOT_FOUND,
+      message: `Locale file(s) not found under locales dir (skipped): ${localeCodes.map((c) => `${c}.json`).join(", ")}`,
+      docPath: "commands/sync/README"
+    }
+  ];
+}
+function issueFromMetadataFlagConflict(conflict) {
+  if (!conflict) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_SYNC_METADATA_FLAG_CONFLICT,
+      message: "Both metadata-enable and strip-metadata were requested; strip-metadata takes precedence and locale leaves are written as plain strings.",
+      docPath: "locales/metadata/README"
+    }
+  ];
+}
+function syncLocaleMetadataDetailLine(report, explicitStrip, explicitMetadata) {
+  if (!explicitStrip && !explicitMetadata || !report) return void 0;
+  if (explicitStrip) {
+    return report.strippedStructuredLeaves > 0 ? `metadata \xB7 stripped structured fields at ${String(report.strippedStructuredLeaves)} template leaf path(s) (plain strings)` : `metadata \xB7 no structured leaves stripped (already plain strings at template paths)`;
+  }
+  const parts = [];
+  const mat = report.byReason.canonical_metadata_materialized ?? 0;
+  if (report.promotedLegacyLeaves > 0) parts.push(`${String(report.promotedLegacyLeaves)} plain \u2192 structured`);
+  if (mat > 0) parts.push(`${String(mat)} thin leaf(es) gained full canonical metadata keys`);
+  if (report.repairedCorruptLeaves > 0) parts.push(`${String(report.repairedCorruptLeaves)} corrupt repaired`);
+  if (report.missingPathsHydratedFromSource > 0) {
+    parts.push(`${String(report.missingPathsHydratedFromSource)} missing hydrated from source`);
+  }
+  if (parts.length > 0) return `metadata \xB7 ${parts.join(" \xB7 ")}`;
+  return `metadata \xB7 structured terminals unchanged (validated in place)`;
+}
+function emitSyncHumanMessages(host, input) {
+  const { result } = input;
+  if (result.missingLocaleCodes.length > 0) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "warn",
+      message: `locale file(s) not found (skipped): ${result.missingLocaleCodes.map((m) => `${m}.json`).join(", ")}`
+    });
+  }
+  if (result.dynamicSites.length > 0) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "warn",
+      message: `${String(result.dynamicSites.length)} translation call(s) use a non-literal key \u2014 sync only aligns locale JSON shapes; computed keys from code are not merged or enumerated.`,
+      data: { dynamicSites: result.dynamicSites.length }
+    });
+  }
+  if (result.sourcePlaceholderLeaves.length > 0) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "warn",
+      message: formatSyncSourcePlaceholderMessage({
+        count: result.sourcePlaceholderLeaves.length,
+        samplePaths: result.sourcePlaceholderLeaves.slice(0, 5).map((leaf) => leaf.path)
+      }),
+      data: { sourcePlaceholderLeaves: result.sourcePlaceholderLeaves.length }
+    });
+  }
+  if (result.targetPlaceholderLeaves.length > 0) {
+    const byLocale = /* @__PURE__ */ new Map();
+    for (const leaf of result.targetPlaceholderLeaves) {
+      byLocale.set(leaf.localeCode, [...byLocale.get(leaf.localeCode) ?? [], leaf]);
+    }
+    for (const [localeCode, leaves] of byLocale) {
+      emitRunMessage(host.emit, {
+        op: "sync",
+        runId: host.runId,
+        level: "warn",
+        message: formatTargetPlaceholderMessage({
+          count: leaves.length,
+          samplePaths: leaves.slice(0, 5).map((leaf) => leaf.path),
+          targetLabel: localeCode
+        }),
+        target: localeCode,
+        data: { targetPlaceholderLeaves: leaves.length }
+      });
+    }
+  }
+  emitRunMessage(host.emit, {
+    op: "sync",
+    runId: host.runId,
+    level: "info",
+    message: `${String(result.fileLines.length)} target file(s) \xB7 ${String(result.dynamicSites.length)} dynamic key site(s)`
+  });
+  const changed = result.fileLines.filter((f) => f.changed).length;
+  const verb = input.dryRun ? "Would change" : "Updated";
+  emitRunMessage(host.emit, {
+    op: "sync",
+    runId: host.runId,
+    level: "info",
+    message: `${verb}: ${String(changed)} \xB7 Unchanged: ${String(result.fileLines.length - changed)}`
+  });
+  const localeGroups = buildSyncLocaleDisplayGroups(result);
+  const segmentedLayout = isSegmentedSyncLayout(localeGroups);
+  const shownLocaleGroups = localeGroups.slice(0, input.listLimit);
+  for (const group of shownLocaleGroups) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "detail",
+      message: formatSyncLocaleFileDetailLine(group, segmentedLayout, input.dryRun),
+      target: group.localeCode,
+      data: { changed: group.changedCount > 0, segmentCount: group.reportKeys.length }
+    });
+  }
+  const omittedLocales = localeGroups.length - shownLocaleGroups.length;
+  const omittedLine = formatSyncFileListOmittedLine(shownLocaleGroups.length, omittedLocales);
+  if (omittedLine) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "detail",
+      message: omittedLine
+    });
+  }
+  if (result.dynamicSites.length > 0) {
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "info",
+      message: "Dynamic keys are not merged by sync \u2014 see `i18nprune validate` and `i18nprune locales dynamic`."
+    });
+  }
+  const reports = result.payload.localeMetadataReports;
+  const leafGroups = localeGroups.slice(0, input.listLimit);
+  for (const group of leafGroups) {
+    if (group.summaries.length === 0) continue;
+    const merged = mergeSyncHumanLeafSummaries(group.summaries);
+    const label = formatSyncLeafSummaryLabel(group, segmentedLayout);
+    emitRunMessage(host.emit, {
+      op: "sync",
+      runId: host.runId,
+      level: "info",
+      message: `${label}: ${String(merged.hydratedFromSource)} leaf path(s) filled from source \xB7 ${String(merged.preservedExistingLeaves)} kept \xB7 ${String(merged.prunedExtraLeaves)} extra path(s) removed (not in source)`,
+      target: group.localeCode
+    });
+    if (segmentedLayout && group.reportKeys.length > 1) {
+      for (const reportKey of group.reportKeys) {
+        const metaLine = syncLocaleMetadataDetailLine(
+          reports?.[reportKey],
+          input.explicitStripMetadata,
+          input.explicitMetadata
+        );
+        if (metaLine === void 0) continue;
+        emitRunMessage(host.emit, {
+          op: "sync",
+          runId: host.runId,
+          level: "detail",
+          message: `  \u25CF ${reportKey} \xB7 ${metaLine}`,
+          target: group.localeCode
+        });
+      }
+    } else {
+      const reportKey = group.reportKeys[0];
+      const metaLine = reportKey !== void 0 ? syncLocaleMetadataDetailLine(reports?.[reportKey], input.explicitStripMetadata, input.explicitMetadata) : void 0;
+      if (metaLine !== void 0) {
+        emitRunMessage(host.emit, {
+          op: "sync",
+          runId: host.runId,
+          level: "detail",
+          message: `  \u25CF ${metaLine}`,
+          target: group.localeCode
+        });
+      }
+    }
+  }
+}
+function runSync(ctx, opts, host) {
+  host.emitProgress({ type: "run.progress.sync", phase: "scan_dynamic_sites" });
+  const analysis = resolveProjectAnalysis(ctx, { emit: host.emit, op: "sync", runId: host.runId });
+  const observations = analysis.keyObservations;
+  const dynamicSites = analysis.dynamicSites;
+  const schemaPaths = analysis.usage.resolvedKeys;
+  const eff = resolveReferenceConfig("sync", ctx.config);
+  const refCtx = buildKeyReferenceContextFromReportDetails(observations, dynamicSites, eff);
+  host.emitProgress({
+    type: "run.progress.sync",
+    phase: "scan_dynamic_sites",
+    current: dynamicSites.length,
+    total: dynamicSites.length,
+    label: `${String(dynamicSites.length)} dynamic key site(s)`
+  });
+  const sourcePath = ctx.paths.sourceLocale;
+  host.emitProgress({ type: "run.progress.sync", phase: "read_source", label: sourcePath });
+  const dir = ctx.paths.localesDir;
+  const sel = parseSyncLangSelection(opts.target);
+  if (sel.mode === "codes") {
+    for (const code of sel.codes) {
+      assertNotSourceTargetLocale("sync", code, sourcePath, {
+        paths: ctx.paths,
+        path: ctx.adapters.path
+      });
+    }
+  }
+  const { segments: targets, missingLocaleCodes } = resolveLocaleSegmentTargets(ctx, { selection: sel });
+  host.emitProgress({
+    type: "run.progress.sync",
+    phase: "resolve_targets",
+    total: targets.length
+  });
+  let updated = 0;
+  const fileLines = [];
+  const humanLeafSummaryByLocaleFile = {};
+  const explicitStripMetadata = opts.stripMetadata === true;
+  const explicitMetadata = opts.metadata === true;
+  const modeDecision = resolveLocaleLeafMode({
+    metadataFlag: explicitMetadata,
+    stripMetadataFlag: explicitStripMetadata
+  });
+  const effectiveSchemaPaths = resolveGlobalSyncSchemaPaths(ctx, schemaPaths);
+  const mergedSourceLeaves = readSourceLocaleLeaves(ctx);
+  const sourcePlaceholderLeaves = detectSourcePlaceholderLeaves(
+    mergedSourceLeaves,
+    sourcePlaceholderValues(ctx.config.missing?.placeholder)
+  );
+  const sourcePlaceholderPaths = new Set(sourcePlaceholderLeaves.map((leaf) => leaf.path));
+  const localeMetadataReports = {};
+  const targetPlaceholderLeaves = [];
+  for (let i = 0; i < targets.length; i++) {
+    const segment = targets[i];
+    const file = segment.reportKey;
+    const full = segment.absolutePath;
+    const segmentSource = resolveSyncSegmentSourcePlan(ctx, {
+      targetSegmentRelativePath: segment.relativePath,
+      targetLocaleCode: segment.locale,
+      schemaPaths: effectiveSchemaPaths
+    });
+    const segmentFillLeaves = segmentSource.effectiveSourceLeaves.filter(
+      (leaf) => !sourcePlaceholderPaths.has(leaf.path)
+    );
+    let segmentTemplate = buildSegmentTemplateFromSource(segmentSource.sourceRaw, segmentFillLeaves);
+    const segmentSourceMap = new Map(segmentFillLeaves.map((leaf) => [leaf.path, leaf.value]));
+    host.emitProgress({
+      type: "run.progress.sync",
+      phase: "build_target",
+      target: file,
+      current: i + 1,
+      total: targets.length
+    });
+    const segmentLeafPaths = segmentFillLeaves.map((leaf) => leaf.path);
+    const curRaw = readLocaleJsonFromContextSync(ctx, full);
+    const cur = normalizeLocaleDocumentToNestedCanonical(curRaw, segmentLeafPaths);
+    const targetCode = segment.locale;
+    const targetPlaceholdersForFile = detectLocalePlaceholderLeaves({
+      leaves: collectTranslationSurfaceLeaves(cur),
+      placeholderValues: sourcePlaceholderValues(ctx.config.missing?.placeholder),
+      localeRole: "target",
+      localeCode: targetCode,
+      localePath: full
+    });
+    targetPlaceholderLeaves.push(...targetPlaceholdersForFile);
+    const targetPlaceholderPaths = targetPlaceholdersForFile.map((leaf) => leaf.path);
+    const mergeOpts = eff.uncertainKeyPolicy === "protect" || eff.uncertainKeyPolicy === "warn_only" ? {
+      uncertainKeepPrefixes: refCtx.uncertainPrefixes,
+      skipFillPaths: [...sourcePlaceholderPaths],
+      forceFillPaths: targetPlaceholderPaths
+    } : { skipFillPaths: [...sourcePlaceholderPaths], forceFillPaths: targetPlaceholderPaths };
+    host.emitProgress({
+      type: "run.progress.sync",
+      phase: "merge",
+      target: file,
+      current: i + 1,
+      total: targets.length
+    });
+    const { next } = computeSyncedLocaleJson(
+      segmentTemplate,
+      cur,
+      ctx.config.policies?.preserve,
+      mergeOpts
+    );
+    host.emitProgress({
+      type: "run.progress.sync",
+      phase: "prune",
+      target: file,
+      current: i + 1,
+      total: targets.length
+    });
+    humanLeafSummaryByLocaleFile[file] = summarizeSyncLeavesForHumanLog(segmentFillLeaves, cur, next);
+    let finalNext = next;
+    if (explicitStripMetadata || explicitMetadata) {
+      let metadataInput = next;
+      if (explicitMetadata && targetPlaceholderPaths.length > 0) {
+        for (const placeholderPath of targetPlaceholderPaths) {
+          metadataInput = setAtPath(metadataInput, placeholderPath, null);
+        }
+      }
+      const normalized = applyLocaleLeafMode({
+        localeJson: metadataInput,
+        sourceMap: segmentSourceMap,
+        mode: modeDecision.mode
+      });
+      finalNext = normalized.next;
+      localeMetadataReports[file] = normalized.report;
+    } else {
+      localeMetadataReports[file] = idleLocaleMetadataReportForSkippedSync(segmentSourceMap.size);
+    }
+    finalNext = normalizeLocaleDocumentToNestedCanonical(finalNext, segmentLeafPaths);
+    const finalWouldChange = !localeJsonContentEquals(curRaw, finalNext);
+    if (opts.dryRun) {
+      fileLines.push({ path: full, changed: finalWouldChange });
+      continue;
+    }
+    if (finalWouldChange) {
+      host.emitProgress({
+        type: "run.progress.sync",
+        phase: "write_files",
+        target: file,
+        label: full
+      });
+      writeLocaleJsonFromContextSync(ctx, full, finalNext);
+      updated += 1;
+    }
+    fileLines.push({ path: full, changed: finalWouldChange });
+  }
+  host.emitProgress({
+    type: "run.progress.sync",
+    phase: "done",
+    current: targets.length,
+    total: targets.length
+  });
+  const payload = {
+    kind: "sync",
+    sourcePath,
+    localesDir: dir,
+    targetFiles: targets.length,
+    writtenFiles: updated,
+    dynamicKeySites: dynamicSites.length,
+    dryRun: Boolean(opts.dryRun),
+    files: fileLines,
+    localeMetadataReports
+  };
+  const issues = [
+    ...issuesFromDynamicScanCount(dynamicSites.length),
+    ...issuesFromSyncMissingLocaleFiles(missingLocaleCodes),
+    ...issueFromMetadataFlagConflict(modeDecision.conflict),
+    ...issuesFromSourcePlaceholderLeaves(sourcePlaceholderLeaves),
+    ...issuesFromTargetPlaceholderLeaves(targetPlaceholderLeaves)
+  ];
+  return {
+    payload,
+    issues,
+    fileLines,
+    targets: targets.map((s) => s.reportKey),
+    updated,
+    dynamicSites,
+    keyObservationsCount: observations.length,
+    missingLocaleCodes,
+    humanLeafSummaryByLocaleFile,
+    sourcePlaceholderLeaves,
+    targetPlaceholderLeaves
+  };
+}
+
+// src/sync/resolveTargets.ts
+function resolveSyncTargetFiles(input) {
+  const { localeJsonBasenames, sourceJsonBasename, selection } = input;
+  const allNonSource = localeJsonBasenames.filter((f) => f !== sourceJsonBasename);
+  if (selection.mode === "all") {
+    return { targetFiles: [...allNonSource], missingLocaleCodes: [] };
+  }
+  const codes = selection.codes;
+  const missingLocaleCodes = codes.filter((c) => !allNonSource.includes(`${c}.json`));
+  const targetFiles = codes.map((c) => `${c}.json`).filter((f) => allNonSource.includes(f));
+  return { targetFiles, missingLocaleCodes };
+}
+
+export { canonicalTemplatePathForCollectedLeaf, computeSyncedLocaleJson, emitSyncHumanMessages, idleLocaleMetadataReportForSkippedSync, mergeToTemplateShape, pruneToTemplateShape, readLeafDisplayString, resolveSyncTargetFiles, runSync, stripStructuredLeafMetadata, summarizeSyncLeavesForHumanLog };