@verbatra/sdk 0.6.2 → 0.6.3

package/dist/index.d.cts

@@ -972,7 +972,7 @@ interface DiffDeps {
 declare function diff(input: DiffInput, deps?: DiffDeps): Promise<DiffSummary>;
 
 /** Why {@link gateCandidateValue} rejected a candidate value. */
-type IntegrityGateReason = "placeholder" | "icu" | "degenerate";
+type IntegrityGateReason = "placeholder" | "icu" | "degenerate" | "empty";
 
 /** Input for {@link editEntry}: the validated config, exactly one target locale/key pair, and the human-typed replacement value. */
 interface EditEntryInput {
@@ -1348,7 +1348,7 @@ type RetranslateEntryResult = {
 declare function retranslateEntry(input: RetranslateEntryInput, deps?: RetranslateEntryDeps): Promise<RetranslateEntryResult>;
 
 /** A stable code for an SDK-originated notice (not a provider notice). */
-type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "BUDGET_TOKENS_EXCEEDED";
+type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "BUDGET_TOKENS_EXCEEDED" | "CACHE_VERSION_UNRECOGNIZED";
 /** Summed token usage across every provider call in a scope (one locale, or the whole run). */
 interface UsageSummary {
     readonly inputTokens: number;
@@ -1432,7 +1432,27 @@ interface LocaleSummary {
      * {@link LocaleSummary.malformedRows}, and {@link LocaleSummary.duplicateKeys}, deliberately do NOT
      * feed this status: they are surfaced in their own lists (and the CLI) but are not withholdings of
      * an attempted translation, so a locale that dropped a malformed row, collapsed a duplicate key, or
-     * left a `changed` row unfilled while accepting its other rows can still be `"succeeded"`.
+     * left a row unfilled while accepting its other rows can still be `"succeeded"`.
+     *
+     * This is a settled decision, not an omission. Recording the reasoning here so the question stops
+     * recurring:
+     *
+     * 1. Two questions, two commands. `import`'s exit code answers "did the import apply what the
+     *    translator gave me". `check` and `diff` answer "is this project fully translated", and both
+     *    already exit non-zero or report pending in every one of these cases. Folding pending human
+     *    work into the import exit code duplicates an existing gate rather than adding one.
+     * 2. It would break the staged handoff. With `de` and `fr` configured and only `de` filled in,
+     *    failing on unfilled work makes `fr` fail and takes the whole import with it, even though `de`
+     *    imported perfectly. Locale-at-a-time handoff is this feature's most common workflow.
+     * 3. {@link LocaleSummary.malformedRows} structurally cannot signal lost work. The Status column is
+     *    the only reachable rejection in the workbook reader; every other field is an unconstrained
+     *    string or a tolerant parse. So a row is malformed on its Status cell alone, entirely
+     *    independently of whether its Translation cell was filled. An untouched sheet with a mangled
+     *    Status column (spreadsheet autocorrect, a CAT-tool round trip) is all-malformed with zero lost
+     *    work. A bucket that cannot distinguish dropped work from absent work cannot honestly drive a
+     *    failure status.
+     * 4. {@link LocaleSummary.duplicateKeys} never could: the first occurrence wins and the intent is
+     *    honoured.
      */
     readonly status: "succeeded" | "partial" | "failed";
     /**
@@ -1513,11 +1533,16 @@ interface LocaleSummary {
      */
     readonly needsReview: readonly NeedsReviewEntry[];
     /**
-     * Keys the workbook exported as `changed` (needing an updated translation) that the translator left
-     * blank, drifted or not, sorted by key. Pending work made visible: the row is skipped (nothing is
-     * written and the prior lock baseline is kept), but the key is surfaced so an unfinished import is
-     * never silently reported as done. Only a workbook import populates this; the provider path, which
-     * never leaves a candidate key unfilled by a person, always leaves it empty.
+     * Keys the translator left blank that still need a translation, drifted or not, sorted by key.
+     * Pending work made visible: the row is skipped (nothing is written and the prior lock baseline is
+     * kept), but the key is surfaced so an unfinished import is never silently reported as done. Only a
+     * workbook import populates this; the provider path, which never leaves a candidate key unfilled by
+     * a person, always leaves it empty.
+     *
+     * Membership is decided by the import-time diff, not by the `status` the row was exported with: a
+     * never-translated key exports as `new`, and a first handoff is all-new, which is the most common
+     * unfilled case there is. A row exported as `changed` whose key no longer needs work by import time
+     * is correspondingly excluded.
      */
     readonly unfilled: readonly string[];
     /**
@@ -1697,6 +1722,19 @@ interface LocaleFinishedEvent {
     readonly locale: string;
     /** Number of keys accepted (translated) for this locale. In a dry-run, the keys that would be translated. */
     readonly translated: number;
+    /**
+     * Zero-based index of this locale in the run's target-locale order, carrying the same value as the
+     * matching {@link LocaleStartedEvent}. This is a correlation key, so a consumer can pair a finish
+     * with its start without matching on the locale name.
+     *
+     * It is deliberately NOT a progress counter. The worker pool claims indices up front, so this is a
+     * claim ordinal rather than a completion ordinal: under concurrency the locales finish in a
+     * different order, and rendering `localeIndex + 1` of `totalLocales` on a finish produces a
+     * counter that jumps around and never reaches its own total in order. Do not reintroduce one.
+     */
+    readonly localeIndex: number;
+    /** Total number of target locales in this run, mirroring {@link LocaleStartedEvent}. */
+    readonly totalLocales: number;
 }
 /** The run reached the end of its locale loop: how many locales it processed. */
 interface RunFinishedEvent {
@@ -2060,8 +2098,9 @@ interface WatchInput {
     readonly lockAcquireTimeoutMs?: number;
     /**
      * Passed through to every run's {@link TranslateInput.concurrency}: how many locales each cycle may
-     * run at once. Defaults to 1 (strictly serial). The per-cycle tracker is fresh, so a budgeted watch
-     * with concurrency greater than 1 still fails each run with `CONCURRENCY_BUDGET_CONFLICT`.
+     * run at once. Defaults to 1 (strictly serial). Because the per-cycle budget tracker is fresh, a
+     * value greater than 1 cannot be honored alongside a `maxTokens` budget; {@link watch} refuses that
+     * combination at startup rather than letting every cycle fail on it.
      */
     readonly concurrency?: number;
     /**
@@ -2095,9 +2134,23 @@ interface WatchController {
  * `onRun` as a {@link WatchRunResult} and watching continues. Returns a controller whose `stop()`
  * closes the watcher and awaits the in-flight run.
  *
+ * Both startup refusals are ordered deliberately: `concurrency` is resolved first because it is
+ * decidable from the arguments alone, while the missing-source check is an I/O probe of project
+ * state, so argument validation runs before any I/O and before the watcher exists. The concurrency
+ * resolve passes `dryRun: false` unconditionally, which is exact rather than a simplification: there
+ * is no dry-run watch, so the budget conflict always applies to a session.
+ *
+ * Resolving it here rather than leaving it to each cycle is the point, not an optimization: a watch
+ * session is long-lived, so a per-cycle refusal would fail the initial run and every run after it,
+ * indefinitely, while the session stayed alive and looked healthy.
+ *
  * @param input - The config, optional cwd/debounce, and the `onRun` callback that receives each result.
  * @param deps - Optional composition seams (watcher, run, registry, provider builder, file system) for tests.
  * @returns A {@link WatchController}; call `stop()` to close the watcher and await the in-flight run.
+ * @throws {@link SdkError} `CONCURRENCY_INVALID`: at startup only, when `concurrency` is defined but
+ *   not an integer of at least 1.
+ * @throws {@link SdkError} `CONCURRENCY_BUDGET_CONFLICT`: at startup only, when `concurrency` is
+ *   greater than 1 while the config sets a `maxTokens` budget.
  * @throws {@link SdkError} `SOURCE_UNREADABLE`: at startup only, when the source locale file is absent.
  * @example
  * ```ts

package/dist/index.d.ts

@@ -972,7 +972,7 @@ interface DiffDeps {
 declare function diff(input: DiffInput, deps?: DiffDeps): Promise<DiffSummary>;
 
 /** Why {@link gateCandidateValue} rejected a candidate value. */
-type IntegrityGateReason = "placeholder" | "icu" | "degenerate";
+type IntegrityGateReason = "placeholder" | "icu" | "degenerate" | "empty";
 
 /** Input for {@link editEntry}: the validated config, exactly one target locale/key pair, and the human-typed replacement value. */
 interface EditEntryInput {
@@ -1348,7 +1348,7 @@ type RetranslateEntryResult = {
 declare function retranslateEntry(input: RetranslateEntryInput, deps?: RetranslateEntryDeps): Promise<RetranslateEntryResult>;
 
 /** A stable code for an SDK-originated notice (not a provider notice). */
-type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "BUDGET_TOKENS_EXCEEDED";
+type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "BUDGET_TOKENS_EXCEEDED" | "CACHE_VERSION_UNRECOGNIZED";
 /** Summed token usage across every provider call in a scope (one locale, or the whole run). */
 interface UsageSummary {
     readonly inputTokens: number;
@@ -1432,7 +1432,27 @@ interface LocaleSummary {
      * {@link LocaleSummary.malformedRows}, and {@link LocaleSummary.duplicateKeys}, deliberately do NOT
      * feed this status: they are surfaced in their own lists (and the CLI) but are not withholdings of
      * an attempted translation, so a locale that dropped a malformed row, collapsed a duplicate key, or
-     * left a `changed` row unfilled while accepting its other rows can still be `"succeeded"`.
+     * left a row unfilled while accepting its other rows can still be `"succeeded"`.
+     *
+     * This is a settled decision, not an omission. Recording the reasoning here so the question stops
+     * recurring:
+     *
+     * 1. Two questions, two commands. `import`'s exit code answers "did the import apply what the
+     *    translator gave me". `check` and `diff` answer "is this project fully translated", and both
+     *    already exit non-zero or report pending in every one of these cases. Folding pending human
+     *    work into the import exit code duplicates an existing gate rather than adding one.
+     * 2. It would break the staged handoff. With `de` and `fr` configured and only `de` filled in,
+     *    failing on unfilled work makes `fr` fail and takes the whole import with it, even though `de`
+     *    imported perfectly. Locale-at-a-time handoff is this feature's most common workflow.
+     * 3. {@link LocaleSummary.malformedRows} structurally cannot signal lost work. The Status column is
+     *    the only reachable rejection in the workbook reader; every other field is an unconstrained
+     *    string or a tolerant parse. So a row is malformed on its Status cell alone, entirely
+     *    independently of whether its Translation cell was filled. An untouched sheet with a mangled
+     *    Status column (spreadsheet autocorrect, a CAT-tool round trip) is all-malformed with zero lost
+     *    work. A bucket that cannot distinguish dropped work from absent work cannot honestly drive a
+     *    failure status.
+     * 4. {@link LocaleSummary.duplicateKeys} never could: the first occurrence wins and the intent is
+     *    honoured.
      */
     readonly status: "succeeded" | "partial" | "failed";
     /**
@@ -1513,11 +1533,16 @@ interface LocaleSummary {
      */
     readonly needsReview: readonly NeedsReviewEntry[];
     /**
-     * Keys the workbook exported as `changed` (needing an updated translation) that the translator left
-     * blank, drifted or not, sorted by key. Pending work made visible: the row is skipped (nothing is
-     * written and the prior lock baseline is kept), but the key is surfaced so an unfinished import is
-     * never silently reported as done. Only a workbook import populates this; the provider path, which
-     * never leaves a candidate key unfilled by a person, always leaves it empty.
+     * Keys the translator left blank that still need a translation, drifted or not, sorted by key.
+     * Pending work made visible: the row is skipped (nothing is written and the prior lock baseline is
+     * kept), but the key is surfaced so an unfinished import is never silently reported as done. Only a
+     * workbook import populates this; the provider path, which never leaves a candidate key unfilled by
+     * a person, always leaves it empty.
+     *
+     * Membership is decided by the import-time diff, not by the `status` the row was exported with: a
+     * never-translated key exports as `new`, and a first handoff is all-new, which is the most common
+     * unfilled case there is. A row exported as `changed` whose key no longer needs work by import time
+     * is correspondingly excluded.
      */
     readonly unfilled: readonly string[];
     /**
@@ -1697,6 +1722,19 @@ interface LocaleFinishedEvent {
     readonly locale: string;
     /** Number of keys accepted (translated) for this locale. In a dry-run, the keys that would be translated. */
     readonly translated: number;
+    /**
+     * Zero-based index of this locale in the run's target-locale order, carrying the same value as the
+     * matching {@link LocaleStartedEvent}. This is a correlation key, so a consumer can pair a finish
+     * with its start without matching on the locale name.
+     *
+     * It is deliberately NOT a progress counter. The worker pool claims indices up front, so this is a
+     * claim ordinal rather than a completion ordinal: under concurrency the locales finish in a
+     * different order, and rendering `localeIndex + 1` of `totalLocales` on a finish produces a
+     * counter that jumps around and never reaches its own total in order. Do not reintroduce one.
+     */
+    readonly localeIndex: number;
+    /** Total number of target locales in this run, mirroring {@link LocaleStartedEvent}. */
+    readonly totalLocales: number;
 }
 /** The run reached the end of its locale loop: how many locales it processed. */
 interface RunFinishedEvent {
@@ -2060,8 +2098,9 @@ interface WatchInput {
     readonly lockAcquireTimeoutMs?: number;
     /**
      * Passed through to every run's {@link TranslateInput.concurrency}: how many locales each cycle may
-     * run at once. Defaults to 1 (strictly serial). The per-cycle tracker is fresh, so a budgeted watch
-     * with concurrency greater than 1 still fails each run with `CONCURRENCY_BUDGET_CONFLICT`.
+     * run at once. Defaults to 1 (strictly serial). Because the per-cycle budget tracker is fresh, a
+     * value greater than 1 cannot be honored alongside a `maxTokens` budget; {@link watch} refuses that
+     * combination at startup rather than letting every cycle fail on it.
      */
     readonly concurrency?: number;
     /**
@@ -2095,9 +2134,23 @@ interface WatchController {
  * `onRun` as a {@link WatchRunResult} and watching continues. Returns a controller whose `stop()`
  * closes the watcher and awaits the in-flight run.
  *
+ * Both startup refusals are ordered deliberately: `concurrency` is resolved first because it is
+ * decidable from the arguments alone, while the missing-source check is an I/O probe of project
+ * state, so argument validation runs before any I/O and before the watcher exists. The concurrency
+ * resolve passes `dryRun: false` unconditionally, which is exact rather than a simplification: there
+ * is no dry-run watch, so the budget conflict always applies to a session.
+ *
+ * Resolving it here rather than leaving it to each cycle is the point, not an optimization: a watch
+ * session is long-lived, so a per-cycle refusal would fail the initial run and every run after it,
+ * indefinitely, while the session stayed alive and looked healthy.
+ *
  * @param input - The config, optional cwd/debounce, and the `onRun` callback that receives each result.
  * @param deps - Optional composition seams (watcher, run, registry, provider builder, file system) for tests.
  * @returns A {@link WatchController}; call `stop()` to close the watcher and await the in-flight run.
+ * @throws {@link SdkError} `CONCURRENCY_INVALID`: at startup only, when `concurrency` is defined but
+ *   not an integer of at least 1.
+ * @throws {@link SdkError} `CONCURRENCY_BUDGET_CONFLICT`: at startup only, when `concurrency` is
+ *   greater than 1 while the config sets a `maxTokens` budget.
  * @throws {@link SdkError} `SOURCE_UNREADABLE`: at startup only, when the source locale file is absent.
  * @example
  * ```ts

package/dist/index.js

@@ -31,27 +31,31 @@ var translationMemorySchema = z.object({
 function cacheFilePath(cwd) {
   return 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 EMPTY_MEMORY;
+    return UNUSABLE;
   }
   if (read.kind !== "ok") {
-    return EMPTY_MEMORY;
+    return UNUSABLE;
   }
   let parsed;
   try {
     parsed = JSON.parse(read.content);
   } catch {
-    return EMPTY_MEMORY;
+    return UNUSABLE;
   }
   const result = translationMemorySchema.safeParse(parsed);
-  if (!result.success || result.data.version !== CURRENT_VERSION) {
-    return EMPTY_MEMORY;
+  if (!result.success) {
+    return UNUSABLE;
   }
-  return result.data;
+  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];
@@ -103,7 +107,10 @@ async function feedTranslationMemory(cwd, fs, fingerprint, additionsByLocale) {
   }
   try {
     const path = cacheFilePath(cwd);
-    const memory = await readTranslationMemory(path, fs);
+    const { memory, writable } = await readTranslationMemory(path, fs);
+    if (!writable) {
+      return;
+    }
     await writeTranslationMemory(path, applyAdditions(memory, fingerprint, additionsByLocale), fs);
   } catch {
   }
@@ -3309,6 +3316,12 @@ function extractPropertiesPlaceholders(value) {
 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";
 }
@@ -3514,7 +3527,7 @@ async function readStructure(filePath) {
     outcome = await readBounded2(filePath);
   } catch (error) {
     if (isFileNotFound(error)) {
-      return [];
+      return { items: [], terminator: "\n" };
     }
     throw new AdapterError("INVALID_STRUCTURE", "The destination file could not be read.");
   }
@@ -3524,13 +3537,16 @@ async function readStructure(filePath) {
   if (outcome.kind === "too-large") {
     throw new AdapterError("INPUT_TOO_LARGE", "The file exceeds the maximum allowed size.");
   }
-  return parseItems(outcome.content);
+  return {
+    items: parseItems(outcome.content),
+    terminator: detectLineTerminator(outcome.content)
+  };
 }
 async function serializePropertiesEntries(entries, filePath) {
-  const structure = await readStructure(filePath);
+  const { items, terminator } = await readStructure(filePath);
   const emitted = /* @__PURE__ */ new Set();
   const lines = [];
-  for (const item of structure) {
+  for (const item of items) {
     if (item.kind === "raw") {
       lines.push(item.text);
       continue;
@@ -3546,8 +3562,7 @@ async function serializePropertiesEntries(entries, filePath) {
       lines.push(formatEntry(key, entry.value));
     }
   }
-  return lines.length === 0 ? "" : `${lines.join("\n")}
-`;
+  return lines.length === 0 ? "" : `${lines.join(terminator)}${terminator}`;
 }
 function createPropertiesAdapter() {
   return createFlatFileAdapter({
@@ -4100,6 +4115,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 };
 }
 
@@ -4949,6 +4967,10 @@ function fanOutAccepted(params, group, acceptedRepresentative, outcome) {
     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);
@@ -5340,14 +5362,21 @@ async function createRunCacheState(input, config, cwd, dryRun, fs) {
   if (dryRun || input.cache === false) {
     return void 0;
   }
-  return {
-    memory: await readTranslationMemory(cacheFilePath(cwd), fs),
-    fingerprint: computeFingerprint(config),
-    additions: /* @__PURE__ */ new Map()
+  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) {
+  if (cache === void 0 || cache.additions.size === 0 || !cache.writable) {
     return;
   }
   try {
@@ -5434,18 +5463,25 @@ async function runLocaleAt(context, targetLocales, localeIndex, runOne, results)
   context.onProgress?.({
     type: "locale-finished",
     locale: targetLocale,
-    translated: summary.translated.length
+    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 (nextIndex < totalLocales) {
+    while (abort === void 0 && nextIndex < totalLocales) {
       const localeIndex = nextIndex;
       nextIndex += 1;
-      await runLocaleAt(context, targetLocales, localeIndex, runOne, results);
+      try {
+        await runLocaleAt(context, targetLocales, localeIndex, runOne, results);
+      } catch (error) {
+        abort ??= { reason: error };
+      }
     }
   }
   const workerCount = Math.min(concurrency, totalLocales);
@@ -5454,6 +5490,9 @@ async function runLocalesWithProgress(context, targetLocales, runOne, concurrenc
     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) {
@@ -5530,7 +5569,8 @@ async function translate2(input, deps = {}) {
   };
   const summaries = dryRun ? await runAllLocalesDry(context, config.targetLocales, concurrency) : await runAllLocalesLive(context, config.targetLocales, concurrency);
   input.onProgress?.({ type: "run-finished", localesCompleted: summaries.length });
-  const { succeeded, partial, failed } = partition(summaries);
+  const locales = withCacheNotices(summaries, cache);
+  const { succeeded, partial, failed } = partition(locales);
   const usage = summaries.reduce(
     (total, summary2) => combineUsage(total, summary2.usage),
     void 0
@@ -5538,7 +5578,7 @@ async function translate2(input, deps = {}) {
   const budgetSummary = toBudgetSummary(budget);
   const summary = {
     dryRun,
-    locales: summaries,
+    locales,
     succeeded,
     partial,
     failed,
@@ -6110,12 +6150,12 @@ function classifyClear(row, sourceEntry, buckets) {
     buckets.withheld.add(row.key);
     return;
   }
-  buckets.accepted.set(row.key, { value: "", source: sourceEntry });
+  buckets.accepted.set(row.key, { value: "", source: sourceEntry, cleared: true });
 }
-function classifyRows(params, buckets) {
+function classifyRows(params, buckets, liveCandidates) {
   for (const row of params.sheet.rows) {
     if (row.translation === "") {
-      if (row.status === "changed") {
+      if (liveCandidates.has(row.key)) {
         buckets.unfilled.push(row.key);
       }
       trackBlankDrift(row, params, buckets);
@@ -6134,7 +6174,11 @@ function classifyRows(params, buckets) {
     }
     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);
@@ -6156,7 +6200,7 @@ function importLocale(params) {
     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();
@@ -6214,8 +6258,10 @@ function mergeAccepted(target, accepted) {
 }
 function sheetCacheAdditions(accepted) {
   const record = {};
-  for (const [, { value, source }] of accepted) {
-    record[contentHash(source)] = value;
+  for (const [, { value, source, cleared }] of accepted) {
+    if (!cleared) {
+      record[contentHash(source)] = value;
+    }
   }
   return record;
 }
@@ -6401,6 +6447,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(