@verbatra/sdk 0.6.1 → 0.6.3

package/dist/index.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
-var fs = require('fs');
 var path = require('path');
+var zod = require('zod');
+var fs = require('fs');
 var cosmiconfig = require('cosmiconfig');
 var cosmiconfigTypescriptLoader = require('cosmiconfig-typescript-loader');
 var crypto = require('crypto');
 var promises = require('fs/promises');
-var zod = require('zod');
 var Anthropic = require('@anthropic-ai/sdk');
 var deepl = require('deepl-node');
 var module$1 = require('module');
@@ -17,8 +17,8 @@ var icuMessageformatParser = require('@formatjs/icu-messageformat-parser');
 var xmldom = require('@xmldom/xmldom');
 var yaml = require('yaml');
 var ExcelJS = require('exceljs');
-var stream = require('stream');
 var JSZip = require('jszip');
+var stream = require('stream');
 var chokidar = require('chokidar');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -49,6 +49,103 @@ var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
 var ExcelJS__default = /*#__PURE__*/_interopDefault(ExcelJS);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 
+// src/cache/translation-memory.ts
+var CACHE_FILE_NAME = "verbatra.cache.json";
+var CURRENT_VERSION = 1;
+var EMPTY_MEMORY = { version: CURRENT_VERSION, entries: {} };
+var MAX_CACHE_FILE_BYTES = 64 * 1024 * 1024;
+var translationMemorySchema = zod.z.object({
+  version: zod.z.number().int().positive(),
+  entries: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.string())))
+});
+function cacheFilePath(cwd) {
+  return path.resolve(cwd, CACHE_FILE_NAME);
+}
+var UNUSABLE = { memory: EMPTY_MEMORY, writable: true };
+async function readTranslationMemory(path, fs) {
+  let read;
+  try {
+    read = await fs.readFileBounded(path, MAX_CACHE_FILE_BYTES);
+  } catch {
+    return UNUSABLE;
+  }
+  if (read.kind !== "ok") {
+    return UNUSABLE;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(read.content);
+  } catch {
+    return UNUSABLE;
+  }
+  const result = translationMemorySchema.safeParse(parsed);
+  if (!result.success) {
+    return UNUSABLE;
+  }
+  if (result.data.version !== CURRENT_VERSION) {
+    return { memory: EMPTY_MEMORY, writable: false };
+  }
+  return { memory: result.data, writable: true };
+}
+function lookupMemory(memory, fingerprint, locale, contentHash2) {
+  return memory.entries[fingerprint]?.[locale]?.[contentHash2];
+}
+function applyAdditions(base, fingerprint, additionsByLocale) {
+  if (additionsByLocale.size === 0) {
+    return base;
+  }
+  const fingerprintEntries = {};
+  for (const [locale, hashes] of Object.entries(base.entries[fingerprint] ?? {})) {
+    fingerprintEntries[locale] = { ...hashes };
+  }
+  for (const [locale, hashes] of additionsByLocale) {
+    fingerprintEntries[locale] = { ...fingerprintEntries[locale], ...hashes };
+  }
+  return {
+    version: base.version,
+    entries: { ...base.entries, [fingerprint]: fingerprintEntries }
+  };
+}
+function additionsToRecord(additions) {
+  const record = {};
+  for (const addition of additions) {
+    record[addition.contentHash] = addition.value;
+  }
+  return record;
+}
+function sortEntries(record) {
+  return Object.entries(record).sort(([a], [b]) => a < b ? -1 : 1);
+}
+function serialize(memory) {
+  const entries = {};
+  for (const [fingerprint, locales] of sortEntries(memory.entries)) {
+    const localeMap = {};
+    for (const [locale, hashes] of sortEntries(locales)) {
+      localeMap[locale] = Object.fromEntries(sortEntries(hashes));
+    }
+    entries[fingerprint] = localeMap;
+  }
+  return `${JSON.stringify({ version: memory.version, entries }, null, 2)}
+`;
+}
+async function writeTranslationMemory(path, memory, fs) {
+  await fs.writeFile(path, serialize(memory));
+}
+async function feedTranslationMemory(cwd, fs, fingerprint, additionsByLocale) {
+  if (additionsByLocale.size === 0) {
+    return;
+  }
+  try {
+    const path = cacheFilePath(cwd);
+    const { memory, writable } = await readTranslationMemory(path, fs);
+    if (!writable) {
+      return;
+    }
+    await writeTranslationMemory(path, applyAdditions(memory, fingerprint, additionsByLocale), fs);
+  } catch {
+  }
+}
+
 // src/config/define-config.ts
 function defineConfig(config) {
   return config;
@@ -242,7 +339,7 @@ async function resolveGlossary(glossary, baseDir, fs) {
 var FNV_OFFSET_BASIS = 14695981039346656037n;
 var FNV_PRIME = 1099511628211n;
 var U64_MASK = (1n << 64n) - 1n;
-function fnv1a64(input) {
+function stableStringHash(input) {
   let hash = FNV_OFFSET_BASIS;
   for (let index = 0; index < input.length; index += 1) {
     hash ^= BigInt(input.charCodeAt(index));
@@ -263,7 +360,7 @@ function canonicalize(entry) {
   ]);
 }
 function contentHash(entry) {
-  return fnv1a64(canonicalize(entry));
+  return stableStringHash(canonicalize(entry));
 }
 function sorted(keys) {
   return [...keys].sort();
@@ -308,7 +405,8 @@ var SUPPORTED_FORMATS = [
   "ngx-translate-json",
   "xliff",
   "yaml",
-  "arb"
+  "arb",
+  "properties"
 ];
 var supportedFormatSchema = zod.z.enum(SUPPORTED_FORMATS);
 var translationEntrySchema = zod.z.object({
@@ -1250,14 +1348,14 @@ function throwAbort(signal) {
   throw new DOMException("This operation was aborted.", "AbortError");
 }
 function delay(ms, signal) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const onAbort = () => {
       clearTimeout(timer);
-      resolve9();
+      resolve10();
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve9();
+      resolve10();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -1995,8 +2093,8 @@ async function withLockFileGuard(cwd, fs, fn, options = {}) {
 
 // src/lock/lock-file.ts
 var LOCK_FILE_NAME = "verbatra.lock.json";
-var CURRENT_VERSION = 1;
-var EMPTY_LOCK = { version: CURRENT_VERSION, locales: {} };
+var CURRENT_VERSION2 = 1;
+var EMPTY_LOCK = { version: CURRENT_VERSION2, locales: {} };
 var MAX_LOCK_FILE_BYTES = 16 * 1024 * 1024;
 var lockFileSchema = zod.z.object({
   version: zod.z.number().int().positive(),
@@ -2025,10 +2123,10 @@ function parseLockFileRead(read, path) {
   if (!result.success) {
     throw new SdkError("LOCK_FILE_INVALID", `The lock-file at ${path} has an unexpected shape.`);
   }
-  if (result.data.version !== CURRENT_VERSION) {
+  if (result.data.version !== CURRENT_VERSION2) {
     throw new SdkError(
       "LOCK_FILE_INVALID",
-      `The lock-file at ${path} has version ${result.data.version}, but this version of verbatra supports version ${CURRENT_VERSION}.`
+      `The lock-file at ${path} has version ${result.data.version}, but this version of verbatra supports version ${CURRENT_VERSION2}.`
     );
   }
   return result.data;
@@ -2818,7 +2916,7 @@ function createTreeFileAdapter(options) {
     extensions,
     sniff,
     parse: parse3,
-    serialize,
+    serialize: serialize2,
     deriveEntry,
     extractPlaceholders,
     computeInvalidIcuKeys,
@@ -2853,7 +2951,7 @@ function createTreeFileAdapter(options) {
     },
     async write(resource, filePath) {
       const tree = buildWriteTree ? await buildWriteTree(resource.entries, filePath) : unflattenEntries(resource.entries);
-      await atomicWriteFile(filePath, serialize(tree));
+      await atomicWriteFile(filePath, serialize2(tree));
     }
   };
 }
@@ -3110,6 +3208,401 @@ function createNgxTranslateJsonAdapter() {
     keyMode: "path-notation"
   });
 }
+function toEntries2(content, namespace, parseEntries) {
+  try {
+    return parseEntries(content, namespace);
+  } catch (error) {
+    rethrowStructured(error, "The file could not be parsed.");
+  }
+}
+function createFlatFileAdapter(options) {
+  const {
+    format,
+    extensions,
+    sniff,
+    parseEntries,
+    serializeEntries,
+    extractPlaceholders,
+    validateMessage,
+    computeInvalidIcuKeys
+  } = options;
+  return {
+    format,
+    canHandle: buildCanHandle(extensions, sniff),
+    extractPlaceholders,
+    validateMessage: validateMessage ?? (() => true),
+    async read(filePath, locale) {
+      const content = await readFileContent(filePath);
+      const namespace = namespaceOf(filePath);
+      const entries = toEntries2(content, namespace, parseEntries);
+      const resource = { locale, namespace, format, entries };
+      const invalidIcuKeys = computeIcu(entries, computeInvalidIcuKeys);
+      return { resource, invalidIcuKeys, excludedLeafPaths: [] };
+    },
+    async write(resource, filePath) {
+      const data = await serializeEntries(resource.entries, filePath);
+      await atomicWriteFile(filePath, data);
+    }
+  };
+}
+var SUBMESSAGE_TYPES = /* @__PURE__ */ new Set(["plural", "select", "selectordinal", "choice"]);
+var ARGUMENT_NAME = /^(?:\d+|[A-Za-z_$][\w$-]*)$/;
+function matchingBraces(value) {
+  const close = new Int32Array(value.length).fill(-1);
+  const open3 = [];
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if (char === "{") {
+      open3.push(i);
+    } else if (char === "}") {
+      const start = open3.pop();
+      if (start !== void 0) {
+        close[start] = i;
+      }
+    }
+  }
+  return close;
+}
+function findNameEnd(value, from, limit) {
+  for (let i = from; i < limit; i += 1) {
+    const char = value[i];
+    if (char === ",") {
+      return { comma: i, hasBrace: false };
+    }
+    if (char === "{" || char === "}") {
+      return { comma: -1, hasBrace: true };
+    }
+  }
+  return { comma: -1, hasBrace: false };
+}
+function parseArgumentAt(value, open3, close) {
+  const { comma, hasBrace } = findNameEnd(value, open3 + 1, close);
+  if (hasBrace) {
+    return null;
+  }
+  const nameEnd = comma === -1 ? close : comma;
+  const name = value.slice(open3 + 1, nameEnd).trim();
+  if (!ARGUMENT_NAME.test(name)) {
+    return null;
+  }
+  if (comma === -1) {
+    return { name, type: null, styleStart: -1 };
+  }
+  const secondComma = value.indexOf(",", comma + 1);
+  if (secondComma === -1 || secondComma >= close) {
+    return { name, type: value.slice(comma + 1, close).trim(), styleStart: -1 };
+  }
+  return { name, type: value.slice(comma + 1, secondComma).trim(), styleStart: secondComma + 1 };
+}
+function canonicalToken(value, arg, close) {
+  if (arg.type === null) {
+    return `{${arg.name}}`;
+  }
+  if (arg.styleStart === -1) {
+    return `{${arg.name},${arg.type}}`;
+  }
+  return `{${arg.name},${arg.type},${value.slice(arg.styleStart, close).trim()}}`;
+}
+function emitArgument(value, close, arg, closeIndex, out) {
+  if (arg.type !== null && SUBMESSAGE_TYPES.has(arg.type)) {
+    out.push(`{${arg.name},${arg.type}}`);
+    if (arg.styleStart !== -1) {
+      scanRange(value, close, arg.styleStart, closeIndex, false, out);
+    }
+    return;
+  }
+  out.push(canonicalToken(value, arg, closeIndex));
+}
+function scanRange(value, close, start, end, topLevel, out) {
+  let i = start;
+  while (i < end) {
+    if (value[i] !== "{") {
+      i += 1;
+      continue;
+    }
+    if (topLevel && value[i + 1] === "{") {
+      i += 2;
+      continue;
+    }
+    const closeIndex = close[i] ?? -1;
+    if (closeIndex === -1 || closeIndex >= end) {
+      i += 1;
+      continue;
+    }
+    const arg = parseArgumentAt(value, i, closeIndex);
+    if (arg === null) {
+      i += 1;
+      continue;
+    }
+    emitArgument(value, close, arg, closeIndex, out);
+    i = closeIndex + 1;
+  }
+}
+function extractPropertiesPlaceholders(value) {
+  const out = [];
+  scanRange(value, matchingBraces(value), 0, value.length, true, out);
+  return out;
+}
+var UNICODE_ESCAPE = /^[0-9a-fA-F]{4}$/;
+var LEADING_WHITESPACE = /^[ \t\f]+/;
+var TRAILING_TERMINATOR = /(?:\r\n|\r|\n)$/;
+function detectLineTerminator(content) {
+  if (content.includes("\r\n")) {
+    return "\r\n";
+  }
+  return content.includes("\r") ? "\r" : "\n";
+}
+function isPropertiesWhitespace(char) {
+  return char === " " || char === "	" || char === "\f";
+}
+function splitPhysicalLines(content) {
+  if (content === "") {
+    return [];
+  }
+  const lines = content.split(/\r\n|\r|\n/);
+  if (TRAILING_TERMINATOR.test(content)) {
+    lines.pop();
+  }
+  return lines;
+}
+function countTrailingBackslashes(line) {
+  let count = 0;
+  for (let i = line.length - 1; i >= 0 && line[i] === "\\"; i -= 1) {
+    count += 1;
+  }
+  return count;
+}
+function isContinued(line) {
+  return countTrailingBackslashes(line) % 2 === 1;
+}
+function isBlankLine(line) {
+  return line.trim() === "";
+}
+function isCommentLine(line) {
+  const trimmed = line.replace(LEADING_WHITESPACE, "");
+  return trimmed.startsWith("#") || trimmed.startsWith("!");
+}
+function joinContinuation(lines, start) {
+  const pieces = [];
+  let index = start;
+  let current = lines[start] ?? "";
+  while (isContinued(current) && index + 1 < lines.length) {
+    pieces.push(current.slice(0, -1));
+    index += 1;
+    current = (lines[index] ?? "").replace(LEADING_WHITESPACE, "");
+  }
+  if (isContinued(current)) {
+    current = current.slice(0, -1);
+  }
+  pieces.push(current);
+  return { logical: pieces.join(""), nextIndex: index + 1 };
+}
+function decodeSimpleEscape(char) {
+  switch (char) {
+    case "t":
+      return "	";
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "f":
+      return "\f";
+    default:
+      return char;
+  }
+}
+function decodeUnicodeEscape(raw, at) {
+  const hex = raw.slice(at, at + 4);
+  if (!UNICODE_ESCAPE.test(hex)) {
+    throw new AdapterError("INVALID_STRUCTURE", "The file has a malformed unicode escape.");
+  }
+  return String.fromCharCode(Number.parseInt(hex, 16));
+}
+function decodeEscapes(raw) {
+  let out = "";
+  let i = 0;
+  while (i < raw.length) {
+    const char = raw[i];
+    if (char !== "\\") {
+      out += char;
+      i += 1;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next === void 0) {
+      break;
+    }
+    if (next === "u") {
+      out += decodeUnicodeEscape(raw, i + 2);
+      i += 6;
+      continue;
+    }
+    out += decodeSimpleEscape(next);
+    i += 2;
+  }
+  return out;
+}
+function keyEndIndex(logical, from) {
+  let i = from;
+  while (i < logical.length) {
+    const char = logical[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === void 0 || isPropertiesWhitespace(char) || char === "=" || char === ":") {
+      break;
+    }
+    i += 1;
+  }
+  return i;
+}
+function skipWhitespace(logical, from) {
+  let i = from;
+  while (i < logical.length) {
+    const char = logical[i];
+    if (char === void 0 || !isPropertiesWhitespace(char)) {
+      break;
+    }
+    i += 1;
+  }
+  return i;
+}
+function parseEntryLine(logical) {
+  const keyStart = skipWhitespace(logical, 0);
+  const keyEnd = keyEndIndex(logical, keyStart);
+  const afterKey = skipWhitespace(logical, keyEnd);
+  const separator = logical[afterKey];
+  const valueStart = separator === "=" || separator === ":" ? skipWhitespace(logical, afterKey + 1) : afterKey;
+  return {
+    key: decodeEscapes(logical.slice(keyStart, keyEnd)),
+    value: decodeEscapes(logical.slice(valueStart))
+  };
+}
+function parseItems(content) {
+  const lines = splitPhysicalLines(content);
+  const items = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    if (isBlankLine(line) || isCommentLine(line)) {
+      items.push({ kind: "raw", text: line });
+      i += 1;
+      continue;
+    }
+    const { logical, nextIndex } = joinContinuation(lines, i);
+    items.push({ kind: "entry", ...parseEntryLine(logical) });
+    i = nextIndex;
+  }
+  return items;
+}
+function parsePropertiesEntries(content, namespace) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of parseItems(content)) {
+    if (item.kind === "entry") {
+      map.set(item.key, {
+        key: item.key,
+        namespace,
+        value: item.value,
+        placeholders: extractPropertiesPlaceholders(item.value),
+        isPlural: false
+      });
+    }
+  }
+  return map;
+}
+function unicodeEscape(code) {
+  return `\\u${code.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function escapeChar(char, isFirst, isKey) {
+  switch (char) {
+    case "\\":
+      return "\\\\";
+    case "	":
+      return "\\t";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\f":
+      return "\\f";
+    case " ":
+      return isKey || isFirst ? "\\ " : " ";
+  }
+  if (isKey && (char === "=" || char === ":" || char === "#" || char === "!")) {
+    return `\\${char}`;
+  }
+  const code = char.charCodeAt(0);
+  return code < 32 || code > 126 ? unicodeEscape(code) : char;
+}
+function escapeString(input, isKey) {
+  let out = "";
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    if (char !== void 0) {
+      out += escapeChar(char, i === 0, isKey);
+    }
+  }
+  return out;
+}
+function formatEntry(key, value) {
+  return `${escapeString(key, true)}=${escapeString(value, false)}`;
+}
+function isFileNotFound(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readStructure(filePath) {
+  let outcome;
+  try {
+    outcome = await readBounded2(filePath);
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return { items: [], terminator: "\n" };
+    }
+    throw new AdapterError("INVALID_STRUCTURE", "The destination file could not be read.");
+  }
+  if (outcome.kind === "not-a-file") {
+    throw new AdapterError("INVALID_STRUCTURE", "The destination path is not a regular file.");
+  }
+  if (outcome.kind === "too-large") {
+    throw new AdapterError("INPUT_TOO_LARGE", "The file exceeds the maximum allowed size.");
+  }
+  return {
+    items: parseItems(outcome.content),
+    terminator: detectLineTerminator(outcome.content)
+  };
+}
+async function serializePropertiesEntries(entries, filePath) {
+  const { items, terminator } = await readStructure(filePath);
+  const emitted = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const item of items) {
+    if (item.kind === "raw") {
+      lines.push(item.text);
+      continue;
+    }
+    const entry = entries.get(item.key);
+    if (entry !== void 0 && !emitted.has(item.key)) {
+      lines.push(formatEntry(item.key, entry.value));
+      emitted.add(item.key);
+    }
+  }
+  for (const [key, entry] of entries) {
+    if (!emitted.has(key)) {
+      lines.push(formatEntry(key, entry.value));
+    }
+  }
+  return lines.length === 0 ? "" : `${lines.join(terminator)}${terminator}`;
+}
+function createPropertiesAdapter() {
+  return createFlatFileAdapter({
+    format: "properties",
+    extensions: [".properties"],
+    parseEntries: parsePropertiesEntries,
+    serializeEntries: serializePropertiesEntries,
+    extractPlaceholders: extractPropertiesPlaceholders
+  });
+}
 var AdapterRegistry = class {
   adapters = [];
   /**
@@ -3187,43 +3680,6 @@ function createVueI18nJsonAdapter() {
     })
   });
 }
-function toEntries2(content, namespace, parseEntries) {
-  try {
-    return parseEntries(content, namespace);
-  } catch (error) {
-    rethrowStructured(error, "The file could not be parsed.");
-  }
-}
-function createFlatFileAdapter(options) {
-  const {
-    format,
-    extensions,
-    sniff,
-    parseEntries,
-    serializeEntries,
-    extractPlaceholders,
-    validateMessage,
-    computeInvalidIcuKeys
-  } = options;
-  return {
-    format,
-    canHandle: buildCanHandle(extensions, sniff),
-    extractPlaceholders,
-    validateMessage: validateMessage ?? (() => true),
-    async read(filePath, locale) {
-      const content = await readFileContent(filePath);
-      const namespace = namespaceOf(filePath);
-      const entries = toEntries2(content, namespace, parseEntries);
-      const resource = { locale, namespace, format, entries };
-      const invalidIcuKeys = computeIcu(entries, computeInvalidIcuKeys);
-      return { resource, invalidIcuKeys, excludedLeafPaths: [] };
-    },
-    async write(resource, filePath) {
-      const data = await serializeEntries(resource.entries, filePath);
-      await atomicWriteFile(filePath, data);
-    }
-  };
-}
 var XLIFF_PATTERN = /<(?:x|g|bx|ex|ph|it|mrk)\b[^>]*>|\{[^{}]+\}/g;
 function extractXliffPlaceholders(value) {
   const result = [];
@@ -3534,7 +3990,7 @@ function createYamlAdapter() {
   });
 }
 function createDefaultRegistry() {
-  return new AdapterRegistry().register(createI18nextJsonAdapter()).register(createVueI18nJsonAdapter()).register(createNextIntlJsonAdapter()).register(createNgxTranslateJsonAdapter()).register(createXliffAdapter()).register(createYamlAdapter()).register(createArbAdapter());
+  return new AdapterRegistry().register(createI18nextJsonAdapter()).register(createVueI18nJsonAdapter()).register(createNextIntlJsonAdapter()).register(createNgxTranslateJsonAdapter()).register(createXliffAdapter()).register(createYamlAdapter()).register(createArbAdapter()).register(createPropertiesAdapter());
 }
 
 // src/selection/select-adapter.ts
@@ -3655,6 +4111,28 @@ async function diff(input, deps = {}) {
   return { hasPendingChanges: locales.some((entry) => entry.hasPendingChanges), locales };
 }
 
+// src/cache/fingerprint.ts
+function fingerprintModel(provider) {
+  const options = provider.options;
+  const model = options.model;
+  return typeof model === "string" ? model : null;
+}
+function sortGlossary(glossary) {
+  if (glossary === void 0) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(glossary).sort(([a], [b]) => a < b ? -1 : 1));
+}
+function computeFingerprint(config) {
+  const canonical = JSON.stringify({
+    provider: config.provider.id,
+    model: fingerprintModel(config.provider),
+    tone: config.tone ?? null,
+    glossary: sortGlossary(config.glossary)
+  });
+  return stableStringHash(canonical);
+}
+
 // src/flow/integrity-gate.ts
 function gateCandidateValue(sourceEntry, candidateValue, adapter) {
   const placeholderResult = adapter.comparePlaceholders?.(sourceEntry.value, candidateValue) ?? checkPlaceholders(sourceEntry.placeholders, adapter.extractPlaceholders(candidateValue));
@@ -3667,6 +4145,9 @@ function gateCandidateValue(sourceEntry, candidateValue, adapter) {
   if (assessValueDegeneracy(sourceEntry.value, candidateValue).degenerate) {
     return { accepted: false, reason: "degenerate" };
   }
+  if (sourceEntry.value.trim() !== "" && candidateValue.trim() === "") {
+    return { accepted: false, reason: "empty" };
+  }
   return { accepted: true };
 }
 
@@ -3705,6 +4186,12 @@ async function editEntry(input, deps = {}) {
       mode: "merge",
       entries: { [input.key]: contentHash(sourceEntry) }
     });
+    await feedTranslationMemory(
+      cwd,
+      fs,
+      computeFingerprint(config),
+      /* @__PURE__ */ new Map([[locale, { [contentHash(sourceEntry)]: input.value }]])
+    );
     return { accepted: true, value: input.value };
   });
 }
@@ -3922,13 +4409,19 @@ async function retranslateEntry(input, deps = {}) {
       mode: "merge",
       entries: { [input.key]: contentHash(sourceEntry) }
     });
+    await feedTranslationMemory(
+      cwd,
+      fs,
+      computeFingerprint(config),
+      /* @__PURE__ */ new Map([[locale, { [contentHash(sourceEntry)]: value }]])
+    );
     const reviewReasons = result.reviewFlags?.get(input.key)?.reasons ?? [];
     return { accepted: true, value, reviewReasons };
   });
 }
 var RUN_STATUS_DIR_NAME = ".verbatra-local";
 var RUN_STATUS_FILE_NAME = "run-status.json";
-var CURRENT_VERSION2 = 1;
+var CURRENT_VERSION3 = 1;
 var MAX_RUN_STATUS_FILE_BYTES = 16 * 1024 * 1024;
 var reviewReasonCodeSchema = zod.z.enum([
   "LENGTH_RATIO_OUTLIER",
@@ -3978,7 +4471,7 @@ function toRunStatusLocale(locale) {
 }
 function buildRunStatusFile(summary, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
-    version: CURRENT_VERSION2,
+    version: CURRENT_VERSION3,
     generatedAt,
     ...summary.usage !== void 0 ? { usage: summary.usage } : {},
     ...summary.budget !== void 0 ? { budget: summary.budget } : {},
@@ -4011,7 +4504,7 @@ async function readRunStatusFile(path, fs) {
     return void 0;
   }
   const result = runStatusFileSchema.safeParse(parsed);
-  if (!result.success || result.data.version !== CURRENT_VERSION2) {
+  if (!result.success || result.data.version !== CURRENT_VERSION3) {
     return void 0;
   }
   return fromParsed(result.data);
@@ -4090,12 +4583,16 @@ function failureSummary(locale, error) {
     orphaned: [],
     pruned: [],
     invalidIcuSource: [],
+    cacheHits: [],
     integrityMismatches: [],
     providerFailures: [],
     budgetWithheld: [],
     generated: [],
     notices: [],
     needsReview: [],
+    unfilled: [],
+    malformedRows: [],
+    duplicateKeys: [],
     error: describeError(error)
   };
 }
@@ -4104,7 +4601,7 @@ function deriveLocaleStatus(parts) {
   if (!withheld) {
     return "succeeded";
   }
-  const accepted = parts.translated.length > 0 || parts.generated.length > 0;
+  const accepted = parts.translated.length > 0 || parts.cacheHits.length > 0 || parts.generated.length > 0;
   return accepted ? "partial" : "failed";
 }
 function partition(locales) {
@@ -4424,6 +4921,101 @@ function foldGenerationItem(item, result, adapter, accepted, withheld, providerF
 }
 
 // src/flow/locale-run.ts
+function partitionCacheHits(params, toTranslate) {
+  const cache = params.cache;
+  const hits = /* @__PURE__ */ new Map();
+  if (cache === void 0) {
+    return { hits, misses: toTranslate };
+  }
+  const misses = [];
+  for (const key of toTranslate) {
+    const source = params.source.entries.get(key);
+    if (source === void 0) {
+      continue;
+    }
+    const cached = lookupMemory(
+      cache.snapshot,
+      cache.fingerprint,
+      params.targetLocale,
+      contentHash(source)
+    );
+    if (cached !== void 0 && gateCandidateValue(source, cached, params.adapter).accepted) {
+      hits.set(key, { value: cached, source });
+    } else {
+      misses.push(key);
+    }
+  }
+  return { hits, misses };
+}
+function collectCacheAdditions(params, accepted, cacheHitKeys) {
+  if (params.cache === void 0) {
+    return [];
+  }
+  const additions = [];
+  for (const [key, entry] of accepted) {
+    if (!cacheHitKeys.has(key)) {
+      additions.push({ contentHash: contentHash(entry.source), value: entry.value });
+    }
+  }
+  return additions;
+}
+function groupMissesByContent(params, misses) {
+  const byHash = /* @__PURE__ */ new Map();
+  for (const key of misses) {
+    const source = params.source.entries.get(key);
+    if (source === void 0) {
+      continue;
+    }
+    const existing = byHash.get(contentHash(source));
+    if (existing === void 0) {
+      byHash.set(contentHash(source), { representative: key, duplicates: [] });
+    } else {
+      existing.duplicates.push(key);
+    }
+  }
+  return [...byHash.values()];
+}
+function fanOutContentDuplicates(params, groups, outcome) {
+  for (const group of groups) {
+    if (group.duplicates.length > 0) {
+      applyGroupOutcome(params, group, outcome);
+    }
+  }
+}
+function applyGroupOutcome(params, group, outcome) {
+  const acceptedRepresentative = outcome.accepted.get(group.representative);
+  if (acceptedRepresentative !== void 0) {
+    fanOutAccepted(params, group, acceptedRepresentative, outcome);
+    return;
+  }
+  withheldBucketFor(group.representative, outcome).push(...group.duplicates);
+}
+function fanOutAccepted(params, group, acceptedRepresentative, outcome) {
+  const flag = outcome.reviewFlags.get(group.representative);
+  for (const key of group.duplicates) {
+    const source = params.source.entries.get(key);
+    if (source === void 0) {
+      continue;
+    }
+    if (!gateCandidateValue(source, acceptedRepresentative.value, params.adapter).accepted) {
+      outcome.integrityMismatches.push(key);
+      continue;
+    }
+    outcome.accepted.set(key, { value: acceptedRepresentative.value, source });
+    if (flag !== void 0) {
+      outcome.reviewFlags.set(key, flag);
+    }
+  }
+}
+function withheldBucketFor(representative, outcome) {
+  if (outcome.integrityMismatches.includes(representative)) {
+    return outcome.integrityMismatches;
+  }
+  if (outcome.budgetWithheld.includes(representative)) {
+    return outcome.budgetWithheld;
+  }
+  return outcome.providerFailures;
+}
 function buildRequest3(params, entries) {
   return {
     sourceLocale: params.sourceLocale,
@@ -4466,6 +5058,7 @@ async function runLocale(params) {
         orphaned,
         invalidIcuSource,
         translated: toTranslate,
+        cacheHits: [],
         generated: [],
         integrityMismatches: [],
         providerFailures: [],
@@ -4473,12 +5066,16 @@ async function runLocale(params) {
         pruned,
         notices: sdkNotices
       }),
-      lockEntries: {}
+      lockEntries: {},
+      cacheAdditions: []
     };
   }
-  const entries = toTranslate.map((key) => params.source.entries.get(key)).filter((entry) => entry !== void 0);
+  const partition2 = partitionCacheHits(params, toTranslate);
+  const cacheHitKeys = new Set(partition2.hits.keys());
+  const missGroups = groupMissesByContent(params, partition2.misses);
+  const entries = missGroups.map((group) => params.source.entries.get(group.representative)).filter((entry) => entry !== void 0);
   const startedStopped = params.budget.stopped;
-  const accepted = /* @__PURE__ */ new Map();
+  const accepted = new Map(partition2.hits);
   const integrityMismatches = [];
   const providerFailures = [];
   const budgetWithheld = [];
@@ -4493,6 +5090,13 @@ async function runLocale(params) {
     budgetWithheld,
     reviewFlags
   );
+  fanOutContentDuplicates(params, missGroups, {
+    accepted,
+    integrityMismatches,
+    providerFailures,
+    budgetWithheld,
+    reviewFlags
+  });
   const merged = new Map(target.entries);
   for (const key of pruned) {
     merged.delete(key);
@@ -4539,7 +5143,8 @@ async function runLocale(params) {
       unchanged: diff2.unchanged,
       orphaned,
       invalidIcuSource,
-      translated: [...accepted.keys()],
+      translated: [...accepted.keys()].filter((key) => !cacheHitKeys.has(key)),
+      cacheHits: [...cacheHitKeys].sort(),
       generated: generation.accepted.map((form) => form.targetKey).sort(),
       integrityMismatches: [...integrityMismatches, ...generation.withheld].sort(),
       providerFailures: [...providerFailures, ...generation.providerFailures].sort(),
@@ -4549,7 +5154,8 @@ async function runLocale(params) {
       needsReview: needsReviewFor(accepted.keys(), reviewFlags),
       ...localeUsage !== void 0 ? { usage: localeUsage } : {}
     }),
-    lockEntries: computeLockEntries(params, merged, withheld, generation.accepted)
+    lockEntries: computeLockEntries(params, merged, withheld, generation.accepted),
+    cacheAdditions: collectCacheAdditions(params, accepted, cacheHitKeys)
   };
 }
 var NO_GENERATION_RESULT = {
@@ -4600,12 +5206,16 @@ function baseSummary(parts) {
     orphaned: parts.orphaned,
     pruned: parts.pruned,
     invalidIcuSource: parts.invalidIcuSource,
+    cacheHits: parts.cacheHits,
     integrityMismatches: parts.integrityMismatches,
     providerFailures: parts.providerFailures,
     budgetWithheld: parts.budgetWithheld,
     generated: parts.generated,
     notices: parts.notices,
     needsReview: parts.needsReview ?? [],
+    unfilled: [],
+    malformedRows: [],
+    duplicateKeys: [],
     ...parts.usage !== void 0 ? { usage: parts.usage } : {}
   };
 }
@@ -4623,7 +5233,16 @@ async function translateAndCheck(provider, params, entries, accepted, integrityM
   const notices = [];
   const usage = createUsageAccumulator();
   let tripped = false;
-  for (const batch of chunk(entries, params.maxBatchSize)) {
+  const batches = chunk(entries, params.maxBatchSize);
+  let batchIndex = 0;
+  for (const batch of batches) {
+    batchIndex += 1;
+    params.onProgress?.({
+      type: "sub-batch",
+      locale: params.targetLocale,
+      batchIndex,
+      totalBatches: batches.length
+    });
     if (params.budget.stopped) {
       for (const entry of batch) {
         budgetWithheld.push(entry.key);
@@ -4769,6 +5388,33 @@ async function recordRunStatus(cwd, dryRun, summary, fs) {
   } catch {
   }
 }
+async function createRunCacheState(input, config, cwd, dryRun, fs) {
+  if (dryRun || input.cache === false) {
+    return void 0;
+  }
+  const { memory, writable } = await readTranslationMemory(cacheFilePath(cwd), fs);
+  return { memory, writable, fingerprint: computeFingerprint(config), additions: /* @__PURE__ */ new Map() };
+}
+function withCacheNotices(summaries, cache) {
+  if (cache === void 0 || cache.writable) {
+    return [...summaries];
+  }
+  const notice = {
+    code: "CACHE_VERSION_UNRECOGNIZED",
+    message: `${CACHE_FILE_NAME} carries a version this build does not recognize, so it was written by a newer verbatra. It was left untouched and this run used no cache. Upgrade verbatra, or delete the file to rebuild it in this build's format.`
+  };
+  return summaries.map((summary) => ({ ...summary, notices: [...summary.notices, notice] }));
+}
+async function recordCacheAdditions(cwd, cache, fs) {
+  if (cache === void 0 || cache.additions.size === 0 || !cache.writable) {
+    return;
+  }
+  try {
+    const merged = applyAdditions(cache.memory, cache.fingerprint, cache.additions);
+    await writeTranslationMemory(cacheFilePath(cwd), merged, fs);
+  } catch {
+  }
+}
 function buildLocaleRunParams(context, targetLocale, baseline) {
   return {
     source: context.source.resource,
@@ -4787,7 +5433,9 @@ function buildLocaleRunParams(context, targetLocale, baseline) {
     generatePlurals: context.generatePlurals,
     maxBatchSize: context.maxBatchSize,
     fs: context.fs,
-    budget: context.budget
+    budget: context.budget,
+    ...context.cache !== void 0 ? { cache: { snapshot: context.cache.memory, fingerprint: context.cache.fingerprint } } : {},
+    ...context.onProgress !== void 0 ? { onProgress: context.onProgress } : {}
   };
 }
 async function runDryLocale(context, targetLocale, lock) {
@@ -4811,6 +5459,9 @@ async function runLiveLocale(context, targetLocale) {
         mode: "replace",
         entries: result.lockEntries
       });
+      if (context.cache !== void 0 && result.cacheAdditions.length > 0) {
+        context.cache.additions.set(targetLocale, additionsToRecord(result.cacheAdditions));
+      }
       return result.summary;
     },
     lockOptions
@@ -4826,27 +5477,98 @@ async function runOneLocale(targetLocale, run) {
     return failureSummary(targetLocale, error);
   }
 }
-async function runAllLocalesDry(context, targetLocales) {
+async function runLocaleAt(context, targetLocales, localeIndex, runOne, results) {
+  const targetLocale = targetLocales[localeIndex];
+  if (targetLocale === void 0) {
+    return;
+  }
+  context.onProgress?.({
+    type: "locale-started",
+    locale: targetLocale,
+    localeIndex,
+    totalLocales: targetLocales.length
+  });
+  const summary = await runOneLocale(targetLocale, () => runOne(targetLocale));
+  results[localeIndex] = summary;
+  context.onProgress?.({
+    type: "locale-finished",
+    locale: targetLocale,
+    translated: summary.translated.length,
+    localeIndex,
+    totalLocales: targetLocales.length
+  });
+}
+async function runLocalesWithProgress(context, targetLocales, runOne, concurrency) {
+  const totalLocales = targetLocales.length;
+  const results = new Array(totalLocales);
+  let nextIndex = 0;
+  let abort;
+  async function worker() {
+    while (abort === void 0 && nextIndex < totalLocales) {
+      const localeIndex = nextIndex;
+      nextIndex += 1;
+      try {
+        await runLocaleAt(context, targetLocales, localeIndex, runOne, results);
+      } catch (error) {
+        abort ??= { reason: error };
+      }
+    }
+  }
+  const workerCount = Math.min(concurrency, totalLocales);
+  const workers = [];
+  for (let index = 0; index < workerCount; index += 1) {
+    workers.push(worker());
+  }
+  await Promise.all(workers);
+  if (abort !== void 0) {
+    throw abort.reason;
+  }
+  return results.filter((summary) => summary !== void 0);
+}
+async function runAllLocalesDry(context, targetLocales, concurrency) {
   const lock = await readLockFile(lockFilePath(context.cwd), context.fs);
-  const summaries = [];
-  for (const targetLocale of targetLocales) {
-    summaries.push(
-      await runOneLocale(targetLocale, () => runDryLocale(context, targetLocale, lock))
+  return runLocalesWithProgress(
+    context,
+    targetLocales,
+    (targetLocale) => runDryLocale(context, targetLocale, lock),
+    concurrency
+  );
+}
+async function runAllLocalesLive(context, targetLocales, concurrency) {
+  return runLocalesWithProgress(
+    context,
+    targetLocales,
+    (targetLocale) => runLiveLocale(context, targetLocale),
+    concurrency
+  );
+}
+function resolveConcurrency(value) {
+  if (value === void 0) {
+    return 1;
+  }
+  if (!Number.isInteger(value) || value < 1) {
+    throw new SdkError(
+      "CONCURRENCY_INVALID",
+      `The concurrency option must be an integer of at least 1, got ${value}.`
     );
   }
-  return summaries;
+  return value;
 }
-async function runAllLocalesLive(context, targetLocales) {
-  const summaries = [];
-  for (const targetLocale of targetLocales) {
-    summaries.push(await runOneLocale(targetLocale, () => runLiveLocale(context, targetLocale)));
+function resolveRunConcurrency(value, dryRun, config) {
+  const concurrency = resolveConcurrency(value);
+  if (!dryRun && concurrency > 1 && config.maxTokens !== void 0) {
+    throw new SdkError(
+      "CONCURRENCY_BUDGET_CONFLICT",
+      "A token budget (maxTokens) and concurrency greater than 1 cannot be combined on a live run: concurrent locales would overshoot the budget nondeterministically. Set concurrency to 1, remove maxTokens, or use --dry-run."
+    );
   }
-  return summaries;
+  return concurrency;
 }
 async function translate2(input, deps = {}) {
   const config = input.config;
   const cwd = input.cwd ?? process.cwd();
   const dryRun = input.dryRun ?? false;
+  const concurrency = resolveRunConcurrency(input.concurrency, dryRun, config);
   const prune = input.prune ?? config.prune ?? false;
   const generatePlurals = input.generatePlurals ?? config.generatePlurals ?? false;
   const maxBatchSize = config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
@@ -4858,6 +5580,7 @@ async function translate2(input, deps = {}) {
   const adapter = selectAdapter(config.format, deps.adapterRegistry);
   const provider = dryRun ? void 0 : selectProvider(config.provider, deps.createProvider);
   const source = await readSource(config, cwd, fs, adapter);
+  const cache = await createRunCacheState(input, config, cwd, dryRun, fs);
   const context = {
     source,
     adapter,
@@ -4869,11 +5592,15 @@ async function translate2(input, deps = {}) {
     maxBatchSize,
     fs,
     budget,
+    cache,
     ...input.onLockWait !== void 0 ? { onLockWait: input.onLockWait } : {},
+    ...input.onProgress !== void 0 ? { onProgress: input.onProgress } : {},
     ...input.lockAcquireTimeoutMs !== void 0 ? { lockAcquireTimeoutMs: input.lockAcquireTimeoutMs } : {}
   };
-  const summaries = dryRun ? await runAllLocalesDry(context, config.targetLocales) : await runAllLocalesLive(context, config.targetLocales);
-  const { succeeded, partial, failed } = partition(summaries);
+  const summaries = dryRun ? await runAllLocalesDry(context, config.targetLocales, concurrency) : await runAllLocalesLive(context, config.targetLocales, concurrency);
+  input.onProgress?.({ type: "run-finished", localesCompleted: summaries.length });
+  const locales = withCacheNotices(summaries, cache);
+  const { succeeded, partial, failed } = partition(locales);
   const usage = summaries.reduce(
     (total, summary2) => combineUsage(total, summary2.usage),
     void 0
@@ -4881,13 +5608,14 @@ async function translate2(input, deps = {}) {
   const budgetSummary = toBudgetSummary(budget);
   const summary = {
     dryRun,
-    locales: summaries,
+    locales,
     succeeded,
     partial,
     failed,
     ...usage !== void 0 ? { usage } : {},
     ...budgetSummary !== void 0 ? { budget: budgetSummary } : {}
   };
+  await recordCacheAdditions(cwd, cache, fs);
   await recordRunStatus(cwd, dryRun, summary, fs);
   return summary;
 }
@@ -4903,8 +5631,12 @@ var INSTRUCTIONS_LINES = [
   "How to use this workbook",
   "",
   "1. There is one sheet per language. Open the sheet named for the language you are translating.",
+  "   Do not rename, delete, or reorder the language tabs. verbatra matches each tab to a language by",
+  "   its exact name; a renamed or missing tab is reported and its translations are not imported.",
   "2. Fill ONLY the 'Translation' column. Leave every other column unchanged.",
-  "3. An empty 'Translation' cell means 'not translated yet'. It is skipped, never written as an empty string.",
+  "3. An empty 'Translation' cell means 'not translated yet'. It is skipped, never written as an empty",
+  "   string. A cell that contains only spaces is treated the same as an empty cell.",
+  "   To deliberately clear an existing value (set it to empty), type exactly [[CLEAR]] in the cell.",
   "4. Keep placeholders exactly as they appear. A token such as {name} or {count} must stay verbatim,",
   "   in your translation, with the same spelling. Do not translate or remove it.",
   "5. For ICU messages (for example {count, plural, one {# item} other {# items}}), keep the ICU",
@@ -5069,6 +5801,26 @@ function buildInstructionsSheet(workbook) {
   }
   sheet.getRow(1).font = { bold: true };
 }
+var WORKBOOK_PROTECTION_XML = '<workbookProtection lockStructure="1" lockWindows="0"/>';
+function spliceWorkbookProtection(xml) {
+  const anchor = xml.includes("<bookViews") ? "<bookViews" : "<sheets";
+  return xml.replace(anchor, `${WORKBOOK_PROTECTION_XML}${anchor}`);
+}
+async function protectWorkbookStructure(bytes) {
+  let zip;
+  try {
+    zip = await JSZip__default.default.loadAsync(bytes);
+  } catch {
+    throw new ExchangeError("WORKBOOK_INVALID", "The workbook could not be serialized.");
+  }
+  const workbookPart = zip.file("xl/workbook.xml");
+  if (workbookPart === null) {
+    return bytes;
+  }
+  const xml = await workbookPart.async("string");
+  zip.file("xl/workbook.xml", spliceWorkbookProtection(xml));
+  return zip.generateAsync({ type: "uint8array", compression: "DEFLATE" });
+}
 async function buildWorkbook(model) {
   assertNoWorksheetNameCollisions(model.sheets);
   const workbook = new ExcelJS__default.default.Workbook();
@@ -5076,13 +5828,15 @@ async function buildWorkbook(model) {
   for (const sheet of model.sheets) {
     await buildDataSheet(workbook, sheet);
   }
+  let serialized;
   try {
     const buffer = await workbook.xlsx.writeBuffer();
-    const view = buffer;
-    return Uint8Array.prototype.slice.call(view);
+    serialized = buffer;
   } catch {
     throw new ExchangeError("WORKBOOK_INVALID", "The workbook could not be serialized.");
   }
+  const protectedBytes = await protectWorkbookStructure(serialized);
+  return Uint8Array.prototype.slice.call(protectedBytes);
 }
 var DEFAULT_WORKBOOK_LIMITS = {
   maxDecompressedBytes: 64 * 1024 * 1024,
@@ -5202,26 +5956,24 @@ function assertHeader(sheet) {
     );
   }
 }
-function parseRow(sheet, row) {
+var MALFORMED_ROW_COLUMN = "Status";
+function parseRow(row) {
   const candidate = {
     key: cellString(row.getCell(COLUMN.key)),
     source: cellString(row.getCell(COLUMN.source)),
     currentTarget: cellString(row.getCell(COLUMN.current)),
     status: cellString(row.getCell(COLUMN.status)),
     sourceHash: cellString(row.getCell(COLUMN.sourceHash)),
-    translation: cellString(row.getCell(COLUMN.translation)),
+    translation: cellString(row.getCell(COLUMN.translation)).trim(),
     context: cellString(row.getCell(COLUMN.context)),
     reviewStatus: cellString(row.getCell(COLUMN.reviewStatus)),
     reviewReasons: cellString(row.getCell(COLUMN.reviewReasons))
   };
   const result = rowSchema.safeParse(candidate);
   if (!result.success) {
-    throw new ExchangeError(
-      "WORKBOOK_INVALID",
-      `The sheet "${sheet.name}" has a row with a missing key or an unrecognized status.`
-    );
+    return { ok: false, column: MALFORMED_ROW_COLUMN };
   }
-  return result.data;
+  return { ok: true, row: result.data };
 }
 function readDataSheet(sheet, limits) {
   assertHeader(sheet);
@@ -5232,6 +5984,9 @@ function readDataSheet(sheet, limits) {
     );
   }
   const rows = [];
+  const malformed = [];
+  const duplicates = [];
+  const seenKeys = /* @__PURE__ */ new Set();
   for (let rowNumber = HEADER_ROW + 1; rowNumber <= sheet.rowCount; rowNumber += 1) {
     const row = sheet.getRow(rowNumber);
     if (row.cellCount > limits.maxCellsPerRow) {
@@ -5243,9 +5998,19 @@ function readDataSheet(sheet, limits) {
     if (cellString(row.getCell(COLUMN.key)) === "") {
       continue;
     }
-    rows.push(parseRow(sheet, row));
+    const outcome = parseRow(row);
+    if (!outcome.ok) {
+      malformed.push({ locale: sheet.name, row: rowNumber, column: outcome.column });
+      continue;
+    }
+    if (seenKeys.has(outcome.row.key)) {
+      duplicates.push({ locale: sheet.name, key: outcome.row.key, row: rowNumber });
+      continue;
+    }
+    seenKeys.add(outcome.row.key);
+    rows.push(outcome.row);
   }
-  return { locale: sheet.name, rows };
+  return { sheet: { locale: sheet.name, rows }, malformed, duplicates };
 }
 async function loadWorkbook(bytes) {
   const workbook = new ExcelJS__default.default.Workbook();
@@ -5268,13 +6033,18 @@ async function readWorkbook(bytes, options = {}) {
     );
   }
   const sheets = [];
+  const malformedRows = [];
+  const duplicateKeys = [];
   for (const sheet of workbook.worksheets) {
     if (sheet.name === INSTRUCTIONS_SHEET_NAME) {
       continue;
     }
-    sheets.push(readDataSheet(sheet, limits));
+    const read = readDataSheet(sheet, limits);
+    sheets.push(read.sheet);
+    malformedRows.push(...read.malformed);
+    duplicateKeys.push(...read.duplicates);
   }
-  return { sheets };
+  return { sheets, malformedRows, duplicateKeys };
 }
 
 // src/flow/workbook/export-workbook.ts
@@ -5375,6 +6145,7 @@ async function exportWorkbook(input, deps = {}) {
 }
 
 // src/flow/workbook/import-locale.ts
+var CLEAR_SENTINEL = "[[CLEAR]]";
 var UnknownKeyError = class extends Error {
   key;
   constructor(key) {
@@ -5403,9 +6174,20 @@ function trackBlankDrift(row, params, buckets) {
     buckets.blankDrifted.add(row.key);
   }
 }
-function classifyRows(params, buckets) {
+function classifyClear(row, sourceEntry, buckets) {
+  if (contentHash(sourceEntry) !== row.sourceHash) {
+    buckets.mismatches.push(row.key);
+    buckets.withheld.add(row.key);
+    return;
+  }
+  buckets.accepted.set(row.key, { value: "", source: sourceEntry, cleared: true });
+}
+function classifyRows(params, buckets, liveCandidates) {
   for (const row of params.sheet.rows) {
     if (row.translation === "") {
+      if (liveCandidates.has(row.key)) {
+        buckets.unfilled.push(row.key);
+      }
       trackBlankDrift(row, params, buckets);
       continue;
     }
@@ -5416,9 +6198,17 @@ function classifyRows(params, buckets) {
     if (sourceEntry === void 0) {
       continue;
     }
+    if (row.translation === CLEAR_SENTINEL) {
+      classifyClear(row, sourceEntry, buckets);
+      continue;
+    }
     const reason = judge(row, sourceEntry, params.adapter);
     if (reason === void 0) {
-      buckets.accepted.set(row.key, { value: row.translation, source: sourceEntry });
+      buckets.accepted.set(row.key, {
+        value: row.translation,
+        source: sourceEntry,
+        cleared: false
+      });
     } else {
       buckets.mismatches.push(row.key);
       buckets.withheld.add(row.key);
@@ -5437,9 +6227,10 @@ function importLocale(params) {
     accepted: /* @__PURE__ */ new Map(),
     mismatches: [],
     withheld: /* @__PURE__ */ new Set(),
-    blankDrifted: /* @__PURE__ */ new Set()
+    blankDrifted: /* @__PURE__ */ new Set(),
+    unfilled: []
   };
-  classifyRows(params, buckets);
+  classifyRows(params, buckets, /* @__PURE__ */ new Set([...diff2.missing, ...diff2.changed]));
   const rowKeys = new Set(params.sheet.rows.map((row) => row.key));
   const invalidIcuSource = [...new Set(params.sourceInvalidIcuKeys)].filter((key) => rowKeys.has(key)).sort();
   const translated = [...buckets.accepted.keys()].sort();
@@ -5448,6 +6239,7 @@ function importLocale(params) {
     locale: params.sheet.locale,
     status: deriveLocaleStatus({
       translated,
+      cacheHits: [],
       generated: [],
       integrityMismatches,
       providerFailures: [],
@@ -5458,12 +6250,16 @@ function importLocale(params) {
     orphaned: diff2.orphaned,
     pruned: [],
     invalidIcuSource,
+    cacheHits: [],
     integrityMismatches,
     providerFailures: [],
     budgetWithheld: [],
     generated: [],
     notices: buckets.blankDrifted.size > 0 ? [blankRowBaselineNotice(buckets.blankDrifted.size)] : [],
-    needsReview: []
+    needsReview: [],
+    unfilled: [...new Set(buckets.unfilled)].sort(),
+    malformedRows: params.malformedRows,
+    duplicateKeys: params.duplicateKeys
   };
   return { summary, accepted: buckets.accepted, withheld: buckets.withheld };
 }
@@ -5490,6 +6286,21 @@ function mergeAccepted(target, accepted) {
   }
   return merged;
 }
+function sheetCacheAdditions(accepted) {
+  const record = {};
+  for (const [, { value, source, cleared }] of accepted) {
+    if (!cleared) {
+      record[contentHash(source)] = value;
+    }
+  }
+  return record;
+}
+function collectSheetAdditions(byLocale, locale, additions) {
+  if (Object.keys(additions).length === 0) {
+    return;
+  }
+  byLocale.set(locale, { ...byLocale.get(locale), ...additions });
+}
 function computeLockEntries2(source, merged, baseline, accepted) {
   const entries = {};
   for (const key of merged.keys()) {
@@ -5506,11 +6317,20 @@ function computeLockEntries2(source, merged, baseline, accepted) {
   }
   return entries;
 }
+var MissingSheetError = class extends Error {
+  code = "WORKBOOK_SHEET_MISSING";
+  constructor(locale) {
+    super(
+      `The workbook has no sheet (tab) for the configured target locale "${locale}". The tab may have been renamed, deleted, or reordered out of the workbook.`
+    );
+    this.name = "MissingSheetError";
+  }
+};
 async function runSheet(ctx, sheet, lock) {
   if (!ctx.config.targetLocales.includes(sheet.locale)) {
     throw new SdkError(
       "CONFIG_INVALID",
-      `The workbook has a sheet for locale "${sheet.locale}", which is not a configured target locale.`
+      `The workbook has a sheet named "${sheet.locale}", which is not a configured target locale. It may be a renamed, added, or reordered tab; leave every language tab named exactly as exported.`
     );
   }
   const target = await readTarget(ctx.cwd, ctx.config, ctx.adapter, ctx.fs, sheet.locale);
@@ -5521,10 +6341,12 @@ async function runSheet(ctx, sheet, lock) {
     target,
     baseline,
     adapter: ctx.adapter,
-    sourceInvalidIcuKeys: ctx.sourceInvalidIcuKeys
+    sourceInvalidIcuKeys: ctx.sourceInvalidIcuKeys,
+    malformedRows: ctx.malformedRows.filter((problem) => problem.locale === sheet.locale).map((problem) => ({ row: problem.row, column: problem.column })),
+    duplicateKeys: ctx.duplicateKeys.filter((duplicate) => duplicate.locale === sheet.locale).map((duplicate) => ({ key: duplicate.key, row: duplicate.row }))
   });
   if (ctx.dryRun) {
-    return { summary, lockEntries: {} };
+    return { summary, lockEntries: {}, cacheAdditions: {} };
   }
   const merged = mergeAccepted(target, accepted);
   if (accepted.size > 0) {
@@ -5539,7 +6361,11 @@ async function runSheet(ctx, sheet, lock) {
       path
     );
   }
-  return { summary, lockEntries: computeLockEntries2(ctx.source, merged, baseline, accepted) };
+  return {
+    summary,
+    lockEntries: computeLockEntries2(ctx.source, merged, baseline, accepted),
+    cacheAdditions: sheetCacheAdditions(accepted)
+  };
 }
 async function importWorkbook(input, deps = {}) {
   const config = input.config;
@@ -5564,9 +6390,12 @@ async function importWorkbook(input, deps = {}) {
     fs,
     source: source.resource,
     sourceInvalidIcuKeys: source.invalidIcuKeys,
-    dryRun
+    dryRun,
+    malformedRows: data.malformedRows,
+    duplicateKeys: data.duplicateKeys
   };
   const summaries = [];
+  const cacheAdditions = /* @__PURE__ */ new Map();
   for (const sheet of data.sheets) {
     try {
       let summary;
@@ -5579,6 +6408,7 @@ async function importWorkbook(input, deps = {}) {
             mode: "replace",
             entries: result.lockEntries
           });
+          collectSheetAdditions(cacheAdditions, sheet.locale, result.cacheAdditions);
           return result.summary;
         });
       }
@@ -5587,6 +6417,15 @@ async function importWorkbook(input, deps = {}) {
       summaries.push(failureSummary(sheet.locale, error));
     }
   }
+  const presentLocales = new Set(data.sheets.map((sheet) => sheet.locale));
+  for (const locale of config.targetLocales) {
+    if (!presentLocales.has(locale)) {
+      summaries.push(failureSummary(locale, new MissingSheetError(locale)));
+    }
+  }
+  if (!dryRun) {
+    await feedTranslationMemory(cwd, fs, computeFingerprint(config), cacheAdditions);
+  }
   const { succeeded, partial, failed } = partition(summaries);
   return { dryRun, locales: summaries, succeeded, partial, failed };
 }
@@ -5638,6 +6477,7 @@ async function watch(input, deps = {}) {
   const cwd = input.cwd ?? process.cwd();
   const debounceMs = input.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const fs = deps.fs ?? defaultFs;
+  resolveRunConcurrency(input.concurrency, false, input.config);
   const sourcePath = localeFilePath(cwd, input.config.files.pattern, input.config.sourceLocale);
   if (!await fs.fileExists(sourcePath)) {
     throw new SdkError(
@@ -5650,7 +6490,10 @@ async function watch(input, deps = {}) {
     config: input.config,
     cwd,
     ...input.onLockWait !== void 0 ? { onLockWait: input.onLockWait } : {},
-    ...input.lockAcquireTimeoutMs !== void 0 ? { lockAcquireTimeoutMs: input.lockAcquireTimeoutMs } : {}
+    ...input.onProgress !== void 0 ? { onProgress: input.onProgress } : {},
+    ...input.lockAcquireTimeoutMs !== void 0 ? { lockAcquireTimeoutMs: input.lockAcquireTimeoutMs } : {},
+    ...input.concurrency !== void 0 ? { concurrency: input.concurrency } : {},
+    ...input.cache !== void 0 ? { cache: input.cache } : {}
   };
   let state = "idle";
   let pending = false;
@@ -5718,6 +6561,7 @@ async function watch(input, deps = {}) {
   return { stop };
 }
 
+exports.CACHE_FILE_NAME = CACHE_FILE_NAME;
 exports.DEFAULT_WORKBOOK_PATH = DEFAULT_WORKBOOK_PATH;
 exports.LOCK_FILE_NAME = LOCK_FILE_NAME;
 exports.SdkError = SdkError;