@i18nprune/core 0.1.0

package/dist/cleanup.js

@@ -0,0 +1,3999 @@
+// src/policies/preserve.ts
+function pathMatchesPreserveKey(path, prefix) {
+  return path === prefix || path.startsWith(`${prefix}.`) || path.startsWith(`${prefix}[`);
+}
+function isPreservePath(path, policy) {
+  if (!policy) return false;
+  if (policy.copyKeys?.some((k) => path === k || pathMatchesPreserveKey(path, k))) return true;
+  if (policy.copyPrefixes?.some((p) => path === p || path.startsWith(p))) return true;
+  return false;
+}
+
+// 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/cleanup/candidates.ts
+function pathUnderRoot(key, roots) {
+  for (const r of roots) {
+    if (key === r || key.startsWith(`${r}.`) || key.startsWith(`${r}[`)) return true;
+  }
+  return false;
+}
+function computeCleanupCandidateKeys(input) {
+  const allKeyPaths = new Set(input.leaves.map((l) => l.path));
+  const used = /* @__PURE__ */ new Set();
+  for (const k of allKeyPaths) {
+    if (input.usage.resolvedKeys.has(k)) used.add(k);
+  }
+  const unused = [...allKeyPaths].filter((k) => !used.has(k));
+  let candidates = unused.filter((k) => !isPreservePath(k, input.preserve));
+  let excludedUncertain = 0;
+  if (input.filterUncertainPrefixes) {
+    const before = candidates.length;
+    candidates = candidates.filter((k) => !pathUnderAnyUncertainPrefix(k, input.uncertainPrefixes));
+    excludedUncertain = before - candidates.length;
+  }
+  return { allKeyPaths, candidates, excludedUncertain };
+}
+
+// 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 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/json/localeLeafPath.ts
+function isPlainObject2(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function getLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject2(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    return root[pathStr];
+  }
+  return getAtPath(root, pathStr);
+}
+function hasLocaleLeafAtPath(root, pathStr) {
+  return getLocaleLeafAtPath(root, pathStr) !== void 0;
+}
+function deleteLocaleLeafAtPath(root, pathStr) {
+  if (isPlainObject2(root) && Object.prototype.hasOwnProperty.call(root, pathStr)) {
+    const clone = deepClone(root);
+    delete clone[pathStr];
+    return clone;
+  }
+  return deleteAtPath(root, pathStr);
+}
+
+// src/cleanup/apply.ts
+function applyCleanupKeysToLocaleJson(localeJson, keysToRemove) {
+  let next = localeJson;
+  const removedPaths = [];
+  for (const key of keysToRemove) {
+    if (hasLocaleLeafAtPath(next, key)) {
+      next = deleteLocaleLeafAtPath(next, key);
+      removedPaths.push(key);
+    }
+  }
+  return { next, removedPaths };
+}
+
+// src/cleanup/stringPresence.ts
+var CLEANUP_MIN_VALUE_STRING_PRESENCE_LENGTH = 4;
+function cleanupStringPresenceProbe(_key, value) {
+  const trimmed = value.trim();
+  if (trimmed.length >= CLEANUP_MIN_VALUE_STRING_PRESENCE_LENGTH) {
+    return trimmed;
+  }
+  return null;
+}
+function resolveCleanupKeysWithStringPresencePolicy(input) {
+  const safeToRemove = [];
+  const evidence = [];
+  for (const key of input.candidates) {
+    const leafValue = input.leaves.find((l) => l.path === key)?.value ?? key;
+    if (input.shouldRunStringPresenceForKey && !input.shouldRunStringPresenceForKey({ key, value: leafValue })) {
+      safeToRemove.push(key);
+      continue;
+    }
+    const sample = cleanupStringPresenceProbe(key, leafValue);
+    if (input.stringPresence === "off" || input.skipStringPresenceCheck || !input.stringPresenceAvailable || sample === null) {
+      safeToRemove.push(key);
+      continue;
+    }
+    const hit = input.hasStringPresence(sample);
+    if (input.stringPresence === "guard") {
+      if (!hit) {
+        safeToRemove.push(key);
+        continue;
+      }
+      evidence.push({
+        key,
+        kind: "guard_skipped",
+        locations: input.getStringPresenceLocations(sample, input.stringPresenceMaxHitsPerKey)
+      });
+      continue;
+    }
+    if (hit) {
+      evidence.push({
+        key,
+        kind: "warn_hit",
+        locations: input.getStringPresenceLocations(sample, input.stringPresenceMaxHitsPerKey)
+      });
+    }
+    safeToRemove.push(key);
+  }
+  return { safeToRemove, evidence };
+}
+
+// src/shared/locales/layout/requireStructure.ts
+function localesMode(config) {
+  return config.mode ?? "flat_file";
+}
+function resolveLocalesStructure(config) {
+  if (config.structure !== void 0) {
+    return config.structure;
+  }
+  if (localesMode(config) === "flat_file") {
+    return "locale_file";
+  }
+  throw new Error("locales.structure is required when locales.mode is locale_directory");
+}
+
+// src/shared/locales/layout/resolveLayout.ts
+function resolveLocalesLayout(config, directoryAbsolute) {
+  const mode = localesMode(config);
+  const structure = resolveLocalesStructure(config);
+  return { mode, structure, directoryAbsolute, config };
+}
+function resolveLocalesLayoutFromContext(ctx) {
+  return resolveLocalesLayout(ctx.config.locales, ctx.paths.localesDir);
+}
+function isLocalesLayoutReadSupported(layout) {
+  return layout.mode === "flat_file" && layout.structure === "locale_file" || layout.mode === "locale_directory" && (layout.structure === "locale_per_dir" || layout.structure === "feature_bundle");
+}
+function isLocalesLayoutWriteSupported(layout) {
+  return layout.mode === "flat_file" && layout.structure === "locale_file" || layout.mode === "locale_directory" && (layout.structure === "locale_per_dir" || layout.structure === "feature_bundle");
+}
+
+// src/shared/languages/normalize.ts
+function normalizeLanguageCode(code) {
+  return code.trim().toLowerCase().replace(/_/g, "-");
+}
+
+// src/shared/path/posix.ts
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+// src/shared/constants/issueCodes.ts
+var ISSUE_SCAN_DYNAMIC_KEY_SITES = "i18nprune.scan.dynamic_key_sites";
+var ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED = "i18nprune.cleanup.uncertain_paths_excluded";
+var ISSUE_CLEANUP_RIPGREP_UNAVAILABLE = "i18nprune.cleanup.ripgrep_unavailable";
+var ISSUE_IO_READ_FAILED = "i18nprune.io.read_failed";
+
+// src/shared/path/platform.ts
+function normalizePathKeyForCache(projectRoot) {
+  return toPosixPath(projectRoot).normalize("NFC").toLowerCase();
+}
+
+// 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/enumerate/resolveSegmentPath.ts
+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/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/helpers/sync/assert.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function assertSyncPortResult(value, label, at) {
+  if (isThenable(value)) {
+    throw new I18nPruneError(
+      `Synchronous ${label} requires a plain value (got a Promise at ${at})`,
+      "USAGE"
+    );
+  }
+  return value;
+}
+
+// src/runtime/helpers/sync/fs.ts
+function 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/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/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/locales/enumerate/listLocaleSegments.ts
+function listLocaleSegments(input) {
+  const diagnostics = [];
+  const { layout, fs, path } = input;
+  const recursive = layout.structure !== "locale_file";
+  const walked = walkLocaleJsonSegments({
+    fs,
+    path,
+    rootAbsolute: layout.directoryAbsolute,
+    recursive
+  });
+  const segments = [];
+  for (const segment of walked) {
+    const locale = localeCodeForSegment(layout.structure, path, segment);
+    if (locale === null) continue;
+    segments.push({
+      locale,
+      relativePath: segment.relativePath,
+      absolutePath: segment.absolutePath
+    });
+  }
+  segments.sort((a, b) => {
+    const byLocale = a.locale.localeCompare(b.locale);
+    if (byLocale !== 0) return byLocale;
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+  diagnostics.push(
+    ...collectLocaleStructuralParityDiagnostics({
+      structure: layout.structure,
+      segments
+    })
+  );
+  return { segments, diagnostics };
+}
+
+// src/shared/locales/enumerate/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];
+}
+
+// src/shared/locales/leaves/walk/translationSurfaceWalk.ts
+function isPlainObject3(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function isStructuredLocaleLeafNode(x) {
+  return isPlainObject3(x) && typeof x.value === "string";
+}
+function readOptionalStatus(o) {
+  const s = o.status;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readOptionalLeafSource(o) {
+  const s = o.source;
+  if (typeof s !== "string" || !s.trim()) return void 0;
+  return s;
+}
+function readConfidence(o) {
+  const c = o.confidence;
+  if (c === null || c === void 0) return null;
+  if (typeof c !== "number" || !Number.isFinite(c)) return null;
+  const clamped = Math.max(0, Math.min(1, c));
+  return Math.round(clamped * 100) / 100;
+}
+function readNeedsReview(o) {
+  if (!("needsReview" in o)) return null;
+  return typeof o.needsReview === "boolean" ? o.needsReview : null;
+}
+function readNeedsTranslationAgain(o) {
+  if (!("needsTranslationAgain" in o)) return null;
+  return typeof o.needsTranslationAgain === "boolean" ? o.needsTranslationAgain : null;
+}
+function isCompleteStructuredLocaleLeafMeta(node) {
+  if (!isStructuredLocaleLeafNode(node)) return false;
+  const o = node;
+  if (typeof o.status !== "string" || !o.status.trim()) return false;
+  if (!(o.confidence === null || typeof o.confidence === "number" && Number.isFinite(o.confidence))) return false;
+  if (typeof o.needsReview !== "boolean") return false;
+  if (typeof o.needsTranslationAgain !== "boolean") return false;
+  if (typeof o.source !== "string" || !o.source.trim()) return false;
+  return true;
+}
+function pushStructuredRow(out, prefix, root, fileOrigin) {
+  out.push({
+    path: prefix,
+    value: root.value,
+    shape: "structured",
+    status: readOptionalStatus(root),
+    confidence: readConfidence(root),
+    needsReview: readNeedsReview(root),
+    needsTranslationAgain: readNeedsTranslationAgain(root),
+    source: readOptionalLeafSource(root),
+    structuredMetaComplete: isCompleteStructuredLocaleLeafMeta(root),
+    ...fileOrigin ? { fileOrigin } : {}
+  });
+}
+function collectTranslationSurfaceLeaves(root, prefix = "", out = [], fileOrigin) {
+  if (typeof root === "string") {
+    if (prefix) {
+      out.push({
+        path: prefix,
+        value: root,
+        shape: "legacy_string",
+        confidence: null,
+        needsReview: null,
+        ...fileOrigin ? { fileOrigin } : {}
+      });
+    }
+    return out;
+  }
+  if (isStructuredLocaleLeafNode(root)) {
+    if (prefix) pushStructuredRow(out, prefix, root, fileOrigin);
+    return out;
+  }
+  if (Array.isArray(root)) {
+    root.forEach((item, i) => {
+      const p = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      collectTranslationSurfaceLeaves(item, p, out, fileOrigin);
+    });
+    return out;
+  }
+  if (isPlainObject3(root)) {
+    for (const k of Object.keys(root)) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      collectTranslationSurfaceLeaves(root[k], p, out, fileOrigin);
+    }
+  }
+  return out;
+}
+
+// src/shared/json/parse.ts
+var I18nPruneJsonParseError = class extends I18nPruneError {
+  filePath;
+  line;
+  column;
+  offset;
+  constructor(input) {
+    const options = input.issueCode !== void 0 ? { cause: input.cause, issueCode: input.issueCode } : { cause: input.cause };
+    super(input.message, input.code, options);
+    this.name = "I18nPruneJsonParseError";
+    this.filePath = input.filePath;
+    this.line = input.location.line;
+    this.column = input.location.column;
+    this.offset = input.location.offset;
+  }
+};
+function locationFromOffset(text, offset) {
+  let line = 1;
+  let column = 1;
+  const capped = Math.max(0, Math.min(offset, text.length));
+  for (let i = 0; i < capped; i += 1) {
+    if (text.charCodeAt(i) === 10) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column, offset };
+}
+function getJsonParseLocation(error, text) {
+  const message = error instanceof Error ? error.message : String(error);
+  const positionMatch = /\bposition\s+(\d+)\b/i.exec(message);
+  if (positionMatch?.[1]) {
+    return locationFromOffset(text, Number.parseInt(positionMatch[1], 10));
+  }
+  const lineColumnMatch = /\bline\s+(\d+)\s+column\s+(\d+)\b/i.exec(message);
+  if (lineColumnMatch?.[1] && lineColumnMatch[2]) {
+    return {
+      line: Number.parseInt(lineColumnMatch[1], 10),
+      column: Number.parseInt(lineColumnMatch[2], 10)
+    };
+  }
+  return {};
+}
+function formatJsonParseMessage(filePath, location, cause) {
+  const subject = filePath ? `Invalid JSON in ${filePath}` : "Invalid JSON";
+  const at = location.line !== void 0 && location.column !== void 0 ? ` at line ${String(location.line)}, column ${String(location.column)}` : location.offset !== void 0 ? ` at offset ${String(location.offset)}` : "";
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return `${subject}${at}: ${detail}`;
+}
+function parseJsonText(text, options = {}) {
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    const location = getJsonParseLocation(cause, text);
+    throw new I18nPruneJsonParseError({
+      message: formatJsonParseMessage(options.filePath, location, cause),
+      code: options.code ?? "IO",
+      cause,
+      location,
+      ...options.issueCode !== void 0 ? { issueCode: options.issueCode } : {},
+      ...options.filePath !== void 0 ? { filePath: options.filePath } : {}
+    });
+  }
+}
+function tryParseJsonText(text, options = {}) {
+  try {
+    return { ok: true, data: parseJsonText(text, options) };
+  } catch (error) {
+    if (error instanceof I18nPruneJsonParseError) return { ok: false, error };
+    throw error;
+  }
+}
+
+// src/shared/locales/leaves/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/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/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/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/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;
+}
+
+// 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/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/cleanup/sourceSurface.ts
+function readCleanupSourceLeaves(ctx) {
+  return readLocaleLeavesForCode(ctx, sourceLocaleCodeFromContext(ctx));
+}
+function listCleanupSourceSegmentPaths(ctx) {
+  const layout = resolveLocalesLayoutFromContext(ctx);
+  if (layout.mode === "flat_file") {
+    const rel = ctx.adapters.path.relative(ctx.paths.localesDir, ctx.paths.sourceLocale);
+    return [
+      {
+        absolutePath: ctx.paths.sourceLocale,
+        relativePath: rel.length > 0 ? rel : ctx.adapters.path.basename(ctx.paths.sourceLocale)
+      }
+    ];
+  }
+  const sourceCode = sourceLocaleCodeFromContext(ctx);
+  return segmentsForLocaleCode(ctx, sourceCode).map((s) => ({
+    absolutePath: s.absolutePath,
+    relativePath: s.relativePath
+  }));
+}
+function listCleanupSourceSegmentsForKeys(ctx, keys) {
+  if (keys.length === 0) return [];
+  return listCleanupSourceSegmentPaths(ctx).filter((segment) => {
+    const raw = readLocaleJsonFromContextSync(ctx, segment.absolutePath);
+    return keys.some((key) => hasLocaleLeafAtPath(raw, key));
+  });
+}
+
+// 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/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/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 };
+}
+
+// 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/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/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/cleanup/run.ts
+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 issuesFromCleanupUncertainExcluded(excludedCount) {
+  if (excludedCount <= 0) return [];
+  return [
+    {
+      severity: "info",
+      code: ISSUE_CLEANUP_UNCERTAIN_PATHS_EXCLUDED,
+      message: `${String(excludedCount)} path(s) excluded under uncertain key prefix policy.`,
+      docPath: "commands/cleanup/README"
+    }
+  ];
+}
+function issuesFromCleanupStringPresenceUnavailable(input) {
+  if (input.skipStringPresenceCheck || input.stringPresenceAvailable) return [];
+  return [
+    {
+      severity: "warning",
+      code: ISSUE_CLEANUP_RIPGREP_UNAVAILABLE,
+      message: "String-presence safety is unavailable \u2014 cleanup uses a narrower reference check. Configure a host string-presence probe for stronger safety.",
+      docPath: "commands/cleanup/README"
+    }
+  ];
+}
+function emitCleanupMessage(host, input) {
+  emitRunMessage(host.emit, { op: "cleanup", runId: host.runId, ...input });
+}
+function createCleanupSourceWritePlan(ctx, keysToRemove) {
+  const writes = listCleanupSourceSegmentsForKeys(ctx, keysToRemove).flatMap((segment) => {
+    const sourceJson = readLocaleJsonFromContextSync(ctx, segment.absolutePath);
+    const applied = applyCleanupKeysToLocaleJson(sourceJson, keysToRemove);
+    if (applied.removedPaths.length === 0) return [];
+    return [
+      {
+        sourcePath: segment.absolutePath,
+        relativePath: segment.relativePath,
+        nextSourceJson: applied.next,
+        removedPaths: applied.removedPaths
+      }
+    ];
+  });
+  const removedPaths = writes.flatMap((w) => w.removedPaths);
+  const primary = writes[0];
+  return {
+    writes,
+    keys: [...keysToRemove],
+    sourcePath: primary?.sourcePath ?? ctx.paths.sourceLocale,
+    nextSourceJson: primary?.nextSourceJson ?? readLocaleJsonFromContextSync(ctx, ctx.paths.sourceLocale),
+    removedPaths
+  };
+}
+function writeCleanupPlan(ctx, plan) {
+  for (const write of plan.writes) {
+    if (write.removedPaths.length === 0) continue;
+    writeLocaleJsonFromContextSync(ctx, write.sourcePath, write.nextSourceJson);
+  }
+}
+function emitCleanupAbortMessage(host, reason) {
+  emitCleanupMessage(host, {
+    level: "notice",
+    message: reason === "no_keys_approved" ? "aborted: no keys approved for removal." : "aborted: user declined confirmation.",
+    data: { reason }
+  });
+}
+function emitCleanupAskIgnoredMessage(host) {
+  emitCleanupMessage(host, { level: "info", message: "--ask ignored (not an interactive terminal)." });
+}
+function emitCleanupWriteIntro(host, input) {
+  const fileHint = input.segmentFileCount > 1 ? `${String(input.segmentFileCount)} source segment file(s)` : "source locale file";
+  emitCleanupMessage(host, {
+    level: "warn",
+    message: `removing ${String(input.removeCount)} path(s) from ${fileHint}. Run \`i18nprune sync\` afterwards to align target locale files.`,
+    data: { removeCount: input.removeCount, segmentFileCount: input.segmentFileCount }
+  });
+}
+function emitCleanupWriteDone(host, input) {
+  if (input.wrote) {
+    for (const write of input.plan.writes) {
+      emitCleanupMessage(host, {
+        level: "detail",
+        message: `wrote ${write.sourcePath}`,
+        path: write.sourcePath
+      });
+    }
+  }
+  const filesWritten = input.plan.writes.length;
+  emitCleanupMessage(host, {
+    level: "info",
+    message: `finished \u2014 ${String(filesWritten)} source locale file(s) updated on disk.`,
+    data: { filesWritten }
+  });
+}
+function runCleanup(ctx, opts, host) {
+  emitCleanupMessage(host, { level: "info", message: "scanning source locale and project sources for unused key paths..." });
+  const eff = resolveReferenceConfig("cleanup", ctx.config);
+  const analysis = resolveProjectAnalysis(ctx, { emit: host.emit, op: "cleanup", runId: host.runId });
+  const dynamicSites = analysis.dynamicSites;
+  const refCtx = buildKeyReferenceContextFromLiteralUsageAndDynamicSites(
+    analysis.usage,
+    dynamicSites,
+    eff
+  );
+  const leaves = readCleanupSourceLeaves(ctx);
+  const filterUncertain = eff.uncertainKeyPolicy === "protect" || eff.uncertainKeyPolicy === "warn_only";
+  const { allKeyPaths, candidates, excludedUncertain } = computeCleanupCandidateKeys({
+    leaves,
+    usage: analysis.usage,
+    preserve: ctx.config.policies?.preserve,
+    uncertainPrefixes: refCtx.uncertainPrefixes,
+    filterUncertainPrefixes: filterUncertain
+  });
+  if (excludedUncertain > 0) {
+    emitCleanupMessage(host, {
+      level: "info",
+      message: `excluded ${String(excludedUncertain)} path(s) under uncertain key prefix(es) (${eff.uncertainKeyPolicy}).`,
+      data: { excludedUncertain, uncertainKeyPolicy: eff.uncertainKeyPolicy }
+    });
+  }
+  const skipStringPresenceCheck = Boolean(opts.skipStringPresenceCheck);
+  const stringPresenceAvailable = skipStringPresenceCheck ? false : host.isStringPresenceAvailable();
+  if (!skipStringPresenceCheck && !stringPresenceAvailable && eff.stringPresence !== "off") {
+    emitCleanupMessage(host, {
+      level: "warn",
+      message: "string-presence safety is unavailable \u2014 cleanup uses static key analysis only."
+    });
+  }
+  emitCleanupMessage(host, {
+    level: "info",
+    message: `${String(allKeyPaths.size)} key path(s) in source JSON \xB7 ${String(candidates.length)} unused candidate(s) after preserve / reference rules`,
+    data: { keyPaths: allKeyPaths.size, candidates: candidates.length }
+  });
+  if (candidates.length > 0) {
+    const affected = listCleanupSourceSegmentsForKeys(ctx, candidates);
+    if (affected.length > 0) {
+      emitCleanupMessage(host, {
+        level: "info",
+        message: `unused key path(s) only in: ${affected.map((s) => s.relativePath).join(", ")}`,
+        data: { segmentCount: affected.length }
+      });
+    }
+  }
+  if (dynamicSites.length > 0) {
+    emitCleanupMessage(host, {
+      level: "warn",
+      message: `${String(dynamicSites.length)} translation call(s) use a non-literal key \u2014 cleanup literal-key inference may miss usage; tighten \`reference\` uncertain-key rules or inspect \`i18nprune validate\` / \`locales dynamic\`.`,
+      data: { dynamicKeySites: dynamicSites.length }
+    });
+  }
+  const stringPresence = resolveCleanupKeysWithStringPresencePolicy({
+    candidates,
+    leaves,
+    stringPresence: eff.stringPresence,
+    stringPresenceMaxHitsPerKey: eff.stringPresenceMaxHitsPerKey,
+    skipStringPresenceCheck,
+    stringPresenceAvailable,
+    hasStringPresence: host.hasStringPresence,
+    getStringPresenceLocations: host.getStringPresenceLocations,
+    shouldRunStringPresenceForKey: host.shouldRunStringPresenceForKey
+  });
+  for (const ev of stringPresence.evidence) {
+    const hint = ev.locations.join(", ");
+    emitCleanupMessage(host, {
+      level: "detail",
+      message: ev.kind === "guard_skipped" ? `cleanup: skipping key (probe text still in src \u2014 not proof of static key usage): ${ev.key}${hint ? ` \u2014 e.g. ${hint}` : ""}` : `cleanup: probe text in src (removal still allowed \u2014 reference.stringPresence=warn): ${ev.key}${hint ? ` \u2014 ${hint}` : ""}`,
+      data: { key: ev.key, kind: ev.kind }
+    });
+  }
+  const safeToRemove = stringPresence.safeToRemove;
+  const writePlan = createCleanupSourceWritePlan(ctx, safeToRemove);
+  const issues = [
+    ...issuesFromDynamicScanCount(dynamicSites.length),
+    ...issuesFromCleanupUncertainExcluded(excludedUncertain),
+    ...issuesFromCleanupStringPresenceUnavailable({ skipStringPresenceCheck, stringPresenceAvailable })
+  ];
+  const payload = {
+    wouldRemove: safeToRemove.length,
+    keys: safeToRemove,
+    dynamicKeySites: dynamicSites.length,
+    uncertainPrefixes: refCtx.uncertainPrefixes
+  };
+  if (safeToRemove.length === 0) {
+    emitCleanupMessage(host, { level: "info", message: "nothing to remove (no unused keys after filters)." });
+  }
+  return {
+    payload,
+    issues,
+    writePlan,
+    sourceLeaves: leaves,
+    allKeyPathCount: allKeyPaths.size,
+    candidateKeys: candidates,
+    safeToRemove,
+    excludedUncertain,
+    dynamicSites,
+    keyObservationsCount: analysis.keyObservations.length,
+    stringPresenceAvailable,
+    stringPresenceEvidence: stringPresence.evidence
+  };
+}
+
+export { applyCleanupKeysToLocaleJson, computeCleanupCandidateKeys, createCleanupSourceWritePlan, emitCleanupAbortMessage, emitCleanupAskIgnoredMessage, emitCleanupWriteDone, emitCleanupWriteIntro, listCleanupSourceSegmentPaths, listCleanupSourceSegmentsForKeys, pathUnderRoot, readCleanupSourceLeaves, resolveCleanupKeysWithStringPresencePolicy, runCleanup, writeCleanupPlan };