@verbatra/sdk 0.4.2 → 0.4.4

package/dist/index.js

@@ -15,6 +15,7 @@ import { parse as parse$1, TYPE } from '@formatjs/icu-messageformat-parser';
 import { XMLSerializer, DOMParser } from '@xmldom/xmldom';
 import { stringify, parse } from 'yaml';
 import ExcelJS from 'exceljs';
+import { Readable } from 'stream';
 import JSZip from 'jszip';
 import { watch as watch$1 } from 'chokidar';
 
@@ -151,7 +152,7 @@ function checkPlaceholders(source, translated) {
   const extra = multisetExcess(translatedCounts, sourceCounts);
   const reordered = missing.length === 0 && extra.length === 0 && !sameOrder(source, translated);
   return {
-    matches: missing.length === 0 && extra.length === 0 && !reordered,
+    matches: missing.length === 0 && extra.length === 0,
     missing,
     extra,
     reordered
@@ -472,6 +473,19 @@ function createDefaultClient2() {
   };
   return { client, freeAccount };
 }
+var PLACEHOLDER_UNSUPPORTED_MESSAGE = "Some entries contain placeholders or ICU syntax that DeepL cannot preserve; they were left untranslated. Use an LLM provider to translate placeholder-bearing strings.";
+function partitionByPlaceholders(entries) {
+  const protectable = [];
+  const unprotectable = [];
+  for (const entry of entries) {
+    if (entry.placeholders.length > 0) {
+      unprotectable.push(entry);
+    } else {
+      protectable.push(entry);
+    }
+  }
+  return { protectable, unprotectable };
+}
 var FORMALITY_DOWNGRADED_MESSAGE = "Formality was not applied: the configured DeepL key is a free-tier key, which does not support formality.";
 var GLOSSARY_IGNORED_MESSAGE = "The supplied glossary term map was not applied: DeepL uses configured glossary IDs, not term maps.";
 function buildTranslateOptions(input) {
@@ -535,6 +549,7 @@ function resolveClient(deps) {
 }
 async function translate(bundle, config, request) {
   const data = validateRequest(request);
+  const { protectable, unprotectable } = partitionByPlaceholders(data.entries);
   const genericGlossarySupplied = request.glossary !== void 0 && Object.keys(request.glossary).length > 0;
   const { options, notices } = buildTranslateOptions({
     freeAccount: bundle.freeAccount,
@@ -542,18 +557,28 @@ async function translate(bundle, config, request) {
     ...data.tone !== void 0 ? { tone: data.tone } : {},
     ...config.glossaryId !== void 0 ? { glossaryId: config.glossaryId } : {}
   });
-  const texts = data.entries.map((entry) => entry.value);
-  const results = await callClient2(
+  const { values, integrity } = await translateProtectable(
     bundle.client,
-    texts,
-    data.sourceLocale,
-    data.targetLocale,
-    options
+    data,
+    protectable,
+    options,
+    request.extractPlaceholders
   );
-  const { values, integrityInputs } = zipResults(data.entries, results);
-  const integrity = checkBatchIntegrity(integrityInputs, request.extractPlaceholders);
+  if (unprotectable.length > 0) {
+    notices.push({ code: "PLACEHOLDER_UNSUPPORTED", message: PLACEHOLDER_UNSUPPORTED_MESSAGE });
+  }
   return { values, integrity, notices };
 }
+async function translateProtectable(client, data, protectable, options, extract) {
+  if (protectable.length === 0) {
+    return { values: /* @__PURE__ */ new Map(), integrity: /* @__PURE__ */ new Map() };
+  }
+  const texts = protectable.map((entry) => entry.value);
+  const results = await callClient2(client, texts, data.sourceLocale, data.targetLocale, options);
+  const { values, integrityInputs } = zipResults(protectable, results);
+  const integrity = checkBatchIntegrity(integrityInputs, extract);
+  return { values, integrity };
+}
 function callClient2(client, texts, sourceLang, targetLang, options) {
   return guardProviderCall(() => client.translateText(texts, sourceLang, targetLang, options));
 }
@@ -1127,19 +1152,53 @@ function childMessages(element) {
   }
   return [];
 }
-function collect(elements, add, state) {
+function addCount(target, token, count) {
+  target.set(token, (target.get(token) ?? 0) + count);
+}
+function combineBranches(branchMultisets) {
+  const combined = /* @__PURE__ */ new Map();
+  const tokens = /* @__PURE__ */ new Set();
+  for (const branch of branchMultisets) {
+    for (const token of branch.keys()) {
+      tokens.add(token);
+    }
+  }
+  for (const token of tokens) {
+    const minCount = Math.min(...branchMultisets.map((branch) => branch.get(token) ?? 0));
+    if (minCount > 0) {
+      combined.set(token, minCount);
+    }
+  }
+  return combined;
+}
+function collect(elements, state) {
+  const result = /* @__PURE__ */ new Map();
   for (const element of elements) {
     const token = tokenOf(element);
     if (token !== void 0) {
-      add(token);
+      addCount(result, token, 1);
     }
     if (element.type === TYPE.plural) {
       state.isPlural = true;
     }
-    for (const child of childMessages(element)) {
-      collect(child, add, state);
+    const branches = childMessages(element);
+    if (branches.length > 0) {
+      const branchMultisets = branches.map((branch) => collect(branch, state));
+      for (const [branchToken, branchCount] of combineBranches(branchMultisets)) {
+        addCount(result, branchToken, branchCount);
+      }
     }
   }
+  return result;
+}
+function flatten(multiset) {
+  const flattened = [];
+  for (const [token, count] of multiset) {
+    for (let i = 0; i < count; i += 1) {
+      flattened.push(token);
+    }
+  }
+  return flattened;
 }
 function analyzeIcuValue(value) {
   if (!value.includes("{") && !value.includes("<")) {
@@ -1147,16 +1206,9 @@ function analyzeIcuValue(value) {
   }
   try {
     const ast = parse$1(value);
-    const placeholders = [];
     const state = { isPlural: false };
-    collect(
-      ast,
-      (token) => {
-        placeholders.push(token);
-      },
-      state
-    );
-    return { placeholders, isPlural: state.isPlural, valid: true };
+    const multiset = collect(ast, state);
+    return { placeholders: flatten(multiset), isPlural: state.isPlural, valid: true };
   } catch {
     return INVALID;
   }
@@ -1418,21 +1470,28 @@ function addEntries(ctx, prefix, node) {
     }
   }
 }
-function addPathEntries(node, prefix, namespace, derive, out) {
+function addPathEntries(node, prefix, namespace, derive, out, claimedPaths) {
   for (const [key, value] of Object.entries(node)) {
     const path = prefix === "" ? key : `${prefix}.${key}`;
+    if (claimedPaths.has(path)) {
+      throw new AdapterError(
+        "INVALID_STRUCTURE",
+        "A dotted key and a nested key path resolve to the same path."
+      );
+    }
+    claimedPaths.add(path);
     if (typeof value === "string") {
       const { placeholders, isPlural } = derive(key, value);
       out.set(path, { key: path, namespace, value, placeholders, isPlural });
     } else {
-      addPathEntries(value, path, namespace, derive, out);
+      addPathEntries(value, path, namespace, derive, out, claimedPaths);
     }
   }
 }
 function flattenTree(tree, namespace, derive, keyMode = "literal-leaf") {
   const out = /* @__PURE__ */ new Map();
   if (keyMode === "path-notation") {
-    addPathEntries(tree, "", namespace, derive, out);
+    addPathEntries(tree, "", namespace, derive, out, /* @__PURE__ */ new Set());
     return out;
   }
   addEntries({ namespace, derive, out, claimed: /* @__PURE__ */ new Map() }, [], tree);
@@ -1554,21 +1613,20 @@ function messagesFromEntries(entries) {
   }
   return out;
 }
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
 async function readDestinationPairs(filePath) {
-  let parsed;
+  let content;
   try {
-    const outcome = await readBounded2(filePath);
-    if (outcome.kind !== "ok") {
+    content = await readFileContent(filePath);
+  } catch (error) {
+    if (isEnoent(error)) {
       return null;
     }
-    parsed = JSON.parse(outcome.content);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return null;
+    throw error;
   }
-  return Object.entries(parsed);
+  return Object.entries(parseArbObject(content));
 }
 async function buildArbWriteTree(entries, filePath) {
   const messages = messagesFromEntries(entries);
@@ -1669,6 +1727,20 @@ function createNextIntlJsonAdapter() {
     validateMessage: icuIsValid
   });
 }
+function assertNoDottedNestedKey(tree) {
+  for (const [key, value] of Object.entries(tree)) {
+    if (typeof value !== "object") {
+      continue;
+    }
+    if (key.includes(".")) {
+      throw new AdapterError(
+        "MIXED_STRUCTURE",
+        "A nested object key contains a literal dot, which is ambiguous with a dotted path."
+      );
+    }
+    assertNoDottedNestedKey(value);
+  }
+}
 function assertNotMixed(tree) {
   let hasNested = false;
   let hasFlatDottedKey = false;
@@ -1685,6 +1757,7 @@ function assertNotMixed(tree) {
       "The file mixes flat dotted keys with nested objects."
     );
   }
+  assertNoDottedNestedKey(tree);
 }
 async function detectStyle(filePath) {
   let parsed;
@@ -2057,6 +2130,24 @@ function selectAdapter(format, registry = createDefaultRegistry()) {
   );
 }
 
+// src/flow/select-locales.ts
+function selectLocales(config, requested) {
+  if (requested === void 0) {
+    return config.targetLocales;
+  }
+  const configured = new Set(config.targetLocales);
+  const unknown = requested.filter((locale) => !configured.has(locale));
+  if (unknown.length > 0) {
+    const label = unknown.length === 1 ? "locale" : "locales";
+    throw new SdkError(
+      "UNKNOWN_LOCALE",
+      `Requested ${label} not in the configured target locales: ${unknown.join(", ")}. Configured targets: ${config.targetLocales.join(", ")}.`
+    );
+  }
+  const wanted = new Set(requested);
+  return config.targetLocales.filter((locale) => wanted.has(locale));
+}
+
 // src/flow/source.ts
 async function readSource(config, cwd, fs, adapter) {
   const sourcePath = localeFilePath(cwd, config.files.pattern, config.sourceLocale);
@@ -2085,13 +2176,6 @@ async function readTarget(cwd, config, adapter, fs, locale) {
   }
   return (await adapter.read(path, locale)).resource;
 }
-function selectedLocales(config, requested) {
-  if (requested === void 0) {
-    return config.targetLocales;
-  }
-  const wanted = new Set(requested);
-  return config.targetLocales.filter((locale) => wanted.has(locale));
-}
 async function diffLocales(input, deps = {}) {
   const config = input.config;
   const cwd = input.cwd ?? process.cwd();
@@ -2100,7 +2184,7 @@ async function diffLocales(input, deps = {}) {
   const source = await readSource(config, cwd, fs, adapter);
   const lock = await readLockFile(lockFilePath(cwd), fs);
   return Promise.all(
-    selectedLocales(config, input.locales).map(async (locale) => {
+    selectLocales(config, input.locales).map(async (locale) => {
       const target = await readTarget(cwd, config, adapter, fs, locale);
       const diff2 = diffResources(source.resource, target, { baseline: baselineFor(lock, locale) });
       return { locale, diff: diff2 };
@@ -2171,6 +2255,7 @@ function failureSummary(locale, error) {
     pruned: [],
     invalidIcuSource: [],
     integrityMismatches: [],
+    providerFailures: [],
     generated: [],
     notices: [],
     error: describeError(error)
@@ -2182,6 +2267,29 @@ function partition(locales) {
   return { succeeded, failed };
 }
 
+// src/flow/batching.ts
+function chunk(items, size) {
+  const chunks = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+var GENERIC_PROVIDER_FAILURE_MESSAGE = "The provider call failed.";
+function classifyProviderFailure(error) {
+  if (error instanceof ProviderError) {
+    return { code: error.code, message: error.message };
+  }
+  return { code: "PROVIDER_CALL_FAILED", message: GENERIC_PROVIDER_FAILURE_MESSAGE };
+}
+function subBatchFailedNotice(count, error) {
+  const { code, message } = classifyProviderFailure(error);
+  return {
+    code: "SUB_BATCH_FAILED",
+    message: `A sub-batch of ${count} entries failed (${code}: ${message}) and was withheld; it will be retried next run.`
+  };
+}
+
 // src/flow/notices.ts
 function isNotice(value) {
   return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.message === "string";
@@ -2364,13 +2472,36 @@ async function generatePluralForms(context) {
   const plan = planPluralGeneration(context.source, context.targetLocale, context.format);
   const stale = staleItems(plan.items, context.baseline);
   if (stale.length === 0) {
-    return { accepted: [], withheld: [] };
+    return { accepted: [], withheld: [], providerFailures: [], notices: [] };
   }
-  const entries = stale.map(syntheticEntry);
-  const result = await context.provider.translateBatch(buildRequest2(context, entries));
   const accepted = [];
   const withheld = [];
-  for (const item of stale) {
+  const providerFailures = [];
+  const notices = [];
+  for (const batch of chunk(stale, context.maxBatchSize)) {
+    const batchNotices = await runGenerationSubBatch(
+      context,
+      batch,
+      accepted,
+      withheld,
+      providerFailures
+    );
+    notices.push(...batchNotices);
+  }
+  return { accepted, withheld, providerFailures, notices };
+}
+async function runGenerationSubBatch(context, batch, accepted, withheld, providerFailures) {
+  let result;
+  try {
+    const entries = batch.map(syntheticEntry);
+    result = await context.provider.translateBatch(buildRequest2(context, entries));
+  } catch (error) {
+    for (const item of batch) {
+      providerFailures.push(item.targetKey);
+    }
+    return [subBatchFailedNotice(batch.length, error)];
+  }
+  for (const item of batch) {
     const value = result.values.get(item.targetKey);
     const integrity = result.integrity.get(item.targetKey);
     if (value !== void 0 && integrity?.matches === true) {
@@ -2383,7 +2514,7 @@ async function generatePluralForms(context) {
       withheld.push(item.targetKey);
     }
   }
-  return { accepted, withheld };
+  return readNotices(result);
 }
 
 // src/flow/locale-run.ts
@@ -2433,6 +2564,7 @@ async function runLocale(params) {
         translated: toTranslate,
         generated: [],
         integrityMismatches: [],
+        providerFailures: [],
         pruned,
         notices: sdkNotices
       }),
@@ -2442,12 +2574,14 @@ async function runLocale(params) {
   const entries = toTranslate.map((key) => params.source.entries.get(key)).filter((entry) => entry !== void 0);
   const accepted = /* @__PURE__ */ new Map();
   const integrityMismatches = [];
+  const providerFailures = [];
   const subBatchNotices = await translateAndCheck(
     provider,
     params,
     entries,
     accepted,
-    integrityMismatches
+    integrityMismatches,
+    providerFailures
   );
   const merged = new Map(target.entries);
   for (const key of pruned) {
@@ -2471,8 +2605,18 @@ async function runLocale(params) {
     path
   );
   const pluralNotices = params.generatePlurals ? pluralNoticeFor(params, merged) : sdkNotices;
-  const notices = [...pluralNotices, ...subBatchNotices];
-  const withheld = /* @__PURE__ */ new Set([...integrityMismatches, ...invalidIcuSource, ...generation.withheld]);
+  const notices = [
+    ...pluralNotices,
+    ...subBatchNotices,
+    ...generation.notices
+  ];
+  const withheld = /* @__PURE__ */ new Set([
+    ...integrityMismatches,
+    ...providerFailures,
+    ...invalidIcuSource,
+    ...generation.withheld,
+    ...generation.providerFailures
+  ]);
   return {
     summary: baseSummary({
       locale: params.targetLocale,
@@ -2483,6 +2627,8 @@ async function runLocale(params) {
       generated: generation.accepted.map((form) => form.targetKey).sort(),
       // Withheld generated forms surface alongside withheld translations: both failed integrity.
       integrityMismatches: [...integrityMismatches, ...generation.withheld].sort(),
+      // A generation sub-batch whose provider call itself threw is a provider failure, never integrity.
+      providerFailures: [...providerFailures, ...generation.providerFailures].sort(),
       pruned,
       notices
     }),
@@ -2491,7 +2637,7 @@ async function runLocale(params) {
 }
 async function runGeneration(params, provider) {
   if (!params.generatePlurals || provider.kind !== "llm") {
-    return { accepted: [], withheld: [] };
+    return { accepted: [], withheld: [], providerFailures: [], notices: [] };
   }
   return generatePluralForms({
     source: params.source,
@@ -2502,7 +2648,8 @@ async function runGeneration(params, provider) {
     provider,
     glossary: params.glossary,
     tone: params.tone,
-    baseline: params.baseline
+    baseline: params.baseline,
+    maxBatchSize: params.maxBatchSize
   });
 }
 function pluralNoticeFor(params, merged) {
@@ -2524,27 +2671,35 @@ function baseSummary(parts) {
     pruned: parts.pruned,
     invalidIcuSource: parts.invalidIcuSource,
     integrityMismatches: parts.integrityMismatches,
+    providerFailures: parts.providerFailures,
     generated: parts.generated,
     notices: parts.notices
   };
 }
-async function translateAndCheck(provider, params, entries, accepted, integrityMismatches) {
+async function translateAndCheck(provider, params, entries, accepted, integrityMismatches, providerFailures) {
   const notices = [];
   for (const batch of chunk(entries, params.maxBatchSize)) {
-    const subNotices = await runSubBatch(provider, params, batch, accepted, integrityMismatches);
+    const subNotices = await runSubBatch(
+      provider,
+      params,
+      batch,
+      accepted,
+      integrityMismatches,
+      providerFailures
+    );
     notices.push(...subNotices);
   }
   return notices;
 }
-async function runSubBatch(provider, params, batch, accepted, integrityMismatches) {
+async function runSubBatch(provider, params, batch, accepted, integrityMismatches, providerFailures) {
   let result;
   try {
     result = await provider.translateBatch(buildRequest3(params, batch));
-  } catch {
+  } catch (error) {
     for (const entry of batch) {
-      integrityMismatches.push(entry.key);
+      providerFailures.push(entry.key);
     }
-    return [subBatchFailedNotice(batch.length)];
+    return [subBatchFailedNotice(batch.length, error)];
   }
   for (const entry of batch) {
     const value = result.values.get(entry.key);
@@ -2557,19 +2712,6 @@ async function runSubBatch(provider, params, batch, accepted, integrityMismatche
   }
   return readNotices(result);
 }
-function subBatchFailedNotice(count) {
-  return {
-    code: "SUB_BATCH_FAILED",
-    message: `A sub-batch of ${count} entries failed and was withheld; it will be retried next run.`
-  };
-}
-function chunk(items, size) {
-  const chunks = [];
-  for (let index = 0; index < items.length; index += size) {
-    chunks.push(items.slice(index, index + size));
-  }
-  return chunks;
-}
 function computeLockEntries(params, merged, withheld, generated) {
   const lockEntries = {};
   const sourceBaseKeys = sourcePluralBaseKeys(params.source);
@@ -2717,6 +2859,7 @@ var COLUMN_WIDTHS = {
   [COLUMN.status]: 12,
   [COLUMN.translation]: 50
 };
+var TEXT_NUMBER_FORMAT = "@";
 function styleHeader(sheet) {
   const header = sheet.getRow(HEADER_ROW);
   HEADERS.forEach((label, index) => {
@@ -2732,6 +2875,7 @@ function applyColumnGeometry(sheet) {
     sheet.getColumn(Number(column)).width = width;
   }
   sheet.getColumn(COLUMN.sourceHash).hidden = true;
+  sheet.getColumn(COLUMN.translation).numFmt = TEXT_NUMBER_FORMAT;
   sheet.views = [{ state: "frozen", ySplit: HEADER_ROW }];
 }
 function writeRow(sheet, sheetRow) {
@@ -2740,7 +2884,9 @@ function writeRow(sheet, sheetRow) {
   row.getCell(COLUMN.source).value = sheetRow.source;
   row.getCell(COLUMN.current).value = sheetRow.currentTarget;
   row.getCell(COLUMN.status).value = sheetRow.status;
-  row.getCell(COLUMN.translation).value = sheetRow.translation === "" ? null : sheetRow.translation;
+  const translationCell = row.getCell(COLUMN.translation);
+  translationCell.numFmt = TEXT_NUMBER_FORMAT;
+  translationCell.value = sheetRow.translation === "" ? null : sheetRow.translation;
   row.getCell(COLUMN.sourceHash).value = sheetRow.sourceHash;
   for (let column = COLUMN.key; column <= COLUMN.sourceHash; column += 1) {
     const cell = row.getCell(column);
@@ -2826,6 +2972,34 @@ function declaredSize(file) {
   const size = data?.uncompressedSize;
   return typeof size === "number" && Number.isFinite(size) ? size : void 0;
 }
+async function streamEntryBounded(file, remaining) {
+  const chunks = [];
+  let raw = 0;
+  let oversize = false;
+  const source = new Readable({ objectMode: true }).wrap(
+    file.nodeStream("nodebuffer")
+  );
+  try {
+    for await (const chunk2 of source) {
+      const buf = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
+      raw += buf.length;
+      if (raw > remaining) {
+        oversize = true;
+        break;
+      }
+      chunks.push(buf);
+    }
+  } catch {
+    throw new ExchangeError("WORKBOOK_INVALID", "A workbook entry could not be decompressed.");
+  }
+  if (oversize) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      "The workbook decompresses to more than the permitted maximum bytes."
+    );
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
 async function guardWorkbookBytes(bytes, limits) {
   let zip;
   try {
@@ -2855,12 +3029,8 @@ async function guardWorkbookBytes(bytes, limits) {
   }
   let actualTotal = 0;
   for (const file of files) {
-    let content;
-    try {
-      content = await file.async("string");
-    } catch {
-      throw new ExchangeError("WORKBOOK_INVALID", "A workbook entry could not be decompressed.");
-    }
+    const remaining = limits.maxDecompressedBytes - actualTotal;
+    const content = await streamEntryBounded(file, remaining);
     actualTotal += Buffer.byteLength(content, "utf8");
     if (actualTotal > limits.maxDecompressedBytes) {
       throw new ExchangeError(
@@ -3010,13 +3180,6 @@ function buildRows(source, target, baseline, includeUnchanged) {
   }
   return [...rows].sort((a, b) => a.key < b.key ? -1 : 1);
 }
-function selectedLocales2(config, requested) {
-  if (requested === void 0) {
-    return config.targetLocales;
-  }
-  const wanted = new Set(requested);
-  return config.targetLocales.filter((locale) => wanted.has(locale));
-}
 async function exportWorkbook(input, deps = {}) {
   const config = input.config;
   const cwd = input.cwd ?? process.cwd();
@@ -3024,7 +3187,7 @@ async function exportWorkbook(input, deps = {}) {
   const adapter = selectAdapter(config.format, deps.adapterRegistry);
   const source = await readSource(config, cwd, fs, adapter);
   const lock = await readLockFile(lockFilePath(cwd), fs);
-  const locales = selectedLocales2(config, input.locales);
+  const locales = selectLocales(config, input.locales);
   const sheets = await Promise.all(
     locales.map(async (locale) => {
       const target = await readTarget3(cwd, config, adapter, fs, locale);
@@ -3075,9 +3238,20 @@ function judge(row, sourceEntry, adapter) {
   }
   return void 0;
 }
+function trackBlankDrift(row, params, buckets) {
+  const sourceEntry = params.source.entries.get(row.key);
+  if (sourceEntry === void 0) {
+    return;
+  }
+  const priorHash = params.baseline.get(row.key);
+  if (priorHash !== void 0 && priorHash !== contentHash(sourceEntry)) {
+    buckets.blankDrifted.add(row.key);
+  }
+}
 function classifyRows(params, buckets) {
   for (const row of params.sheet.rows) {
     if (row.translation === "") {
+      trackBlankDrift(row, params, buckets);
       continue;
     }
     if (isUnknownKey(row, params.source, params.target)) {
@@ -3096,9 +3270,20 @@ function classifyRows(params, buckets) {
     }
   }
 }
+function blankRowBaselineNotice(count) {
+  return {
+    code: "BLANK_ROW_BASELINE_RETAINED",
+    message: `${count} row(s) were left blank for a key whose source changed since the row's baseline was recorded; the prior baseline was kept so the drift keeps being reported.`
+  };
+}
 function importLocale(params) {
   const diff2 = diffResources(params.source, params.target, { baseline: params.baseline });
-  const buckets = { accepted: /* @__PURE__ */ new Map(), mismatches: [], withheld: /* @__PURE__ */ new Set() };
+  const buckets = {
+    accepted: /* @__PURE__ */ new Map(),
+    mismatches: [],
+    withheld: /* @__PURE__ */ new Set(),
+    blankDrifted: /* @__PURE__ */ new Set()
+  };
   classifyRows(params, buckets);
   const rowKeys = new Set(params.sheet.rows.map((row) => row.key));
   const invalidIcuSource = [...new Set(params.sourceInvalidIcuKeys)].filter((key) => rowKeys.has(key)).sort();
@@ -3112,9 +3297,11 @@ function importLocale(params) {
     pruned: [],
     invalidIcuSource,
     integrityMismatches: [...buckets.mismatches].sort(),
+    // A workbook import never calls a provider, so a provider-call failure cannot occur here.
+    providerFailures: [],
     // Plural generation is a translate-flow concern; the manual workbook import never generates forms.
     generated: [],
-    notices: []
+    notices: buckets.blankDrifted.size > 0 ? [blankRowBaselineNotice(buckets.blankDrifted.size)] : []
   };
   return { summary, accepted: buckets.accepted, withheld: buckets.withheld };
 }
@@ -3148,21 +3335,19 @@ function mergeAccepted(target, accepted) {
   }
   return merged;
 }
-function computeLockEntries2(source, merged, baseline, withheld) {
+function computeLockEntries2(source, merged, baseline, accepted) {
   const entries = {};
   for (const key of merged.keys()) {
     const sourceEntry = source.entries.get(key);
     if (sourceEntry === void 0) {
       continue;
     }
-    if (withheld.has(key)) {
-      const prior = baseline.get(key);
-      if (prior !== void 0) {
-        entries[key] = prior;
-      }
+    if (accepted.has(key)) {
+      entries[key] = contentHash(sourceEntry);
       continue;
     }
-    entries[key] = contentHash(sourceEntry);
+    const prior = baseline.get(key);
+    entries[key] = prior !== void 0 ? prior : contentHash(sourceEntry);
   }
   return entries;
 }
@@ -3175,7 +3360,7 @@ async function runSheet(ctx, sheet, lock) {
   }
   const target = await readTarget4(ctx.cwd, ctx.config, ctx.adapter, ctx.fs, sheet.locale);
   const baseline = baselineFor(lock, sheet.locale);
-  const { summary, accepted, withheld } = importLocale({
+  const { summary, accepted } = importLocale({
     sheet,
     source: ctx.source,
     target,
@@ -3199,7 +3384,7 @@ async function runSheet(ctx, sheet, lock) {
       path
     );
   }
-  return { summary, lockEntries: computeLockEntries2(ctx.source, merged, baseline, withheld) };
+  return { summary, lockEntries: computeLockEntries2(ctx.source, merged, baseline, accepted) };
 }
 async function importWorkbook(input, deps = {}) {
   const config = input.config;