@verbatra/sdk 0.6.0 → 0.6.1

package/dist/index.js

@@ -329,77 +329,76 @@ function checkPlaceholders(source, translated) {
     reordered
   };
 }
-var LOCALE_TOKEN = "{locale}";
-function localeFilePath(cwd, pattern, locale) {
-  return resolve(cwd, pattern.replaceAll(LOCALE_TOKEN, locale));
-}
-var RATE_LIMITED_STATUS = 429;
-var TIMEOUT_STATUS = 408;
-var AUTH_FAILED_STATUSES = /* @__PURE__ */ new Set([401, 403]);
-var RATE_LIMITED_CLASS_NAMES = /* @__PURE__ */ new Set([
-  "RateLimitError",
-  "TooManyRequestsError"
-]);
-var AUTH_FAILED_CLASS_NAMES = /* @__PURE__ */ new Set([
-  "AuthenticationError",
-  "PermissionDeniedError",
-  "AuthorizationError"
-]);
-var TIMEOUT_CLASS_NAMES = /* @__PURE__ */ new Set([
-  "APIConnectionTimeoutError",
-  "ConnectionError"
-]);
-var ABORT_ERROR_CLASS_NAMES = /* @__PURE__ */ new Set(["APIUserAbortError"]);
-function getErrorStatus(error) {
-  if (typeof error !== "object" || error === null || !("status" in error)) {
-    return void 0;
+var MIN_SOURCE_LENGTH = 8;
+var MAX_LENGTH_MULTIPLE = 12;
+var MAX_REPEAT_UNIT_LENGTH = 16;
+var MIN_CONSECUTIVE_REPEATS = 8;
+var REPEAT_COVERAGE_FRACTION = 0.5;
+var MAX_SCAN_LENGTH = 8192;
+function matchesUnit(text, a, b, unit) {
+  for (let i = 0; i < unit; i++) {
+    if (text[a + i] !== text[b + i]) {
+      return false;
+    }
   }
-  const status = error.status;
-  return typeof status === "number" ? status : void 0;
+  return true;
 }
-function readClassName(error) {
-  if (typeof error !== "object" || error === null) {
-    return void 0;
+function countConsecutiveCopies(text, start, unit, scanLength) {
+  let copies = 1;
+  let next = start + unit;
+  while (next + unit <= scanLength && matchesUnit(text, start, next, unit)) {
+    copies++;
+    next += unit;
+  }
+  return copies;
+}
+function hasDominantRun(text, scanLength, unit, coverage) {
+  const limit = scanLength - unit;
+  let start = 0;
+  while (start <= limit) {
+    const copies = countConsecutiveCopies(text, start, unit, scanLength);
+    if (copies >= MIN_CONSECUTIVE_REPEATS && copies * unit >= coverage) {
+      return true;
+    }
+    start += copies * unit;
   }
-  return error.constructor?.name;
+  return false;
 }
-function classifyProviderError(error) {
-  const status = getErrorStatus(error);
-  if (status === RATE_LIMITED_STATUS) {
-    return "RATE_LIMITED";
-  }
-  if (status !== void 0 && AUTH_FAILED_STATUSES.has(status)) {
-    return "AUTH_FAILED";
-  }
-  if (status === TIMEOUT_STATUS) {
-    return "TIMEOUT";
-  }
-  const className = readClassName(error);
-  if (className !== void 0) {
-    if (RATE_LIMITED_CLASS_NAMES.has(className)) {
-      return "RATE_LIMITED";
-    }
-    if (AUTH_FAILED_CLASS_NAMES.has(className)) {
-      return "AUTH_FAILED";
-    }
-    if (TIMEOUT_CLASS_NAMES.has(className)) {
-      return "TIMEOUT";
+function hasRunawayRepetition(text) {
+  const scanLength = Math.min(text.length, MAX_SCAN_LENGTH);
+  const coverage = scanLength * REPEAT_COVERAGE_FRACTION;
+  const maxUnit = Math.min(
+    MAX_REPEAT_UNIT_LENGTH,
+    Math.floor(scanLength / MIN_CONSECUTIVE_REPEATS)
+  );
+  for (let unit = 1; unit <= maxUnit; unit++) {
+    if (hasDominantRun(text, scanLength, unit, coverage)) {
+      return true;
     }
   }
-  return "PROVIDER_ERROR";
+  return false;
 }
-function isAbortShapedError(error) {
-  if (error instanceof Error && error.name === "AbortError") {
-    return true;
+function assessValueDegeneracy(sourceValue, candidateValue) {
+  const source = sourceValue.trim();
+  const candidate = candidateValue.trim();
+  if (source.length >= MIN_SOURCE_LENGTH && candidate.length >= source.length * MAX_LENGTH_MULTIPLE) {
+    return { degenerate: true };
   }
-  const className = readClassName(error);
-  return className !== void 0 && ABORT_ERROR_CLASS_NAMES.has(className);
+  return { degenerate: hasRunawayRepetition(candidate) };
 }
-function isAbortError(error, signal) {
-  if (signal !== void 0) {
-    return signal.aborted === true && isAbortShapedError(error);
+var LOCALE_TOKEN = "{locale}";
+function localeFilePath(cwd, pattern, locale) {
+  return resolve(cwd, pattern.replaceAll(LOCALE_TOKEN, locale));
+}
+function checkBatchIntegrity(inputs, extract, compare) {
+  const integrity = /* @__PURE__ */ new Map();
+  for (const { key, sourceValue, translatedValue } of inputs) {
+    integrity.set(
+      key,
+      compare !== void 0 ? compare(sourceValue, translatedValue) : checkPlaceholders(extract(sourceValue), extract(translatedValue))
+    );
   }
-  return isAbortShapedError(error);
+  return integrity;
 }
 var REDACTED = "[REDACTED]";
 var KEY_PATTERNS = [
@@ -437,38 +436,6 @@ var ProviderError = class extends Error {
     this.code = code;
   }
 };
-var PROVIDER_CALL_FAILED_MESSAGE = "The translation provider request failed.";
-var RATE_LIMITED_MESSAGE = "The translation provider rate-limited this request.";
-var TIMEOUT_MESSAGE = "The translation provider request timed out.";
-var AUTH_FAILED_MESSAGE = "The translation provider rejected the request credentials.";
-var MESSAGE_BY_CODE = {
-  RATE_LIMITED: RATE_LIMITED_MESSAGE,
-  TIMEOUT: TIMEOUT_MESSAGE,
-  AUTH_FAILED: AUTH_FAILED_MESSAGE,
-  PROVIDER_ERROR: PROVIDER_CALL_FAILED_MESSAGE
-};
-async function guardProviderCall(call, signal) {
-  signal?.throwIfAborted();
-  try {
-    return await call();
-  } catch (error) {
-    if (isAbortError(error, signal)) {
-      throw error;
-    }
-    const code = classifyProviderError(error);
-    throw new ProviderError(code, MESSAGE_BY_CODE[code]);
-  }
-}
-function checkBatchIntegrity(inputs, extract, compare) {
-  const integrity = /* @__PURE__ */ new Map();
-  for (const { key, sourceValue, translatedValue } of inputs) {
-    integrity.set(
-      key,
-      compare !== void 0 ? compare(sourceValue, translatedValue) : checkPlaceholders(extract(sourceValue), extract(translatedValue))
-    );
-  }
-  return integrity;
-}
 var requestDataSchema = z.object({
   sourceLocale: z.string().min(1),
   targetLocale: z.string().min(1),
@@ -711,6 +678,121 @@ function assertNotTruncated(truncated) {
     throw new ProviderError("OUTPUT_TRUNCATED", OUTPUT_TRUNCATED_MESSAGE);
   }
 }
+var RATE_LIMITED_STATUS = 429;
+var TIMEOUT_STATUS = 408;
+var AUTH_FAILED_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var RATE_LIMITED_CLASS_NAMES = /* @__PURE__ */ new Set([
+  "RateLimitError",
+  "TooManyRequestsError"
+]);
+var AUTH_FAILED_CLASS_NAMES = /* @__PURE__ */ new Set([
+  "AuthenticationError",
+  "PermissionDeniedError",
+  "AuthorizationError"
+]);
+var TIMEOUT_CLASS_NAMES = /* @__PURE__ */ new Set([
+  "APIConnectionTimeoutError",
+  "ConnectionError"
+]);
+var ABORT_ERROR_CLASS_NAMES = /* @__PURE__ */ new Set(["APIUserAbortError"]);
+function getErrorStatus(error) {
+  if (typeof error !== "object" || error === null || !("status" in error)) {
+    return void 0;
+  }
+  const status = error.status;
+  return typeof status === "number" ? status : void 0;
+}
+function readClassName(error) {
+  if (typeof error !== "object" || error === null) {
+    return void 0;
+  }
+  return error.constructor?.name;
+}
+function classifyProviderError(error) {
+  const status = getErrorStatus(error);
+  if (status === RATE_LIMITED_STATUS) {
+    return "RATE_LIMITED";
+  }
+  if (status !== void 0 && AUTH_FAILED_STATUSES.has(status)) {
+    return "AUTH_FAILED";
+  }
+  if (status === TIMEOUT_STATUS) {
+    return "TIMEOUT";
+  }
+  const className = readClassName(error);
+  if (className !== void 0) {
+    if (RATE_LIMITED_CLASS_NAMES.has(className)) {
+      return "RATE_LIMITED";
+    }
+    if (AUTH_FAILED_CLASS_NAMES.has(className)) {
+      return "AUTH_FAILED";
+    }
+    if (TIMEOUT_CLASS_NAMES.has(className)) {
+      return "TIMEOUT";
+    }
+  }
+  return "PROVIDER_ERROR";
+}
+function isAbortShapedError(error) {
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  const className = readClassName(error);
+  return className !== void 0 && ABORT_ERROR_CLASS_NAMES.has(className);
+}
+function isAbortError(error, signal) {
+  if (signal !== void 0) {
+    return signal.aborted === true && isAbortShapedError(error);
+  }
+  return isAbortShapedError(error);
+}
+var PROVIDER_CALL_FAILED_MESSAGE = "The translation provider request failed.";
+var RATE_LIMITED_MESSAGE = "The translation provider rate-limited this request.";
+var TIMEOUT_MESSAGE = "The translation provider request timed out.";
+var AUTH_FAILED_MESSAGE = "The translation provider rejected the request credentials.";
+var MESSAGE_BY_CODE = {
+  RATE_LIMITED: RATE_LIMITED_MESSAGE,
+  TIMEOUT: TIMEOUT_MESSAGE,
+  AUTH_FAILED: AUTH_FAILED_MESSAGE,
+  PROVIDER_ERROR: PROVIDER_CALL_FAILED_MESSAGE
+};
+async function guardProviderCall(call, signal) {
+  signal?.throwIfAborted();
+  try {
+    return await call();
+  } catch (error) {
+    if (isAbortError(error, signal)) {
+      throw error;
+    }
+    const code = classifyProviderError(error);
+    throw new ProviderError(code, MESSAGE_BY_CODE[code]);
+  }
+}
+var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+function requestTimedOutMessage(timeoutMs) {
+  return `The translation provider request exceeded the ${timeoutMs} ms request timeout.`;
+}
+function combineSignals(caller, timeout) {
+  return caller === void 0 ? timeout : AbortSignal.any([caller, timeout]);
+}
+async function withRequestTimeout(timeoutMs, callerSignal, call) {
+  const timeoutController = new AbortController();
+  const signal = combineSignals(callerSignal, timeoutController.signal);
+  let timer;
+  const timedOut = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      timeoutController.abort();
+      reject(new ProviderError("TIMEOUT", requestTimedOutMessage(timeoutMs)));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([guardProviderCall(() => call(signal), signal), timedOut]);
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  }
+}
 var PROVIDER_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
@@ -765,7 +847,13 @@ function createDefaultClient() {
 }
 var anthropicConfigSchema = z.object({
   model: z.string().min(1),
-  maxTokens: z.number().int().positive()
+  maxTokens: z.number().int().positive(),
+  /**
+   * Optional verbatra-imposed per-request timeout in milliseconds. A positive integer; when absent,
+   * the shared default request timeout applies. Bounds each outbound request so a hung-but-alive
+   * server cannot hold a locale's write lock open forever.
+   */
+  requestTimeoutMs: z.number().int().positive().optional()
 });
 var SUBMIT_TOOL_NAME = "submit_translations";
 var SYSTEM_RULES = [
@@ -825,10 +913,11 @@ function createAnthropicProvider(config, deps = {}) {
   };
 }
 function createMechanism(client, config) {
+  const timeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   return {
     translate: async ({ payloadJson, signal }) => {
       const body = buildRequest(config, payloadJson);
-      const message = await callClient(client, body, signal);
+      const message = await callClient(client, body, timeoutMs, signal);
       assertNotTruncated(message.stop_reason === "max_tokens");
       const raw = requireToolInput(message.content);
       const usage = toUsage(message.usage);
@@ -836,10 +925,11 @@ function createMechanism(client, config) {
     }
   };
 }
-function callClient(client, body, signal) {
-  return guardProviderCall(
-    () => client.messages.create(body, signal !== void 0 ? { signal } : void 0),
-    signal
+function callClient(client, body, timeoutMs, signal) {
+  return withRequestTimeout(
+    timeoutMs,
+    signal,
+    (requestSignal) => client.messages.create(body, { signal: requestSignal })
   );
 }
 function toUsage(usage) {
@@ -853,7 +943,14 @@ function toUsage(usage) {
   return { inputTokens: input_tokens, outputTokens: output_tokens };
 }
 var deepLConfigSchema = z.object({
-  glossaryId: z.string().min(1).optional()
+  glossaryId: z.string().min(1).optional(),
+  /**
+   * Optional verbatra-imposed per-request timeout in milliseconds. A positive integer; when absent,
+   * the shared default request timeout applies. Bounds each outbound request so a hung-but-alive
+   * server cannot hold a locale's write lock open forever. deepl-node cannot cancel an in-flight
+   * request, so on timeout verbatra's await is released but the underlying request is left to settle.
+   */
+  requestTimeoutMs: z.number().int().positive().optional()
 });
 var DEEPL_LOGGER = "deepl";
 function resolveDeeplLoglevel(requireFn = createRequire(import.meta.url)) {
@@ -1024,6 +1121,7 @@ async function translate(bundle, config, request) {
     options,
     request.extractPlaceholders,
     request.comparePlaceholders,
+    config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
     request.signal
   );
   if (unprotectable.length > 0) {
@@ -1058,7 +1156,7 @@ function buildReviewFlags2(protectable, data, values, integrity, glossary) {
   }
   return reviewFlags;
 }
-async function translateProtectable(client, data, protectable, options, extract, compare, signal) {
+async function translateProtectable(client, data, protectable, options, extract, compare, timeoutMs, signal) {
   if (protectable.length === 0) {
     return { values: /* @__PURE__ */ new Map(), integrity: /* @__PURE__ */ new Map() };
   }
@@ -1069,29 +1167,45 @@ async function translateProtectable(client, data, protectable, options, extract,
     data.sourceLocale,
     data.targetLocale,
     options,
+    timeoutMs,
     signal
   );
   const { values, integrityInputs } = zipResults(protectable, results);
   const integrity = checkBatchIntegrity(integrityInputs, extract, compare);
   return { values, integrity };
 }
-function callClient2(client, texts, sourceLang, targetLang, options, signal) {
-  return guardProviderCall(
-    () => client.translateText(texts, sourceLang, targetLang, options),
-    signal
+function callClient2(client, texts, sourceLang, targetLang, options, timeoutMs, signal) {
+  return withRequestTimeout(
+    timeoutMs,
+    signal,
+    () => client.translateText(texts, sourceLang, targetLang, options)
   );
 }
-async function callClientChunked(client, texts, sourceLang, targetLang, options, signal) {
+async function callClientChunked(client, texts, sourceLang, targetLang, options, timeoutMs, signal) {
   const results = [];
   for (const chunk2 of chunkTextsForDeepL(texts)) {
-    const chunkResults = await callClient2(client, chunk2, sourceLang, targetLang, options, signal);
+    const chunkResults = await callClient2(
+      client,
+      chunk2,
+      sourceLang,
+      targetLang,
+      options,
+      timeoutMs,
+      signal
+    );
     results.push(...chunkResults);
   }
   return results;
 }
 var geminiConfigSchema = z.object({
   model: z.string().min(1),
-  maxOutputTokens: z.number().int().positive()
+  maxOutputTokens: z.number().int().positive(),
+  /**
+   * Optional verbatra-imposed per-request timeout in milliseconds. A positive integer; when absent,
+   * the shared default request timeout applies. Bounds each outbound request so a hung-but-alive
+   * server cannot hold a locale's write lock open forever.
+   */
+  requestTimeoutMs: z.number().int().positive().optional()
 });
 var DEFAULT_GEMINI_RETRY = { attempts: 3, baseDelayMs: 250 };
 function isRetryableStatus(error) {
@@ -1281,20 +1395,27 @@ function createGeminiProvider(config, deps = {}) {
   };
 }
 function createMechanism2(client, config) {
+  const timeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   return {
     translate: async ({ payloadJson, signal }) => {
-      const request = buildGeminiRequest(config, payloadJson, signal);
-      const response = await callClient3(client, request, signal);
+      const response = await withRequestTimeout(
+        timeoutMs,
+        signal,
+        (requestSignal) => client.models.generateContent(buildGeminiRequest(config, payloadJson, requestSignal))
+      );
       return extractGeminiResult(response);
     }
   };
 }
-function callClient3(client, request, signal) {
-  return guardProviderCall(() => client.models.generateContent(request), signal);
-}
 var openAiConfigSchema = z.object({
   model: z.string().min(1),
-  maxOutputTokens: z.number().int().positive()
+  maxOutputTokens: z.number().int().positive(),
+  /**
+   * Optional verbatra-imposed per-request timeout in milliseconds. A positive integer; when absent,
+   * the shared default request timeout applies. Bounds each outbound request so a hung-but-alive
+   * server cannot hold a locale's write lock open forever.
+   */
+  requestTimeoutMs: z.number().int().positive().optional()
 });
 function createDefaultClient4() {
   const sdk = new OpenAI({ apiKey: requireOpenAiKey(), logLevel: "off" });
@@ -1449,18 +1570,20 @@ function createOpenAiProvider(config, deps = {}) {
   };
 }
 function createMechanism3(client, config) {
+  const timeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   return {
     translate: async ({ payloadJson, signal }) => {
       const body = buildOpenAiRequest(config, payloadJson);
-      const completion = await callClient4(client, body, signal);
+      const completion = await callClient3(client, body, timeoutMs, signal);
       return extractOpenAiResult(completion);
     }
   };
 }
-function callClient4(client, body, signal) {
-  return guardProviderCall(
-    () => client.chat.completions.create(body, signal !== void 0 ? { signal } : void 0),
-    signal
+function callClient3(client, body, timeoutMs, signal) {
+  return withRequestTimeout(
+    timeoutMs,
+    signal,
+    (requestSignal) => client.chat.completions.create(body, { signal: requestSignal })
   );
 }
 var HOSTED_PROVIDER_ENV_VARS = new Set(
@@ -1483,7 +1606,13 @@ var openAiCompatibleConfigSchema = z.object({
   maxOutputTokens: z.number().int().positive(),
   apiKeyEnvVar: z.string().min(1).refine(isNotHostedProviderEnvVar, {
     message: "apiKeyEnvVar must not name a hosted provider's environment variable."
-  }).optional()
+  }).optional(),
+  /**
+   * Optional verbatra-imposed per-request timeout in milliseconds. A positive integer; when absent,
+   * the shared default request timeout applies. Bounds each outbound request so a hung-but-alive local
+   * server (the reported stuck-LM-Studio case) cannot hold a locale's write lock open forever.
+   */
+  requestTimeoutMs: z.number().int().positive().optional()
 });
 function createDefaultClient5(config) {
   const sdk = new OpenAI({
@@ -1515,18 +1644,20 @@ function createOpenAiCompatibleProvider(config, deps = {}) {
   };
 }
 function createMechanism4(client, config) {
+  const timeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   return {
     translate: async ({ payloadJson, signal }) => {
       const body = buildOpenAiRequest(config, payloadJson, "strict-schema", "max_tokens");
-      const completion = await callClient5(client, body, signal);
+      const completion = await callClient4(client, body, timeoutMs, signal);
       return extractOpenAiResult(completion, true);
     }
   };
 }
-function callClient5(client, body, signal) {
-  return guardProviderCall(
-    () => client.chat.completions.create(body, signal !== void 0 ? { signal } : void 0),
-    signal
+function callClient4(client, body, timeoutMs, signal) {
+  return withRequestTimeout(
+    timeoutMs,
+    signal,
+    (requestSignal) => client.chat.completions.create(body, { signal: requestSignal })
   );
 }
 var SCAFFOLD_MODELS = {
@@ -1736,6 +1867,8 @@ var LOCAL_DIR_NAME = ".verbatra-local";
 var LOCK_FILE_GUARD_STEM = "_lockfile";
 var DEFAULT_POLL_INTERVAL_MS = 100;
 var DEFAULT_ACQUIRE_TIMEOUT_MS = 10 * 6e4;
+var WAIT_NOTICE_INTERVAL_MS = 1e3;
+var MAX_LOCK_PAYLOAD_BYTES = 64 * 1024;
 function lockPath(cwd, stem) {
   return resolve(cwd, LOCAL_DIR_NAME, "locks", `${stem}.lock`);
 }
@@ -1753,7 +1886,47 @@ function sleep(ms) {
 function lockPayload() {
   return JSON.stringify({ pid: process.pid, acquiredAt: (/* @__PURE__ */ new Date()).toISOString() });
 }
-async function acquireLock(path, fs, pollIntervalMs, deadline) {
+function parseHolder(read) {
+  if (read.kind !== "ok") {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(read.content);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const holder = {};
+  if (typeof record.pid === "number") {
+    holder.pid = record.pid;
+  }
+  if (typeof record.acquiredAt === "string") {
+    holder.acquiredAt = record.acquiredAt;
+  }
+  return holder;
+}
+function makeWaitNotifier(path, fs, onWait, start) {
+  let holder;
+  let holderRead = false;
+  let lastEmit;
+  return async () => {
+    if (!holderRead) {
+      holderRead = true;
+      holder = parseHolder(await fs.readFileBounded(path, MAX_LOCK_PAYLOAD_BYTES));
+    }
+    const elapsedMs = Date.now() - start;
+    if (lastEmit !== void 0 && elapsedMs - lastEmit < WAIT_NOTICE_INTERVAL_MS) {
+      return;
+    }
+    lastEmit = elapsedMs;
+    onWait({ lockPath: path, elapsedMs, ...holder !== void 0 ? { holder } : {} });
+  };
+}
+async function acquireLock(path, fs, pollIntervalMs, deadline, notify) {
   for (; ; ) {
     if (await fs.createExclusive(path, lockPayload())) {
       return;
@@ -1764,6 +1937,9 @@ async function acquireLock(path, fs, pollIntervalMs, deadline) {
         `Could not acquire the write lock at ${path}: another process may be holding it. If no verbatra process is currently running, this lock file was likely left behind by one that was killed; delete it and retry.`
       );
     }
+    if (notify !== void 0) {
+      await notify();
+    }
     const jitter = Math.random() * pollIntervalMs;
     await sleep(pollIntervalMs + jitter);
   }
@@ -1771,7 +1947,9 @@ async function acquireLock(path, fs, pollIntervalMs, deadline) {
 async function withFileLock(path, fs, fn, options) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const acquireTimeoutMs = options.acquireTimeoutMs ?? DEFAULT_ACQUIRE_TIMEOUT_MS;
-  await acquireLock(path, fs, pollIntervalMs, Date.now() + acquireTimeoutMs);
+  const start = Date.now();
+  const notify = options.onWait !== void 0 ? makeWaitNotifier(path, fs, options.onWait, start) : void 0;
+  await acquireLock(path, fs, pollIntervalMs, start + acquireTimeoutMs, notify);
   try {
     return await fn();
   } finally {
@@ -3456,6 +3634,9 @@ function gateCandidateValue(sourceEntry, candidateValue, adapter) {
   if (!adapter.validateMessage(candidateValue)) {
     return { accepted: false, reason: "icu" };
   }
+  if (assessValueDegeneracy(sourceEntry.value, candidateValue).degenerate) {
+    return { accepted: false, reason: "degenerate" };
+  }
   return { accepted: true };
 }
 
@@ -3743,7 +3924,7 @@ var runBudgetSchema = z.object({
 });
 var runStatusLocaleSchema = z.object({
   locale: z.string(),
-  status: z.enum(["succeeded", "failed"]),
+  status: z.enum(["succeeded", "partial", "failed"]),
   needsReview: z.array(needsReviewEntrySchema),
   usage: usageSummarySchema.optional()
 });
@@ -3888,10 +4069,21 @@ function failureSummary(locale, error) {
     error: describeError(error)
   };
 }
+function deriveLocaleStatus(parts) {
+  const withheld = parts.integrityMismatches.length > 0 || parts.providerFailures.length > 0 || parts.budgetWithheld.length > 0;
+  if (!withheld) {
+    return "succeeded";
+  }
+  const accepted = parts.translated.length > 0 || parts.generated.length > 0;
+  return accepted ? "partial" : "failed";
+}
 function partition(locales) {
-  const succeeded = locales.filter((s) => s.status === "succeeded").map((s) => s.locale);
-  const failed = locales.filter((s) => s.status === "failed").map((s) => s.locale);
-  return { succeeded, failed };
+  const namesWith = (status) => locales.filter((s) => s.status === status).map((s) => s.locale);
+  return {
+    succeeded: namesWith("succeeded"),
+    partial: namesWith("partial"),
+    failed: namesWith("failed")
+  };
 }
 
 // src/flow/batching.ts
@@ -4372,7 +4564,7 @@ function pluralNoticeFor(params, merged) {
 function baseSummary(parts) {
   return {
     locale: parts.locale,
-    status: "succeeded",
+    status: deriveLocaleStatus(parts),
     translated: parts.translated,
     unchanged: parts.unchanged,
     orphaned: parts.orphaned,
@@ -4431,10 +4623,16 @@ async function runSubBatch(provider, params, batch, accepted, integrityMismatche
   try {
     result = await provider.translateBatch(buildRequest3(params, batch));
   } catch (error) {
-    for (const entry of batch) {
-      providerFailures.push(entry.key);
-    }
-    return { notices: [subBatchFailedNotice(batch.length, error)], usage: void 0 };
+    return handleSubBatchFailure(
+      error,
+      provider,
+      params,
+      batch,
+      accepted,
+      integrityMismatches,
+      providerFailures,
+      reviewFlags
+    );
   }
   for (const entry of batch) {
     foldEntryResult(entry, result, params.adapter, accepted, integrityMismatches, providerFailures);
@@ -4446,6 +4644,44 @@ async function runSubBatch(provider, params, batch, accepted, integrityMismatche
   }
   return { notices: readNotices(result), usage: result.usage };
 }
+function isOutputTruncated(error) {
+  return error instanceof ProviderError && error.code === "OUTPUT_TRUNCATED";
+}
+async function handleSubBatchFailure(error, provider, params, batch, accepted, integrityMismatches, providerFailures, reviewFlags) {
+  if (isOutputTruncated(error) && batch.length > 1) {
+    return retryTruncatedSplit(
+      provider,
+      params,
+      batch,
+      accepted,
+      integrityMismatches,
+      providerFailures,
+      reviewFlags
+    );
+  }
+  for (const entry of batch) {
+    providerFailures.push(entry.key);
+  }
+  return { notices: [subBatchFailedNotice(batch.length, error)], usage: void 0 };
+}
+async function retryTruncatedSplit(provider, params, batch, accepted, integrityMismatches, providerFailures, reviewFlags) {
+  const notices = [];
+  let usage;
+  for (const half of chunk(batch, Math.ceil(batch.length / 2))) {
+    const sub = await runSubBatch(
+      provider,
+      params,
+      half,
+      accepted,
+      integrityMismatches,
+      providerFailures,
+      reviewFlags
+    );
+    notices.push(...sub.notices);
+    usage = combineUsage(usage, sub.usage);
+  }
+  return { notices, usage };
+}
 function foldEntryResult(entry, result, adapter, accepted, integrityMismatches, providerFailures) {
   const value = result.values.get(entry.key);
   if (value === void 0) {
@@ -4529,16 +4765,26 @@ async function runDryLocale(context, targetLocale, lock) {
   return (await runLocale(params)).summary;
 }
 async function runLiveLocale(context, targetLocale) {
-  return withLocaleWriteLock(context.cwd, targetLocale, context.fs, async () => {
-    const lock = await readLockFile(lockFilePath(context.cwd), context.fs);
-    const params = buildLocaleRunParams(context, targetLocale, baselineFor(lock, targetLocale));
-    const result = await runLocale(params);
-    await updateLockFileLocale(context.cwd, context.fs, targetLocale, {
-      mode: "replace",
-      entries: result.lockEntries
-    });
-    return result.summary;
-  });
+  const lockOptions = {
+    ...context.onLockWait !== void 0 ? { onWait: context.onLockWait } : {},
+    ...context.lockAcquireTimeoutMs !== void 0 ? { acquireTimeoutMs: context.lockAcquireTimeoutMs } : {}
+  };
+  return withLocaleWriteLock(
+    context.cwd,
+    targetLocale,
+    context.fs,
+    async () => {
+      const lock = await readLockFile(lockFilePath(context.cwd), context.fs);
+      const params = buildLocaleRunParams(context, targetLocale, baselineFor(lock, targetLocale));
+      const result = await runLocale(params);
+      await updateLockFileLocale(context.cwd, context.fs, targetLocale, {
+        mode: "replace",
+        entries: result.lockEntries
+      });
+      return result.summary;
+    },
+    lockOptions
+  );
 }
 async function runOneLocale(targetLocale, run) {
   try {
@@ -4592,10 +4838,12 @@ async function translate2(input, deps = {}) {
     generatePlurals,
     maxBatchSize,
     fs,
-    budget
+    budget,
+    ...input.onLockWait !== void 0 ? { onLockWait: input.onLockWait } : {},
+    ...input.lockAcquireTimeoutMs !== void 0 ? { lockAcquireTimeoutMs: input.lockAcquireTimeoutMs } : {}
   };
   const summaries = dryRun ? await runAllLocalesDry(context, config.targetLocales) : await runAllLocalesLive(context, config.targetLocales);
-  const { succeeded, failed } = partition(summaries);
+  const { succeeded, partial, failed } = partition(summaries);
   const usage = summaries.reduce(
     (total, summary2) => combineUsage(total, summary2.usage),
     void 0
@@ -4605,6 +4853,7 @@ async function translate2(input, deps = {}) {
     dryRun,
     locales: summaries,
     succeeded,
+    partial,
     failed,
     ...usage !== void 0 ? { usage } : {},
     ...budgetSummary !== void 0 ? { budget: budgetSummary } : {}
@@ -5163,15 +5412,23 @@ function importLocale(params) {
   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();
+  const translated = [...buckets.accepted.keys()].sort();
+  const integrityMismatches = [...buckets.mismatches].sort();
   const summary = {
     locale: params.sheet.locale,
-    status: "succeeded",
-    translated: [...buckets.accepted.keys()].sort(),
+    status: deriveLocaleStatus({
+      translated,
+      generated: [],
+      integrityMismatches,
+      providerFailures: [],
+      budgetWithheld: []
+    }),
+    translated,
     unchanged: diff2.unchanged,
     orphaned: diff2.orphaned,
     pruned: [],
     invalidIcuSource,
-    integrityMismatches: [...buckets.mismatches].sort(),
+    integrityMismatches,
     providerFailures: [],
     budgetWithheld: [],
     generated: [],
@@ -5300,8 +5557,8 @@ async function importWorkbook(input, deps = {}) {
       summaries.push(failureSummary(sheet.locale, error));
     }
   }
-  const { succeeded, failed } = partition(summaries);
-  return { dryRun, locales: summaries, succeeded, failed };
+  const { succeeded, partial, failed } = partition(summaries);
+  return { dryRun, locales: summaries, succeeded, partial, failed };
 }
 
 // src/lock/load-lock-file.ts
@@ -5359,7 +5616,12 @@ async function watch(input, deps = {}) {
     );
   }
   const runTranslate = deps.runTranslate ?? defaultRunTranslate(deps);
-  const runInput = { config: input.config, cwd };
+  const runInput = {
+    config: input.config,
+    cwd,
+    ...input.onLockWait !== void 0 ? { onLockWait: input.onLockWait } : {},
+    ...input.lockAcquireTimeoutMs !== void 0 ? { lockAcquireTimeoutMs: input.lockAcquireTimeoutMs } : {}
+  };
   let state = "idle";
   let pending = false;
   let stopped = false;