@verbatra/sdk 0.12.0 → 0.13.1

package/dist/index.d.ts

@@ -1521,6 +1521,16 @@ interface FlatFileAdapterOptions {
  */
 declare function createFlatFileAdapter(options: FlatFileAdapterOptions): FormatAdapter;
 
+/** Which part of a rendered message a segment came from. */
+type IcuSegmentKind = "text" | "argument" | "tag";
+/** One run of a rendered message. `text` is always plain text, never markup to interpret. */
+interface IcuSegment {
+    /** Literal message text, a substituted or formatted argument, or a tag boundary. */
+    readonly kind: IcuSegmentKind;
+    /** The text of this run. */
+    readonly text: string;
+}
+
 /**
  * Derives the per-entry facts a format decides for itself from one key and its string value: the
  * placeholder tokens the value carries, and whether the key is one plural form of a set.
@@ -1646,6 +1656,11 @@ type BoundedFileRead = {
      * a file the process may not open or a directory. Absent when nothing exists at the path.
      */
     readonly unreadable?: boolean;
+    /**
+     * `true` together with `unreadable` when what exists at the path is not a regular file, such
+     * as a directory. Absent when the process was refused access to a file.
+     */
+    readonly notRegularFile?: boolean;
 } | {
     /** The file exists but exceeds the requested byte limit, so nothing was read. */
     readonly kind: "too-large";
@@ -1667,6 +1682,11 @@ type BoundedBytesRead = {
      * a file the process may not open or a directory. Absent when nothing exists at the path.
      */
     readonly unreadable?: boolean;
+    /**
+     * `true` together with `unreadable` when what exists at the path is not a regular file, such
+     * as a directory. Absent when the process was refused access to a file.
+     */
+    readonly notRegularFile?: boolean;
 } | {
     /** The file exists but exceeds the requested byte limit, so nothing was read. */
     readonly kind: "too-large";
@@ -1688,9 +1708,10 @@ interface DirectoryEntry {
  * embedding application can back part of a project with something other than a local disk.
  *
  * The seam carries every file the SDK touches once a config is loaded: the run-status file, the
- * lock-file and the write locks, the translation-memory cache, the config glossary, workbook and TMX
- * I/O, generated declaration and pseudolocale files, the source scan, and the locale files
- * themselves, which the adapters read and write through a port built from this one. Two exceptions
+ * run-history file, the lock-file and the write locks, the translation-memory cache, the config
+ * glossary, workbook and TMX I/O, generated declaration and pseudolocale files, the source scan,
+ * and the locale files themselves, which the adapters read and write through a port built from this
+ * one. Two exceptions
  * remain. {@link loadConfig} finds and loads the config file itself directly from disk; only its
  * glossary goes through the port. And a caller-supplied `deps.adapterRegistry` holds adapters the
  * caller constructed, so their file access is whatever the caller wired into them, and supplying
@@ -2425,7 +2446,7 @@ declare const CACHE_FILE_NAME = "verbatra.cache.json";
  *   lock file's path. Thrown by
  *   {@link editEntry}, {@link retranslateEntry}, {@link approveEntry}, {@link rejectEntry}, and
  *   {@link approveLocale}, which act on one locale, and by {@link updateGlossaryTerm}, which takes the project's glossary
- *   lock. {@link translate} and {@link importWorkbook} do not throw it: they record it on the
+ *   lock, and {@link setKeyLengthLimit}, which takes the project's limits lock. {@link translate} and {@link importWorkbook} do not throw it: they record it on the
  *   contended locale's {@link LocaleSummary} and carry on with the other locales. For
  *   {@link translate}, {@link watch}, and {@link importWorkbook}, `lockAcquireTimeoutMs` bounds
  *   only the locale write lock taken before any provider call or file write, so a locale that fails
@@ -2439,6 +2460,21 @@ declare const CACHE_FILE_NAME = "verbatra.cache.json";
  *   read-only, has been removed, or the disk is out of space, or the project's glossary write lock
  *   could not be created, for instance in a read-only project. The file-system error is the
  *   `cause`. Thrown by {@link updateGlossaryTerm}.
+ * - `LENGTH_LIMIT_INVALID`: {@link setKeyLengthLimit} refused its input: the `maxLength` is not a
+ *   whole number from 1 to `Number.MAX_SAFE_INTEGER` (or `null`), the key is empty or longer than
+ *   1024 characters, the limit is a number and the config's own `maxLength` already sets the key,
+ *   so the limits file cannot override it, or the write would take the file past 10,000 entries or
+ *   1 MiB. Nothing is written.
+ * - `LIMITS_FILE_UNUSABLE`: `verbatra.limits.json` cannot be used: it is not a
+ *   regular file, is over 1 MiB, is not UTF-8 or JSON, has another shape or a newer version, or holds more than 10,000
+ *   entries. A file that cannot be used is never overwritten. Thrown by
+ *   {@link setKeyLengthLimit}. A run that meets such a file does not throw: it returns a
+ *   `LIMITS_FILE_IGNORED` notice.
+ * - `LIMITS_FILE_UNWRITABLE`: the limits file exists but the process may not read it, or it or the
+ *   project's limits write lock could not be written, for instance in a read-only project, or the
+ *   lock could not be released after the limit was saved, which the message says. A write failure
+ *   carries the file-system error as its `cause`; a refused read does not. Thrown by
+ *   {@link setKeyLengthLimit}.
  * - `LOCALE_LAYOUT_INVALID`: the configured `files.pattern` and `files.localeStyle` cannot be
  *   combined, or the style has no valid path spelling for a configured locale. Thrown by
  *   {@link createLocalePathResolver}, and so by every entry point that maps a locale to a path,
@@ -2460,8 +2496,8 @@ declare const CACHE_FILE_NAME = "verbatra.cache.json";
  * - `LOCK_TIMEOUT_INVALID`: the `lockAcquireTimeoutMs` input is not a whole number of
  *   milliseconds of at least 0. Thrown by {@link translate}, {@link importWorkbook},
  *   {@link retranslateEntry}, {@link retranslateEntries}, {@link editEntry}, {@link approveEntry},
- *   {@link rejectEntry}, {@link approveEntries}, {@link rejectEntries}, {@link approveLocale}, and
- *   {@link updateGlossaryTerm} before anything is read or locked, and
+ *   {@link rejectEntry}, {@link approveEntries}, {@link rejectEntries}, {@link approveLocale},
+ *   {@link updateGlossaryTerm}, and {@link setKeyLengthLimit} before anything is read or locked, and
  *   by {@link watch} once at startup, before any watching begins.
  * - `PAGE_CURSOR_INVALID`: the `cursor` passed to {@link localeValuesPage} or
  *   {@link provenanceReportPage} is malformed, longer than {@link PAGE_CURSOR_MAX_LENGTH}, was made
@@ -2469,6 +2505,9 @@ declare const CACHE_FILE_NAME = "verbatra.cache.json";
  *   changed between pages. Call again without a cursor.
  * - `PAGE_LIMIT_INVALID`: the `limit` passed to {@link localeValuesPage} or
  *   {@link provenanceReportPage} is not a whole number from 1 to {@link PAGE_LIMIT_CAP}.
+ * - `FIND_TEXT_INVALID`: the `find` text passed to {@link previewValueReplace} or
+ *   {@link applyValueReplace} is empty or longer than 20,000 characters, or that `find` or the
+ *   `replace` text holds an unpaired surrogate. Thrown before anything is read.
  * - `TARGET_UNWRITABLE`: a target locale file could not be written, because its directory is not
  *   writable, does not exist, is read-only, or is out of space. The message names the target file
  *   relative to `cwd` and the underlying file-system code, never the internal temporary file the
@@ -2565,7 +2604,7 @@ declare const CACHE_FILE_NAME = "verbatra.cache.json";
  * - `LOCALE_FAILED`: never thrown. It is the fallback code recorded on a failed
  *   {@link LocaleSummary} when a per-locale failure carries no code of its own.
  */
-type SdkErrorCode = "CONFIG_NOT_FOUND" | "CONFIG_INVALID" | "UNKNOWN_FORMAT" | "UNKNOWN_LOCALE" | "UNKNOWN_KEY" | "KEY_PROTECTED" | "KEY_PINNED" | "PROVIDER_CONSTRUCTION_FAILED" | "MACHINE_TRANSLATION_DISABLED" | "NETWORK_POLICY_VIOLATION" | "SOURCE_UNREADABLE" | "SOURCE_INVALID" | "LOCK_FILE_INVALID" | "PROVENANCE_FILE_INVALID" | "PROVENANCE_FILE_UNWRITABLE" | "REVIEW_VALUE_CHANGED" | "REVIEW_SOURCE_CHANGED" | "REVIEW_REJECT_UNSUPPORTED" | "REVIEW_RESTORE_FAILED" | "REVIEWER_INVALID" | "LOCK_CONTENDED" | "GLOSSARY_NOT_FILE_BACKED" | "GLOSSARY_UNWRITABLE" | "LOCALE_LAYOUT_INVALID" | "LOCALE_PATH_COLLISION" | "CONCURRENCY_INVALID" | "CONCURRENCY_BUDGET_CONFLICT" | "MAX_TOKENS_INVALID" | "LOCK_TIMEOUT_INVALID" | "PAGE_CURSOR_INVALID" | "PAGE_LIMIT_INVALID" | "TARGET_UNWRITABLE" | "PSEUDO_OUTPUT_CONFLICT" | "SOURCE_UNWRITABLE" | "EXTRACT_NOT_CONFIGURED" | "EXTRACT_FS_UNSUPPORTED" | "TYPES_OUTPUT_CONFLICT" | "TYPES_UNWRITABLE" | "TMX_OUTPUT_CONFLICT" | "TMX_UNWRITABLE" | "MEMORY_UNWRITABLE" | "EXPORT_OUTPUT_CONFLICT" | "EXPORT_UNWRITABLE" | "LOCALE_STATE_NOT_CARRIED_OVER" | "LOCALE_UNSUPPORTED_BY_PROVIDER" | "NOT_A_LOCALE_FILE" | "SENSITIVE_CONTENT_WITHHELD" | "RUN_CANCELLED" | "LOCALE_FAILED";
+type SdkErrorCode = "CONFIG_NOT_FOUND" | "CONFIG_INVALID" | "UNKNOWN_FORMAT" | "UNKNOWN_LOCALE" | "UNKNOWN_KEY" | "KEY_PROTECTED" | "KEY_PINNED" | "PROVIDER_CONSTRUCTION_FAILED" | "MACHINE_TRANSLATION_DISABLED" | "NETWORK_POLICY_VIOLATION" | "SOURCE_UNREADABLE" | "SOURCE_INVALID" | "LOCK_FILE_INVALID" | "PROVENANCE_FILE_INVALID" | "PROVENANCE_FILE_UNWRITABLE" | "REVIEW_VALUE_CHANGED" | "REVIEW_SOURCE_CHANGED" | "REVIEW_REJECT_UNSUPPORTED" | "REVIEW_RESTORE_FAILED" | "REVIEWER_INVALID" | "LOCK_CONTENDED" | "GLOSSARY_NOT_FILE_BACKED" | "GLOSSARY_UNWRITABLE" | "LENGTH_LIMIT_INVALID" | "LIMITS_FILE_UNUSABLE" | "LIMITS_FILE_UNWRITABLE" | "LOCALE_LAYOUT_INVALID" | "LOCALE_PATH_COLLISION" | "CONCURRENCY_INVALID" | "CONCURRENCY_BUDGET_CONFLICT" | "MAX_TOKENS_INVALID" | "LOCK_TIMEOUT_INVALID" | "PAGE_CURSOR_INVALID" | "PAGE_LIMIT_INVALID" | "FIND_TEXT_INVALID" | "TARGET_UNWRITABLE" | "PSEUDO_OUTPUT_CONFLICT" | "SOURCE_UNWRITABLE" | "EXTRACT_NOT_CONFIGURED" | "EXTRACT_FS_UNSUPPORTED" | "TYPES_OUTPUT_CONFLICT" | "TYPES_UNWRITABLE" | "TMX_OUTPUT_CONFLICT" | "TMX_UNWRITABLE" | "MEMORY_UNWRITABLE" | "EXPORT_OUTPUT_CONFLICT" | "EXPORT_UNWRITABLE" | "LOCALE_STATE_NOT_CARRIED_OVER" | "LOCALE_UNSUPPORTED_BY_PROVIDER" | "NOT_A_LOCALE_FILE" | "SENSITIVE_CONTENT_WITHHELD" | "RUN_CANCELLED" | "LOCALE_FAILED";
 /**
  * The single structured error the SDK throws. Every whole-run failure surfaces as an `SdkError`
  * carrying a stable {@link SdkErrorCode}, except the few a flow's `@throws` names otherwise (a
@@ -2585,7 +2624,7 @@ declare class SdkError extends Error {
      * error for a `SOURCE_INVALID` TMX file. Read that file's line, column and unit with
      * `tmxErrorLocation` rather than from the cause directly. Only `SOURCE_INVALID`,
      * `PROVIDER_CONSTRUCTION_FAILED`, `EXPORT_UNWRITABLE`, `GLOSSARY_UNWRITABLE`,
-     * `REVIEW_RESTORE_FAILED`, `SOURCE_UNWRITABLE` and `LOCK_CONTENDED` carry one, and `CONFIG_INVALID` only when the
+     * `LIMITS_FILE_UNWRITABLE`, `REVIEW_RESTORE_FAILED`, `SOURCE_UNWRITABLE` and `LOCK_CONTENDED` carry one, and `CONFIG_INVALID` only when the
      * config file failed to load with a coded error, such as an import that does not resolve. A
      * config parse or schema error and `CONFIG_NOT_FOUND` carry none, because a config parser's error
      * can quote the file's content.
@@ -3522,6 +3561,9 @@ interface RateCard {
     table: Record<string, ModelRate>;
 }
 
+/** Where a key's `maxLength` budget comes from: the config's own `maxLength`, or `verbatra.limits.json`. The config wins per key. */
+type MaxLengthSource = "config" | "limits-file";
+
 /** The locale spellings {@link LocaleStyle} is drawn from, in declaration order. */
 declare const LOCALE_STYLES: readonly ["literal", "posix", "android"];
 /**
@@ -4121,6 +4163,10 @@ type IntegrityGateReason = (typeof INTEGRITY_GATE_REASONS)[number];
  * - `PROVENANCE_FILE_TOO_LARGE`: recording this locale's provenance would have grown the provenance
  *   file past the size verbatra reads back, so the file was left as it was and the values the
  *   locale wrote have no record.
+ * - `LIMITS_FILE_IGNORED`: `verbatra.limits.json` could not be used, so this run held the keys to
+ *   the config's `maxLength` budgets only and flagged no value against a limit the file sets. The
+ *   message names the reason. Nothing is written and the file is left as it is. Reported by
+ *   {@link translate} and {@link watch}, dry runs too.
  * - `LOCALE_STATE_CARRIED_OVER`: the lock file, translation memory, or provenance file held no state
  *   for this locale but held state under exactly one underscore spelling of it, such as `pt_BR` for
  *   `pt-BR`, left behind when the configured code was respelled. {@link translate} and
@@ -4186,7 +4232,7 @@ type IntegrityGateReason = (typeof INTEGRITY_GATE_REASONS)[number];
  * and `FORMALITY_UNSUPPORTED_BY_PROVIDER` are raised before anything is spent, from the same
  * assessment {@link doctor} reports under its `locales` check, and on a dry run too.
  */
-type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "HANDOFF_REVIEWS_RECORDED" | "BUDGET_TOKENS_EXCEEDED" | "CACHE_VERSION_UNRECOGNIZED" | "PROVENANCE_VERSION_UNRECOGNIZED" | "PROVENANCE_FILE_TOO_LARGE" | "LOCALE_STATE_CARRIED_OVER" | "LOCALE_STATE_CARRY_OVER_SKIPPED" | "LOCALE_UNVERIFIED_BY_PROVIDER" | "LOCALE_NOT_WELL_TESTED" | "GLOSSARY_UNSUPPORTED_BY_PROVIDER" | "FORMALITY_UNSUPPORTED_BY_PROVIDER" | "SOURCE_FOREIGN_PLACEHOLDERS" | "SOURCE_VALUE_EMPTY" | "SENSITIVE_CONTENT_SENT" | "SENSITIVE_CONTENT_REDACTED" | "SENSITIVE_CONTENT_WITHHELD" | "RUN_CANCELLED";
+type SdkNoticeCode = "PLURAL_CATEGORIES_INCOMPLETE" | "SUB_BATCH_FAILED" | "BLANK_ROW_BASELINE_RETAINED" | "HANDOFF_REVIEWS_RECORDED" | "BUDGET_TOKENS_EXCEEDED" | "CACHE_VERSION_UNRECOGNIZED" | "PROVENANCE_VERSION_UNRECOGNIZED" | "PROVENANCE_FILE_TOO_LARGE" | "LIMITS_FILE_IGNORED" | "LOCALE_STATE_CARRIED_OVER" | "LOCALE_STATE_CARRY_OVER_SKIPPED" | "LOCALE_UNVERIFIED_BY_PROVIDER" | "LOCALE_NOT_WELL_TESTED" | "GLOSSARY_UNSUPPORTED_BY_PROVIDER" | "FORMALITY_UNSUPPORTED_BY_PROVIDER" | "SOURCE_FOREIGN_PLACEHOLDERS" | "SOURCE_VALUE_EMPTY" | "SENSITIVE_CONTENT_SENT" | "SENSITIVE_CONTENT_REDACTED" | "SENSITIVE_CONTENT_WITHHELD" | "RUN_CANCELLED";
 /**
  * Token usage as reported by the provider. Absent when the provider does not report usage, which is
  * the case for machine-translation APIs such as DeepL that do not bill in tokens.
@@ -4783,6 +4829,260 @@ interface RunSummary {
     readonly cancelled?: true;
 }
 
+declare const RUN_HISTORY_TRIGGERS: readonly ["translate", "retranslate"];
+/**
+ * What produced a {@link RunHistoryRecord}: `translate` for a {@link translate} run (which is also
+ * what {@link watch}, the Studio translate-pending action and the `translation.translatePending`
+ * MCP tool run), `retranslate` for one {@link retranslateEntry} call or one
+ * {@link retranslateEntries} batch.
+ */
+type RunHistoryTrigger = (typeof RUN_HISTORY_TRIGGERS)[number];
+/** Every {@link RunCostBasis}. */
+declare const RUN_COST_BASES: readonly ["usage", "source-characters"];
+/**
+ * Where a run's cost figure comes from: `usage` is the token usage the provider reported, priced at
+ * the rate on file; `source-characters` is an estimate for a machine-translation provider that
+ * reports no usage, the source characters of the keys sent to it, priced at the rate on file.
+ */
+type RunCostBasis = (typeof RUN_COST_BASES)[number];
+declare const RUN_COST_CAVEATS: readonly ["SOURCE_DUPLICATES_NOT_DEDUPLICATED", "TRANSPORT_RETRIES_NOT_COUNTED", "USAGE_PARTIAL"];
+/**
+ * What a cost figure leaves out. `SOURCE_DUPLICATES_NOT_DEDUPLICATED` and
+ * `TRANSPORT_RETRIES_NOT_COUNTED` mark a `source-characters` estimate, with the meaning the same
+ * code has on a run estimate; keys the provider failed on are not counted either, and the locale's
+ * `providerFailures` says how many. `USAGE_PARTIAL` marks a `usage` figure that is a lower bound,
+ * whether or not a rate was found: at least one locale sent keys and reported no tokens, so the
+ * amount, when there is one, and the recorded token count cover only what was reported. A locale that reported usage for some of its sub-batches but not all cannot be told
+ * apart, and shows no mark.
+ */
+type RunCostCaveat = (typeof RUN_COST_CAVEATS)[number];
+/** Every {@link RunHistoryUnavailableReason}. */
+declare const RUN_HISTORY_UNAVAILABLE_REASONS: readonly ["unreadable", "too-large"];
+/**
+ * Why the whole run-history file could not be read, which {@link runHistory} reports instead of an
+ * error: `unreadable` when something exists at the path but the process could not read it as a
+ * regular file, `too-large` when it is over 8 MiB. A missing file is not unavailable, it is an
+ * empty history, and a line that is not valid UTF-8 is one unreadable record, not an unavailable
+ * file.
+ */
+type RunHistoryUnavailableReason = (typeof RUN_HISTORY_UNAVAILABLE_REASONS)[number];
+/**
+ * The zod schema for a {@link RunHistoryResult}, the result of {@link runHistory}. Published as
+ * `run-history-result.json`.
+ */
+declare const runHistoryResultSchema: z.ZodObject<{
+    records: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        at: z.ZodISODateTime;
+        trigger: z.ZodEnum<{
+            translate: "translate";
+            retranslate: "retranslate";
+        }>;
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        entries: z.ZodOptional<z.ZodNumber>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+        }, z.core.$strip>>;
+        cost: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            pricing: z.ZodLiteral<"priced">;
+            basis: z.ZodEnum<{
+                usage: "usage";
+                "source-characters": "source-characters";
+            }>;
+            rateKey: z.ZodString;
+            currency: z.ZodString;
+            asOf: z.ZodISODate;
+            amount: z.ZodNumber;
+            caveats: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                SOURCE_DUPLICATES_NOT_DEDUPLICATED: "SOURCE_DUPLICATES_NOT_DEDUPLICATED";
+                TRANSPORT_RETRIES_NOT_COUNTED: "TRANSPORT_RETRIES_NOT_COUNTED";
+                USAGE_PARTIAL: "USAGE_PARTIAL";
+            }>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            pricing: z.ZodEnum<{
+                "no-rate-on-file": "no-rate-on-file";
+                "rate-unit-mismatch": "rate-unit-mismatch";
+                "no-usage": "no-usage";
+            }>;
+            basis: z.ZodEnum<{
+                usage: "usage";
+                "source-characters": "source-characters";
+            }>;
+            rateKey: z.ZodString;
+            caveats: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                SOURCE_DUPLICATES_NOT_DEDUPLICATED: "SOURCE_DUPLICATES_NOT_DEDUPLICATED";
+                TRANSPORT_RETRIES_NOT_COUNTED: "TRANSPORT_RETRIES_NOT_COUNTED";
+                USAGE_PARTIAL: "USAGE_PARTIAL";
+            }>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            pricing: z.ZodLiteral<"not-billed">;
+            rateKey: z.ZodString;
+            caveats: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                SOURCE_DUPLICATES_NOT_DEDUPLICATED: "SOURCE_DUPLICATES_NOT_DEDUPLICATED";
+                TRANSPORT_RETRIES_NOT_COUNTED: "TRANSPORT_RETRIES_NOT_COUNTED";
+                USAGE_PARTIAL: "USAGE_PARTIAL";
+            }>>>>;
+        }, z.core.$strip>], "pricing">;
+        locales: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            locale: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                succeeded: "succeeded";
+                partial: "partial";
+            }>;
+            translated: z.ZodDefault<z.ZodNumber>;
+            cacheHits: z.ZodDefault<z.ZodNumber>;
+            fuzzyHits: z.ZodDefault<z.ZodNumber>;
+            generated: z.ZodDefault<z.ZodNumber>;
+            pruned: z.ZodDefault<z.ZodNumber>;
+            integrityMismatches: z.ZodDefault<z.ZodNumber>;
+            providerFailures: z.ZodDefault<z.ZodNumber>;
+            usage: z.ZodOptional<z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+            }, z.core.$strip>>;
+            coverage: z.ZodOptional<z.ZodObject<{
+                missing: z.ZodNumber;
+                stale: z.ZodNumber;
+                upToDate: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        localesOmitted: z.ZodOptional<z.ZodNumber>;
+        coverageUnavailable: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>>;
+    total: z.ZodNumber;
+    unreadableRecords: z.ZodNumber;
+    unavailable: z.ZodOptional<z.ZodEnum<{
+        unreadable: "unreadable";
+        "too-large": "too-large";
+    }>>;
+}, z.core.$strip>;
+/**
+ * How far a locale is translated, measured by a {@link check} pass after the run: the same three
+ * counts {@link LocaleCheckSummary} reports.
+ */
+interface RunHistoryCoverage {
+    /** Source keys with a non-blank value and no translation in the locale yet. */
+    readonly missing: number;
+    /** Keys whose source text changed since the locale was last translated. */
+    readonly stale: number;
+    /** Keys whose translation still matches the source recorded in the lock-file. */
+    readonly upToDate: number;
+}
+/** One locale's part of a {@link RunHistoryRecord}: counts only, never a key name or a text. */
+interface RunHistoryLocale {
+    /** The target locale. */
+    readonly locale: string;
+    /** How the locale finished, as in {@link LocaleSummary.status}. */
+    readonly status: "succeeded" | "partial" | "failed";
+    /** Keys that received a new value from the provider. */
+    readonly translated: number;
+    /** Keys served from the translation memory instead of the provider. */
+    readonly cacheHits: number;
+    /** Keys reused from the translation memory for a changed source string. */
+    readonly fuzzyHits: number;
+    /** Plural forms generated for the target language. */
+    readonly generated: number;
+    /** Orphaned keys removed from the locale. */
+    readonly pruned: number;
+    /** Keys whose translation the integrity gate refused. */
+    readonly integrityMismatches: number;
+    /** Keys the provider failed to translate. */
+    readonly providerFailures: number;
+    /** Token usage for this locale, absent when the provider reports none. */
+    readonly usage?: UsageSummary | undefined;
+    /**
+     * Coverage measured after the run. Absent for a locale that was not measured, including every
+     * locale of a record with `coverageUnavailable`.
+     */
+    readonly coverage?: RunHistoryCoverage | undefined;
+}
+/**
+ * What a run cost, frozen when the record was written from the `rates` the config held then.
+ * `pricing` says whether a rate was found; only `priced` carries `currency`, `asOf` and `amount`.
+ * A `source-characters` figure is an estimate, never an invoice: show it as one.
+ */
+type RunHistoryCost = {
+    /** A rate for the provider and model was on file and applied. */
+    readonly pricing: "priced";
+    /** Where the quantity comes from. */
+    readonly basis: RunCostBasis;
+    /** The `provider/model` or bare provider id the rate was looked up under. */
+    readonly rateKey: string;
+    /** The three-letter currency code of the rate card at the time. */
+    readonly currency: string;
+    /** The `asOf` date of the rate card at the time, as `YYYY-MM-DD`. */
+    readonly asOf: string;
+    /** The cost in `currency`. */
+    readonly amount: number;
+    /**
+     * What a `source-characters` figure leaves out, or `USAGE_PARTIAL` when part of the usage
+     * went unreported. Absent for a complete `usage` figure.
+     */
+    readonly caveats?: readonly RunCostCaveat[] | undefined;
+} | {
+    /**
+     * Why no figure exists: no rate on file, a rate in the wrong unit, or keys were sent to a
+     * token-billed provider that reported no usage (`no-usage`). Show it as unknown, never as
+     * free.
+     */
+    readonly pricing: "no-rate-on-file" | "rate-unit-mismatch" | "no-usage";
+    /** Where the quantity would have come from. */
+    readonly basis: RunCostBasis;
+    /** The `provider/model` or bare provider id looked up. */
+    readonly rateKey: string;
+    /**
+     * What a `source-characters` figure leaves out, or `USAGE_PARTIAL` when part of the usage
+     * went unreported. Absent for a complete `usage` figure.
+     */
+    readonly caveats?: readonly RunCostCaveat[] | undefined;
+} | {
+    /** The provider is self-hosted or `none`, so no API bills for the run. */
+    readonly pricing: "not-billed";
+    /** The `provider/model` or bare provider id looked up. */
+    readonly rateKey: string;
+    /**
+     * `USAGE_PARTIAL` when part of the reported token usage is missing, so the recorded token
+     * count is a lower bound. Absent otherwise.
+     */
+    readonly caveats?: readonly RunCostCaveat[] | undefined;
+};
+/**
+ * One finished run in the local run history. It holds counts, usage and cost only: no key name and
+ * no translation text, which is why the history file can sit in `.verbatra-local` and never needs
+ * committing.
+ */
+interface RunHistoryRecord {
+    /** The record format version, `1`. */
+    readonly version: 1;
+    /** When the record was written, an ISO 8601 UTC timestamp. */
+    readonly at: string;
+    /** What produced the run. */
+    readonly trigger: RunHistoryTrigger;
+    /** The configured provider's id. */
+    readonly provider: string;
+    /** The configured model, when the provider has one. */
+    readonly model?: string | undefined;
+    /**
+     * The number of keys a `retranslate` record covers: one for {@link retranslateEntry}, and for
+     * {@link retranslateEntries} the number of entries attempted, that is, whose provider call was
+     * made, whether it answered, was refused by the integrity gate or failed. Absent for `translate`.
+     */
+    readonly entries?: number | undefined;
+    /** Token usage of the whole run, absent when the provider reports none or nothing was sent. */
+    readonly usage?: UsageSummary | undefined;
+    /** What the run cost, frozen at write. */
+    readonly cost: RunHistoryCost;
+    /** The locales the run touched, with their counts. */
+    readonly locales: readonly RunHistoryLocale[];
+    /** How many locales were left out of `locales` to keep the record small. Absent when none. */
+    readonly localesOmitted?: number | undefined;
+    /** `true` when the coverage pass after the run failed, so no locale carries `coverage`. */
+    readonly coverageUnavailable?: true | undefined;
+}
+
 /**
  * Where a finished run stands against its token budget.
  *
@@ -4857,6 +5157,18 @@ interface IncompletePlural {
     readonly missing: readonly PluralCategory[];
 }
 
+/**
+ * Why a result holds values to the config's `maxLength` budgets alone although
+ * `verbatra.limits.json` exists. Returned as `limitsNotice` by every call that reads the limits
+ * file when the file cannot be used; the file is left as it is.
+ */
+interface LimitsFileNotice {
+    /** Always `LIMITS_FILE_IGNORED`. */
+    readonly code: "LIMITS_FILE_IGNORED";
+    /** What is wrong with the file, never a path or a value. */
+    readonly message: string;
+}
+
 /**
  * The two severities of a quality-check finding, lowest last. An `error` is a value the
  * write-time integrity gate would refuse; a `warning` is a review reason a translation run would
@@ -4937,6 +5249,8 @@ interface CheckQaSummary {
      * against such a source, so these keys are skipped in every locale until the source is fixed.
      */
     readonly invalidSourceKeys: readonly string[];
+    /** Present when `verbatra.limits.json` could not be used, so `MAX_LENGTH_EXCEEDED` was judged against the config's budgets alone. */
+    readonly limitsNotice?: LimitsFileNotice;
 }
 
 /** One locale's counts in a {@link CheckSummary}. */
@@ -5151,6 +5465,10 @@ interface CheckDeps {
  * locale and the resolved path. A caller that maps SDK codes should be ready for an unrecognized
  * error from a target file.
  *
+ * With `qa` set, a `verbatra.limits.json` that cannot be used is ignored, so only the config's
+ * `maxLength` budgets apply, and `qa.limitsNotice` in the result says so; {@link doctor} names the
+ * problem.
+ *
  * @param input - The config and the optional locale filter.
  * @param deps - Optional adapter registry and file-system overrides.
  * @returns Per-locale counts and the project-wide in-sync verdict.
@@ -5278,8 +5596,9 @@ interface CheckFileDeps {
 /**
  * Checks one locale file, the fast path for validating a file right after it was edited by hand
  * or by an agent. It reads that file and, for a target locale, the source locale file, and
- * nothing else: no other locale, no lock-file, no provenance file, no source code, and no
- * provider. It writes nothing and needs no API key.
+ * nothing else but the project's `verbatra.limits.json`, which it reads for the `maxLength` budgets:
+ * no other locale, no lock-file, no provenance file, no source code,
+ * and no provider. It writes nothing and needs no API key.
  *
  * The file is resolved against the config's `files.pattern` and `files.localeStyle` to the locale
  * it holds. A file that cannot be parsed is reported as a {@link QaSyntaxFinding}, with the line
@@ -5290,6 +5609,9 @@ interface CheckFileDeps {
  * syntax alone, since there is nothing to hold it against; its keys whose value is not a valid ICU
  * message are listed in `qa.invalidSourceKeys`.
  *
+ * A `verbatra.limits.json` that cannot be used is ignored, so only the config's `maxLength`
+ * budgets apply, and the result's `qa.limitsNotice` says so; {@link doctor} names the problem.
+ *
  * @param input - The config, the file, and the optional severity floor.
  * @param deps - Optional adapter registry and file-system overrides.
  * @returns The file's role, one locale result (one per target locale for a catalogue), and totals.
@@ -5394,6 +5716,10 @@ declare const checkFileSummarySchema: z.ZodObject<{
         errors: z.ZodNumber;
         warnings: z.ZodNumber;
         invalidSourceKeys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        limitsNotice: z.ZodExactOptional<z.ZodObject<{
+            code: z.ZodLiteral<"LIMITS_FILE_IGNORED">;
+            message: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 
@@ -5500,6 +5826,10 @@ declare const checkSummarySchema: z.ZodObject<{
         errors: z.ZodNumber;
         warnings: z.ZodNumber;
         invalidSourceKeys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        limitsNotice: z.ZodExactOptional<z.ZodObject<{
+            code: z.ZodLiteral<"LIMITS_FILE_IGNORED">;
+            message: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     review: z.ZodExactOptional<z.ZodObject<{
         reviewed: z.ZodBoolean;
@@ -5532,7 +5862,10 @@ declare const checkSummarySchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-/** The {@link DataFlowManifest.version} this build writes. A renamed or removed field raises it. */
+/**
+ * The {@link DataFlowManifest.version} this build writes. A renamed or removed field raises it; an
+ * added enum member or optional field does not.
+ */
 declare const DATA_FLOW_MANIFEST_VERSION = 1;
 /** Whether the provider is a prompt-driven LLM, a machine-translation API, or `none`. */
 type DataFlowProviderKind = "llm" | "machine-translation" | "none";
@@ -5673,8 +6006,12 @@ interface DataFlowLocale {
 }
 /** One file or directory verbatra writes on the local disk. */
 interface DataFlowLocalFile {
-    /** Which file: the lock file, the provenance file, the translation memory, or the local state directory. */
-    readonly id: "lock" | "provenance" | "cache" | "local-state";
+    /**
+     * Which file: the lock file, the provenance file, the length limits file, the translation memory,
+     * or the local state directory, which holds the run status, the run history (counts, token usage
+     * and cost per run, no key name and no text) and the write locks.
+     */
+    readonly id: "lock" | "provenance" | "limits" | "cache" | "local-state";
     /** The project-relative path it is written to, with `/` separators. */
     readonly path: string;
     /** Whether it holds source text, or text derived from it. */
@@ -6497,6 +6834,11 @@ interface LocaleCapabilityReport {
  *   left behind after the config respelled it `pt-BR`, says whether the next {@link translate} run
  *   carries it over to the configured spelling, and suggests removing it or respelling the
  *   configured locale otherwise. It is `warn` when it names one or cannot read that state.
+ * - `limits`: informational, never fails. Reads `verbatra.limits.json`, the file of per-key length
+ *   limits that sits beside the lock file. It is `warn` when the file cannot be used (a run ignores
+ *   it and a limit cannot be set until it is fixed), when a limit names a key the source does not
+ *   have, when the config's `maxLength` overrides a limit, or when the source could not be read to
+ *   check the keys. It is `pass` when the file is absent or empty.
  * - `locales`: the configured provider supports the source locale and every target locale, judged
  *   against the language table verbatra ships for a machine-translation provider (see
  *   {@link LocaleSupport}). It fails when a locale is `unsupported`, exactly the case
@@ -6513,7 +6855,7 @@ interface LocaleCapabilityReport {
  *   source locale file could not be read for the counts. It runs only when
  *   {@link DoctorInput.dataFlow} is set.
  */
-type DoctorCheckId = "config" | "format-adapter" | "provider" | "api-key" | "network-policy" | "source-file" | "plural-rules" | "plural-completeness" | "locale-codes" | "locale-state" | "locales" | "untranslated-literals" | "data-flow";
+type DoctorCheckId = "config" | "format-adapter" | "provider" | "api-key" | "network-policy" | "source-file" | "plural-rules" | "plural-completeness" | "locale-codes" | "locale-state" | "limits" | "locales" | "untranslated-literals" | "data-flow";
 /**
  * The verdict on one {@link DoctorCheck}.
  *
@@ -6767,6 +7109,7 @@ declare const doctorResultSchema: z.ZodObject<{
             provider: "provider";
             locales: "locales";
             config: "config";
+            limits: "limits";
             "format-adapter": "format-adapter";
             "api-key": "api-key";
             "network-policy": "network-policy";
@@ -7136,6 +7479,17 @@ type RetranslateEntryResult = {
      * when nothing was flagged. The value is written either way; these are advisory.
      */
     readonly reviewReasons: readonly ReviewReasonCode[];
+    /**
+     * Present when `verbatra.limits.json` could not be used, so `reviewReasons` was judged against
+     * the config's `maxLength` budgets alone.
+     */
+    readonly limitsNotice?: LimitsFileNotice;
+    /**
+     * Tokens the provider reported for this call, absent when it reports none (DeepL, Google
+     * Cloud Translation, LibreTranslate). Present on a refused result too, since the provider was
+     * billed before the integrity gate ran.
+     */
+    readonly usage?: UsageSummary;
 } | {
     /** The value was refused; nothing was written and the previous translation is intact. */
     readonly accepted: false;
@@ -7154,6 +7508,17 @@ type RetranslateEntryResult = {
     readonly details?: readonly string[];
     /** The rejected value, echoed back so a UI can show what was refused. */
     readonly value: string;
+    /**
+     * Present when `verbatra.limits.json` could not be used, so the provider was given the
+     * config's `maxLength` budgets alone.
+     */
+    readonly limitsNotice?: LimitsFileNotice;
+    /**
+     * Tokens the provider reported for this call, absent when it reports none (DeepL, Google
+     * Cloud Translation, LibreTranslate). Present on a refused result too, since the provider was
+     * billed before the integrity gate ran.
+     */
+    readonly usage?: UsageSummary;
 };
 /**
  * Re-runs the configured provider for a single key and saves the result. This is the paid
@@ -7183,6 +7548,10 @@ type RetranslateEntryResult = {
  * adapter codes to its own copy. A caller that maps SDK codes should be ready for an unrecognized
  * error from a target file on either path.
  *
+ * A `verbatra.limits.json` that cannot be used is ignored, so the value is held to the config's
+ * `maxLength` budgets only, and the result's `limitsNotice` says so; {@link doctor} names the
+ * problem.
+ *
  * It spends outside the token budget. `maxTokens` and `budgetBehavior` bound a {@link translate}
  * run, and this is its own single-key path with its own provider, so a configured ceiling neither
  * withholds this call nor counts it. A caller that exposes retranslation to users, as the Studio
@@ -7837,6 +8206,17 @@ declare const extractResultSchema: z.ZodObject<{
     dryRun: z.ZodBoolean;
 }, z.core.$strip>;
 
+/** The kind of value a message argument takes, as far as verbatra can tell from the message. */
+type MessageArgumentType = "string" | "number" | "date" | "unknown" | "date-or-string";
+/** One named argument of a message. */
+interface NamedMessageArgument {
+    /** The argument's name as written in the message. */
+    readonly name: string;
+    /** The value type the argument takes. */
+    readonly type: MessageArgumentType;
+    /** True when some arm of the message omits the argument, so a caller may leave it out. */
+    readonly optional?: boolean;
+}
 /**
  * Why verbatra declined to describe a message's arguments rather than guessing at them.
  *
@@ -7848,6 +8228,31 @@ declare const extractResultSchema: z.ZodObject<{
  *   of 64 or more (such as `%0$s` or `{64}`).
  */
 type UnresolvedArgumentReason = "invalid-message-syntax" | "mixed-argument-styles" | "argument-index-out-of-range";
+/**
+ * The arguments a message takes, by style: `none`, `named` (`{name}`), `positional` (`{0}` or
+ * `%s`), or `unresolved` when verbatra declined to describe them, with the reason.
+ */
+type MessageArguments = {
+    /** The message takes no arguments. */
+    readonly style: "none";
+} | {
+    /** The message takes named arguments, such as `{name}`. */
+    readonly style: "named";
+    /** The arguments, in the order they first appear. */
+    readonly named: readonly NamedMessageArgument[];
+} | {
+    /** The message takes numbered or unnumbered arguments, such as `{0}` or `%s`. */
+    readonly style: "positional";
+    /** The value type of each argument, by zero-based position. */
+    readonly positional: readonly MessageArgumentType[];
+    /** The position from which every later argument is optional. Absent when none are. */
+    readonly optionalFrom?: number;
+} | {
+    /** verbatra declined to describe the arguments. */
+    readonly style: "unresolved";
+    /** Why the arguments could not be described. */
+    readonly reason: UnresolvedArgumentReason;
+};
 
 /**
  * Where {@link generateTypes} writes its declaration when the caller names no path: a `.d.ts` at
@@ -8042,8 +8447,12 @@ interface GitExecFileResult {
 }
 /**
  * An argument-array process runner, never a shell string, mirroring the shape of
- * `util.promisify(child_process.execFile)`. {@link localeHistory} calls it only to run `git log`.
- * Inject your own to sandbox that call or to serve history from somewhere else.
+ * `util.promisify(child_process.execFile)`. {@link localeHistory}, {@link keyHistory},
+ * {@link localeGitStatus} and {@link localeGitDiff} call it only to run `git`. Inject your own to sandbox those calls or to
+ * serve the answers from somewhere else. The default runner passes git a minimal environment with
+ * no inherited `GIT_*` variable. A runner of your own must do the same, and must honour the
+ * timeout and output limits: only the default runner guarantees them. It need not set
+ * `GIT_NO_LAZY_FETCH`, since the arguments already carry `--no-lazy-fetch` on a git that knows it.
  *
  * @param file - The executable to run, resolved on `PATH`.
  * @param args - The arguments, passed as a list so no value is ever interpreted by a shell.
@@ -8058,15 +8467,283 @@ type GitExecFile = (file: string, args: readonly string[], options: {
     /** The most bytes of standard output or error to accept before the process is killed. */
     readonly maxBuffer: number;
 }) => Promise<GitExecFileResult>;
+/** How long each git command run by {@link localeGitStatus} and {@link localeGitDiff} may take, in milliseconds. */
+declare const LOCALE_GIT_TIMEOUT_MS = 10000;
+/** The most output {@link localeGitStatus} and {@link localeGitDiff} accept from one git command, in bytes: 1 MiB. */
+declare const LOCALE_GIT_MAX_OUTPUT_BYTES = 1048576;
+
+/**
+ * Why {@link localeGitStatus} or {@link localeGitDiff} could not read the repository:
+ *
+ * - `git-missing`: no `git` executable was found.
+ * - `not-a-repository`: the project is not inside a git work tree.
+ * - `bare-repository`: the project folder holds a bare repository of its own, which verbatra does
+ *   not open (`safe.bareRepository=explicit`), so a repository planted in a downloaded folder is refused.
+ * - `dubious-ownership`: git refused the repository because another user owns it (`safe.directory`).
+ * - `timeout`: a git command ran longer than {@link LOCALE_GIT_TIMEOUT_MS} and was stopped.
+ * - `output-too-large`: a git command wrote more than {@link LOCALE_GIT_MAX_OUTPUT_BYTES}, or a
+ *   committed locale file is larger than {@link LOCALE_GIT_BLOB_MAX_BYTES}.
+ * - `unsafe-config`: the repository configures more content filters than verbatra switches off, or
+ *   one whose name cannot be passed to git safely, so no command was run against it.
+ * - `git-too-old`: the repository is a partial clone and git is older than 2.45, which cannot be told
+ *   not to fetch missing objects from the remote, so no command was run against it.
+ * - `git-failed`: git failed in a way none of the other reasons names, such as a corrupt index.
+ * - `custom-adapter`: ({@link localeGitDiff} only) the format is a `custom:` adapter, or the call
+ *   was given an adapter registry, so the committed file cannot be read through a private
+ *   in-memory file system.
+ * - `revision-unreadable`: ({@link localeGitDiff} only) the committed locale file is not a regular
+ *   file or could not be parsed.
+ * - `working-file-unreadable`: ({@link localeGitDiff} only) the locale file on disk is a symbolic
+ *   link or sits behind one, or could not be parsed.
+ * - `outside-project`: a configured locale file lies outside the project directory, for example
+ *   with a `files.pattern` that starts with `../`, so the call cannot say what changed in it and
+ *   does not report a partial list as a complete one.
+ */
+type LocaleGitUnavailableReason = (typeof LOCALE_GIT_UNAVAILABLE_REASONS)[number];
+/**
+ * The {@link LocaleGitUnavailableReason}s that name a repository that could not be read: all of
+ * them except the ones only {@link localeGitDiff} and {@link localeGitStatus} give about a locale
+ * file (`custom-adapter`, `revision-unreadable`, `working-file-unreadable` and `outside-project`).
+ */
+type LocaleGitRepositoryUnavailableReason = Exclude<LocaleGitUnavailableReason, "custom-adapter" | "revision-unreadable" | "working-file-unreadable" | "outside-project">;
+/** Every {@link LocaleGitUnavailableReason}, in the order the documentation lists them. */
+declare const LOCALE_GIT_UNAVAILABLE_REASONS: readonly ["git-missing", "not-a-repository", "bare-repository", "dubious-ownership", "timeout", "output-too-large", "unsafe-config", "git-too-old", "git-failed", "custom-adapter", "revision-unreadable", "working-file-unreadable", "outside-project"];
+
+/**
+ * How git sees one watched file against `HEAD` and the index:
+ *
+ * - `modified`: the file changed, including a change of file type, and a file taken out of the index
+ *   that is still on disk (a staged deletion together with an untracked or ignored file).
+ * - `added`: the file is new in the index and not in `HEAD`.
+ * - `deleted`: the file is gone from the working tree or the index.
+ * - `untracked`: git does not track the file yet.
+ * - `conflicted`: the file has unresolved merge conflicts.
+ */
+type LocaleGitFileState = (typeof LOCALE_GIT_FILE_STATES)[number];
+/** Every {@link LocaleGitFileState}, in the order the documentation lists them. */
+declare const LOCALE_GIT_FILE_STATES: readonly ["modified", "added", "deleted", "untracked", "conflicted"];
+/** One changed file in a {@link LocaleGitStatusResult}. */
+interface LocaleGitFile {
+    /** The file's path relative to the project directory, with `/` separators. */
+    readonly path: string;
+    /**
+     * The locales whose data lives in this file: one for a one-file-per-locale format, every
+     * configured locale for a shared catalogue such as `apple-xcstrings`, none for
+     * `verbatra.lock.json` and `verbatra.provenance.json`.
+     */
+    readonly locales: readonly string[];
+    /** How git sees the file. */
+    readonly state: LocaleGitFileState;
+}
+/**
+ * The result of {@link localeGitStatus}: `available: false` with a reason when the repository could
+ * not be read, otherwise the branch and the changed files.
+ */
+type LocaleGitStatusResult = {
+    /** `false`: the repository could not be read. */
+    readonly available: false;
+    /** Why the repository could not be read. */
+    readonly reason: LocaleGitUnavailableReason;
+} | {
+    /** `true`: the repository was read. */
+    readonly available: true;
+    /** The checked-out branch, also on a branch with no commits yet. `null` on a detached `HEAD`. */
+    readonly branch: string | null;
+    /** The watched files that differ from `HEAD`, in config order; clean files are not listed. */
+    readonly files: readonly LocaleGitFile[];
+};
+/** Input for {@link localeGitStatus}. */
+interface LocaleGitStatusInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** Directory the `files.pattern` is resolved against and git runs in. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory; pass `cwd` from {@link resolveProjectRoot} for a copied config. */
+    readonly cwd?: string;
+}
+/** Injectable dependencies for {@link localeGitStatus}. Every field has a working default. */
+interface LocaleGitStatusDeps {
+    /** Runs `git`. Defaults to a real `child_process.execFile`. */
+    readonly execFile?: GitExecFile;
+}
+/**
+ * Lists which locale files, `verbatra.lock.json` and `verbatra.provenance.json` differ from the
+ * last commit, each with its state, and names the checked-out branch. It writes nothing, calls no
+ * provider and takes no path from the caller: the watched files come from the config.
+ *
+ * The default runner starts git as an argument list, never through a shell, with a minimal
+ * environment (`PATH`, `HOME` and the Windows system variables, no `GIT_*` variable and no
+ * `XDG_CONFIG_HOME`, so the global git configuration is read from `HOME` alone) and with optional
+ * locks, `core.fsmonitor`, bare-repository discovery, submodule inspection, lazy fetching from a
+ * partial clone's remote and every content filter the repository configures switched off. Lazy
+ * fetching is switched off with `--no-lazy-fetch`, which needs git 2.45 or newer: on an older git a
+ * partial clone is refused with `git-too-old`. Paths are matched literally and follow a `--`
+ * separator, so a path that starts with a dash is not read as an option; a path beyond the project
+ * directory is never passed. Every command is killed after {@link LOCALE_GIT_TIMEOUT_MS} and may
+ * write at most {@link LOCALE_GIT_MAX_OUTPUT_BYTES}. A runner you inject through `execFile` gets
+ * the same arguments but must supply the environment and the limits itself. The tests cover the routes a repository's own configuration
+ * could use to make git run a command: filter drivers, `core.fsmonitor`, aliases, pagers, hook
+ * paths, text conversion drivers, a promisor remote's command and a bare repository planted in the
+ * folder. That is not a promise that opening a project is safe: a `verbatra.config.ts` is code
+ * verbatra runs. The branch name is stripped of control and bidirectional formatting characters.
+ * Renames are reported as a deleted and an added file. A file taken out of the index that is still on
+ * disk is `modified`. A file behind a symbolic link or inside a submodule is never listed, and the
+ * call does not say so. The `apple-strings` format also watches each locale's `.stringsdict` file,
+ * listed with the same locales as its `.strings` file.
+ *
+ * @param input - The config and the project directory.
+ * @param deps - Optional process runner override.
+ * @returns The branch and the changed files, or `available: false` with a
+ * {@link LocaleGitUnavailableReason} when git is missing, the project is not in a work tree, git
+ * refused the repository's ownership, the repository configures a filter verbatra cannot switch off,
+ * or a command timed out, wrote too much or failed.
+ *
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a configured locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ *
+ * @example
+ * ```ts
+ * import { loadConfig, localeGitStatus } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const status = await localeGitStatus({ config });
+ * if (status.available) {
+ *   for (const file of status.files) {
+ *     console.log(file.state, file.path);
+ *   }
+ * }
+ * ```
+ */
+declare function localeGitStatus(input: LocaleGitStatusInput, deps?: LocaleGitStatusDeps): Promise<LocaleGitStatusResult>;
+
+/** How git sees the file: a {@link LocaleGitFileState}, or `unchanged` when it matches `HEAD`. */
+type LocaleGitDiffState = LocaleGitFileState | "unchanged";
+/** A key present on only one side of a {@link localeGitDiff}, with its text. */
+interface LocaleGitDiffEntry {
+    /** The key. */
+    readonly key: string;
+    /** The key's text, cut to {@link LOCALE_GIT_DIFF_MAX_VALUE_CHARS} characters. */
+    readonly value: string;
+}
+/** A key present on both sides of a {@link localeGitDiff} whose text differs. */
+interface LocaleGitDiffChange {
+    /** The key. */
+    readonly key: string;
+    /** The text at `HEAD`, cut to {@link LOCALE_GIT_DIFF_MAX_VALUE_CHARS} characters. */
+    readonly before: string;
+    /** The text in the working tree, cut to {@link LOCALE_GIT_DIFF_MAX_VALUE_CHARS} characters. */
+    readonly after: string;
+}
+/**
+ * The result of {@link localeGitDiff}: `available: false` with a reason when the comparison could
+ * not be made, otherwise the key-level difference between `HEAD` and the working tree.
+ */
+type LocaleGitDiffResult = {
+    /** `false`: the comparison could not be made. */
+    readonly available: false;
+    /** Why the comparison could not be made. */
+    readonly reason: LocaleGitUnavailableReason;
+} | {
+    /** `true`: the comparison was made. */
+    readonly available: true;
+    /** The locale's file path relative to the project directory, with `/` separators. */
+    readonly path: string;
+    /** How git sees the file. A `conflicted` file carries no difference, and neither does an `unchanged` one. */
+    readonly state: LocaleGitDiffState;
+    /** Keys in the working tree and not at `HEAD`, in working-tree order. */
+    readonly added: readonly LocaleGitDiffEntry[];
+    /** Keys at `HEAD` and not in the working tree, in `HEAD` order. */
+    readonly removed: readonly LocaleGitDiffEntry[];
+    /** Keys on both sides with different text, in working-tree order. */
+    readonly changed: readonly LocaleGitDiffChange[];
+    /** `true` when more than {@link LOCALE_GIT_DIFF_MAX_ENTRIES} keys differ or a text was cut, so the lists are incomplete. */
+    readonly truncated: boolean;
+};
+/** Input for {@link localeGitDiff}. */
+interface LocaleGitDiffInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** The source locale or a configured target locale to compare. */
+    readonly locale: string;
+    /** Directory the `files.pattern` is resolved against and git runs in. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory; pass `cwd` from {@link resolveProjectRoot} for a copied config. */
+    readonly cwd?: string;
+}
+/**
+ * Injectable dependencies for {@link localeGitDiff}. Passing an `adapterRegistry` makes the call
+ * return `custom-adapter`: the committed file is parsed by the built-in adapters over a private
+ * in-memory file system, which a registry of your own cannot be given.
+ */
+interface LocaleGitDiffDeps {
+    /** Runs `git`. Defaults to a real `child_process.execFile`. */
+    readonly execFile?: GitExecFile;
+    /** Present only to be refused: any value makes the result `custom-adapter`. */
+    readonly adapterRegistry?: AdapterRegistry;
+}
+/** The most differing keys {@link localeGitDiff} lists in total; the rest set `truncated`. */
+declare const LOCALE_GIT_DIFF_MAX_ENTRIES = 500;
+/** The longest text {@link localeGitDiff} returns for one value, in characters; a longer one is cut and sets `truncated`. */
+declare const LOCALE_GIT_DIFF_MAX_VALUE_CHARS = 2000;
+/**
+ * Compares one locale's file at `HEAD` with the file on disk, key by key: the keys added, the keys
+ * removed, and the keys whose text changed, each with its text. It writes nothing, calls no
+ * provider and takes no path from the caller: the file comes from the config and the locale.
+ *
+ * The committed file is read with `git cat-file blob`, checked to be a regular file no larger than
+ * {@link LOCALE_GIT_BLOB_MAX_BYTES} first, and parsed by the built-in adapter for the configured
+ * format over an in-memory file system. Both sides are compared as parsed keys, never as text, and
+ * git never runs a diff, a text conversion driver or an external diff. The command safeguards of
+ * {@link localeGitStatus} apply, including the minimal environment and the refusal to fetch lazily:
+ * a committed file missing from a partial clone reads as `revision-unreadable`. What is compared
+ * follows what is there: a file absent at `HEAD` compares against nothing, and a file absent on disk
+ * compares to nothing, whatever git's status code says. A `conflicted` or `unchanged` file is not
+ * compared and lists no difference. The file on disk is read only when it is a regular file and the
+ * real path of its directory is the project directory's real path plus the path written in the
+ * config, so no parent directory is a symbolic link; the comparison is exact apart from Unicode
+ * normalization and never ignores case, and a directory that cannot be inspected is refused rather
+ * than read as empty. For `apple-strings` the
+ * `.stringsdict` file is read with the `.strings` file on both sides, and the state reported is the
+ * `.strings` file's, else the `.stringsdict` file's. At most {@link LOCALE_GIT_DIFF_MAX_ENTRIES}
+ * keys are listed, and each key and text is cut to {@link LOCALE_GIT_DIFF_MAX_VALUE_CHARS}
+ * characters, either of which sets `truncated`, so the result stays bounded. The keys and texts are
+ * the file's own and untrusted: show them as text.
+ *
+ * A locale whose file is shared with others, as in `apple-xcstrings`, is compared for that locale
+ * alone. A `custom:` format, or a call that passes an `adapterRegistry`, returns `custom-adapter`
+ * because a custom adapter cannot be run against a private in-memory file system.
+ *
+ * @param input - The config, the locale and the project directory.
+ * @param deps - Optional process runner override, and an adapter registry that is refused.
+ * @returns The difference, or `available: false` with a {@link LocaleGitUnavailableReason}.
+ *
+ * @throws {@link SdkError} `UNKNOWN_LOCALE`: the locale is neither the source nor a configured
+ * target locale.
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a configured locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ *
+ * @example
+ * ```ts
+ * import { loadConfig, localeGitDiff } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const diff = await localeGitDiff({ config, locale: "de" });
+ * if (diff.available) {
+ *   for (const change of diff.changed) {
+ *     console.log(change.key, change.before, "->", change.after);
+ *   }
+ * }
+ * ```
+ */
+declare function localeGitDiff(input: LocaleGitDiffInput, deps?: LocaleGitDiffDeps): Promise<LocaleGitDiffResult>;
+
 /** One commit that touched a locale file, as {@link localeHistory} lists it. */
 interface LocaleHistoryCommit {
     /** The full commit hash. */
     readonly hash: string;
-    /** The author's name as git records it, after `.mailmap`. Never the email address. */
+    /** The author's name as git records it, after `.mailmap`, with anything shaped like an API key replaced by `[REDACTED]`, cut to 200 characters. Never the email address. */
     readonly author: string;
     /** The author date in strict ISO 8601. */
     readonly authorDate: string;
-    /** The first line of the commit message. */
+    /** The first line of the commit message, with anything shaped like an API key replaced by `[REDACTED]`, cut to 500 characters. */
     readonly subject: string;
     /** The watched locale files the commit touched, relative to the repository root. */
     readonly touchedPaths: readonly string[];
@@ -8076,12 +8753,17 @@ interface LocaleHistoryCommit {
  *
  * - `git-missing`: no `git` executable was found.
  * - `not-a-repository`: the project is not inside a git repository.
+ * - `bare-repository`: the project folder holds a bare repository of its own, which is not opened.
+ * - `dubious-ownership`: git refused the repository because another user owns it.
  * - `timeout`: `git log` ran longer than {@link LOCALE_HISTORY_TIMEOUT_MS} and was stopped.
  * - `output-too-large`: `git log` wrote more than {@link LOCALE_HISTORY_MAX_OUTPUT_BYTES}.
+ * - `unsafe-config`: the repository configures more content filters than can be switched off, or
+ *   one whose name cannot be passed to git safely.
+ * - `git-too-old`: the repository is a partial clone and git is older than 2.45.
  */
 type LocaleHistoryUnavailableReason = (typeof LOCALE_HISTORY_UNAVAILABLE_REASONS)[number];
 /** Every {@link LocaleHistoryUnavailableReason}, in the order the documentation lists them. */
-declare const LOCALE_HISTORY_UNAVAILABLE_REASONS: readonly ["git-missing", "not-a-repository", "timeout", "output-too-large"];
+declare const LOCALE_HISTORY_UNAVAILABLE_REASONS: readonly ["git-missing", "not-a-repository", "bare-repository", "dubious-ownership", "timeout", "output-too-large", "unsafe-config", "git-too-old"];
 /**
  * The result of {@link localeHistory}: `available: false` with a reason when the history could not
  * be read, otherwise the commits, newest first.
@@ -8096,6 +8778,8 @@ type LocaleHistoryResult = {
     readonly available: true;
     /** The commits that touched the locale files, newest first. */
     readonly commits: readonly LocaleHistoryCommit[];
+    /** `true` when more than 256 distinct keys, one key longer than 4096 characters, or keys adding up to more than 65,536 UTF-16 code units turned up in author names and subjects, so every non-empty `subject` and `author` was replaced by `[REDACTED]` (empty text stays empty). Absent otherwise. */
+    readonly truncated?: true;
 };
 /** How long {@link localeHistory} lets `git log` run before stopping it, in milliseconds. */
 declare const LOCALE_HISTORY_TIMEOUT_MS = 10000;
@@ -8106,6 +8790,97 @@ declare const LOCALE_HISTORY_LIMIT_DEFAULT = 50;
 /** The most commits {@link localeHistory} lists, whatever `limit` asks for. */
 declare const LOCALE_HISTORY_LIMIT_CAP = 200;
 
+/** The largest committed locale file {@link localeGitDiff} reads, in bytes: 8 MiB. */
+declare const LOCALE_GIT_BLOB_MAX_BYTES = 8388608;
+
+/** Which argument a preview row varies, or `none` for a message with nothing to vary. */
+type IcuPreviewAxis = "plural" | "ordinal" | "select" | "none";
+/**
+ * Why a message could not be previewed.
+ *
+ * - `too-long`: the message is over 20,000 characters.
+ * - `too-complex`: the message nests deeper than 16 braces or has more than 256 `{` and `<` characters.
+ * - `invalid-message`: the message does not parse as ICU.
+ * - `unsupported-locale`: this runtime's CLDR data does not know the locale, or it is malformed.
+ * - `too-large`: the first row alone would render more than 100,000 characters or 5,000 segments.
+ */
+type IcuPreviewFailure = "too-long" | "too-complex" | "invalid-message" | "unsupported-locale" | "too-large";
+/** One rendering of a message with one argument varied. Arguments that enclose it are held at the arm that contains it; `category` repeats when the same arm appears in several places. */
+interface IcuPreviewRow {
+    /** What the row varies: a cardinal plural, an ordinal plural, a select, or `none`. */
+    readonly axis: IcuPreviewAxis;
+    /** The argument the row varies, or `null` when the message has none to vary. */
+    readonly argument: string | null;
+    /** The plural category, an exact arm such as `=0`, or the select option the row shows; for a row showing a value you supplied, the arm that value selects. `null` when the message has nothing to vary. */
+    readonly category: string | null;
+    /** The value the varied argument took in this row. `null` when the message has nothing to vary. */
+    readonly sample: string | number | null;
+    /** True for the row that shows a value you supplied in `args` for this argument rather than one of its arms. */
+    readonly supplied: boolean;
+    /** The enclosing arguments this row holds at the arm that contains the varied argument, by name. Empty when the varied argument is not nested. */
+    readonly held: Readonly<Record<string, string | number>>;
+    /** The rendered message. Plain text runs only: never markup to interpret. */
+    readonly segments: readonly IcuSegment[];
+}
+/** Input for {@link previewIcuMessage}. */
+interface IcuPreviewInput {
+    /** The resolved project config. Only its `format` is read. */
+    readonly config: VerbatraConfig;
+    /** The locale the message is rendered for. A locale this runtime's CLDR data does not know is refused as `unsupported-locale`. */
+    readonly locale: string;
+    /** The message text. Untrusted: a value over 20,000 characters, nested deeper than 16 braces, or with more than 256 `{` and `<` characters is refused rather than parsed. */
+    readonly value: string;
+    /** Sample values for the message's arguments, by name. Numbers drive plural and number arguments, and a number given for a date argument is read as milliseconds since the epoch. Names the message does not use are ignored. A value for a plural, ordinal or select argument adds one row showing it for each axis it drives, at the first place it reaches an arm of that argument (a place that agrees with your other values comes first), and in the ordinary rows is replaced by the arm each row shows. A number text such as `"5"` reads as the number, as the runtime does. */
+    readonly args?: Readonly<Record<string, string | number>>;
+}
+/**
+ * What {@link previewIcuMessage} found.
+ *
+ * - `supported: false`: the configured format does not use ICU message syntax, so there is nothing
+ *   to preview.
+ * - `valid: false`: the message was refused, with the reason.
+ * - `valid: true`: the message's arguments and its renderings.
+ */
+type IcuPreviewResult = {
+    readonly supported: false;
+    readonly reason: "not-icu";
+} | {
+    readonly supported: true;
+    readonly valid: false;
+    readonly reason: IcuPreviewFailure;
+} | {
+    readonly supported: true;
+    readonly valid: true;
+    /** The message's arguments with the types verbatra infers for them. */
+    readonly arguments: MessageArguments;
+    /** One row per plural category, exact arm, or select option, varying one argument at a time. At most 24. */
+    readonly rows: readonly IcuPreviewRow[];
+    /** True when a reachable arm has no row because the preview needed more than 24 rows or ran out of its shared 100,000-character or 5,000-segment output budget. Arms no input can reach do not set it. */
+    readonly truncated: boolean;
+};
+/**
+ * Renders an ICU message for a locale, one row per arm: each plural category, exact arm and select
+ * option, and each place one of them appears.
+ *
+ * Previews only the formats whose messages use ICU syntax, `next-intl-json` and `arb`; any other
+ * format, including a `custom:` one, answers `supported: false`. The message is untrusted text and
+ * the call never throws on it: an over-long, over-nested, malformed or otherwise unusable message,
+ * or an unknown locale, comes back as `valid: false` with a reason. Numbers and dates are formatted
+ * with this runtime's Node CLDR data, dates at a fixed instant in UTC unless a number in `args` sets the instant, so the text can differ from
+ * what an application's own runtime prints. Nothing is read from or written to disk.
+ *
+ * Each row varies one argument and holds the others at `args` or a default. A row for an argument
+ * nested inside another argument's arm also holds that enclosing argument at the arm, so the row
+ * shows the arm it names; the `args` value for an argument a row varies or holds this way is
+ * replaced in that row, and a value you give for a plural, ordinal or select argument adds one row of its own for each axis that argument drives, a plural, an ordinal or a select, placed after that axis's rows and marked `supplied`; its `category` is the arm the value selects at the first place it reaches one, and a value that reaches no arm of an axis adds no row for it. Text that is not a number selects `other` in a plural, where `#` stays `#`. `held` lists the enclosing arguments a row holds, so nested rows can be told apart. The supplied rows count toward the 24 rows and the output budget. An arm that appears in several places gets a row for each place, and rows with
+ * the same label and the same text collapse into one. The rows share one output budget; when it runs
+ * out, or more than 24 rows exist, the rest are left out and `truncated` is set.
+ *
+ * @param input - The config, locale, message and optional sample values.
+ * @returns The preview, or why there is nothing to preview.
+ */
+declare function previewIcuMessage(input: IcuPreviewInput): IcuPreviewResult;
+
 /** Input for {@link keyValue}. */
 interface KeyValueInput {
     /** The resolved project config, normally from {@link loadConfig}. */
@@ -8207,8 +8982,12 @@ interface KeyContextGlossaryNotice {
 interface KeyContext extends KeyValueResult {
     /** The glossary terms whose source occurs in the source text, as that locale is held to them. */
     readonly glossary: LocaleGlossary;
-    /** The key's configured `maxLength` budget in characters, absent when the config sets none. */
+    /** The key's `maxLength` budget in characters, from the config or from `verbatra.limits.json`, absent when neither sets one. */
     readonly maxLength?: number;
+    /** Where `maxLength` comes from: the config wins over the limits file. Present exactly when `maxLength` is. */
+    readonly maxLengthSource?: MaxLengthSource;
+    /** Present when `verbatra.limits.json` could not be used, so `maxLength` is the config's alone. Its code is `LIMITS_FILE_IGNORED`. */
+    readonly limitsNotice?: LimitsFileNotice;
     /** How the input's `draft` uses the applying terms, absent when no draft was given. */
     readonly draftCheck?: GlossaryDraftCheck;
     /** Present when the glossary could not be read; the glossary part is then empty. */
@@ -8217,7 +8996,7 @@ interface KeyContext extends KeyValueResult {
 /**
  * Reads what a translator needs to write one key in one target locale: the key's current source
  * and target text with provenance and description (as {@link keyValue} reports them), the glossary
- * terms that apply to the source text, the key's `maxLength` budget, and, when a draft is given,
+ * terms that apply to the source text, the key's `maxLength` budget (from the config, else from `verbatra.limits.json`), and, when a draft is given,
  * how that draft uses the applying terms. It writes nothing and calls no provider.
  *
  * Glossary values pass through secret redaction before they are matched. A glossary that cannot be
@@ -8256,6 +9035,210 @@ interface KeyContext extends KeyValueResult {
  */
 declare function keyContext(input: KeyContextInput, deps?: KeyContextDeps): Promise<KeyContext>;
 
+/** How a {@link KeyHistorySegment} relates the older text to the newer one. */
+type KeyHistorySegmentKind = "equal" | "added" | "removed";
+/** One run of text in a word-level difference between two values. */
+interface KeyHistorySegment {
+    /** `equal` text is in both values, `removed` only in the older one, `added` only in the newer one. */
+    readonly kind: KeyHistorySegmentKind;
+    /** The text of the run. It is the value's own text and untrusted: show it as text, never as markup. */
+    readonly text: string;
+}
+
+/** The longest value {@link keyHistory} returns, in characters. A longer one is counted in `unreadableRevisions` instead. */
+declare const KEY_HISTORY_MAX_VALUE_CHARS = 4096;
+/** The longest key {@link keyHistory} accepts, in characters. */
+declare const KEY_HISTORY_MAX_KEY_CHARS = 1024;
+/** How long after its start {@link keyHistory} still begins a new read, in milliseconds. A read already running is not cut short. */
+declare const KEY_HISTORY_DEADLINE_MS = 30000;
+/**
+ * Why a {@link keyHistory} answer may be incomplete, in the order they are listed:
+ * `commit-limit` (older commits exist than the limit examines), `shallow-clone`,
+ * `unreadable-revision` (a commit's file could not be read or parsed, held a value that is too
+ * long, or had a log line that did not parse), `file-too-large` (a commit's file was above the
+ * size cap for its format), `byte-budget` (the files read in one call reached their total size
+ * budget), `deadline` (the time ran out), `source-unreadable` (the source file could not be read in
+ * full), `records-unreadable` (a lock-file or provenance file could not be read in full) and
+ * `scrub-cap` (more than 256 distinct keys, one key longer than 4096 characters, or keys adding up to more than 65,536 UTF-16 code units turned up: the answer then replaces every non-empty value, diff segment, subject and author name with `[REDACTED]`, leaves empty text empty, and sets `valueRedacted` on every revision).
+ */
+declare const KEY_HISTORY_TRUNCATION_REASONS: readonly ["commit-limit", "shallow-clone", "unreadable-revision", "file-too-large", "byte-budget", "deadline", "source-unreadable", "records-unreadable", "scrub-cap"];
+/** One member of {@link KEY_HISTORY_TRUNCATION_REASONS}. */
+type KeyHistoryTruncation = (typeof KEY_HISTORY_TRUNCATION_REASONS)[number];
+/**
+ * One commit in which a key's value changed, as {@link keyHistory} lists it.
+ */
+interface KeyRevision {
+    /** The full commit hash. */
+    readonly commit: string;
+    /** The author date in strict ISO 8601. */
+    readonly authorDate: string;
+    /** The author's name after `.mailmap`, never the email address, scrubbed with {@link redact} before it is cut to 200 characters. */
+    readonly author: string;
+    /** The first line of the commit message, scrubbed with {@link redact} before it is cut to 500 characters. */
+    readonly subject: string;
+    /** The key's value in that commit. Untrusted: show it as text. Anything shaped like an API key is replaced by `[REDACTED]`, and so is any other text equal to a key that {@link redact} replaced in a value, subject or author name elsewhere in the same answer. */
+    readonly value: string;
+    /**
+     * Which write path produced the value, read from `verbatra.provenance.json` as committed with it:
+     * a stored origin, `unrecorded` when that file holds no record for the key, or `external` when
+     * its record describes a different value. Absent when that file could not be read or parsed, is
+     * above 4 MiB, lay past the 128 MiB a call reads of lock and provenance files, or when the time
+     * ran out before it was.
+     */
+    readonly origin?: KeyOrigin;
+    /**
+     * Whether the content hash of the key's current source entry (text, description, meaning,
+     * plural flag and placeholders) differs from the hash the lock-file recorded for the key in that
+     * commit. `unknown` when the lock-file, its entry for the key or the current source entry is not
+     * available, or when the lock-file was above its size limit, did not parse or the time ran out
+     * before it was read. Unlike `origin`, which compares the value with the provenance record and
+     * is absent when that file cannot be used, this never depends on the value. Restoring a revision
+     * whose source entry changed makes it count as up to date.
+     */
+    readonly sourceChanged: boolean | "unknown";
+    /**
+     * `true` when {@link redact} changed the value, which then holds `[REDACTED]` where a key
+     * was. Such a value is not the stored text: do not offer it for restore.
+     */
+    readonly valueRedacted?: true;
+    /** The word-level difference from the previous value of the key, both sides scrubbed with {@link redact}; the whole value when the key first appears. */
+    readonly diff: readonly KeyHistorySegment[];
+}
+/** A value in the working tree that is not committed yet. */
+interface KeyWorkingTreeValue {
+    /** The key's value on disk. Untrusted: show it as text. */
+    readonly value: string;
+    /** `true` when {@link redact} changed the value: it is not the stored text, so do not offer it for restore. */
+    readonly valueRedacted?: true;
+    /** The word-level difference from the value at `HEAD`, both sides scrubbed with {@link redact}; the whole value when `HEAD` has none. */
+    readonly diff: readonly KeyHistorySegment[];
+}
+/**
+ * The result of {@link keyHistory}: `available: false` with a reason when the history could not be
+ * read, otherwise the revisions, newest first.
+ */
+type KeyHistoryResult = {
+    /** `false`: the history could not be read. */
+    readonly available: false;
+    /** Why the history could not be read. */
+    readonly reason: LocaleGitUnavailableReason;
+} | {
+    /** `true`: the history was read. */
+    readonly available: true;
+    /** The commits in which the key's value changed, newest first. */
+    readonly revisions: readonly KeyRevision[];
+    /** The value on disk, present only when it differs from the value at `HEAD`. */
+    readonly workingTree?: KeyWorkingTreeValue;
+    /** `true` when the value on disk could not be compared with `HEAD`, so `workingTree` is absent: the file on disk does not parse, is a symbolic link or is above its size limit, its value is longer than {@link KEY_HISTORY_MAX_VALUE_CHARS}, the copy at `HEAD` could not be read (it is above its size limit, does not parse or was not reached), or the time ran out. */
+    readonly workingTreeUnreadable?: true;
+    /** `true` when the answer may leave history out or leave a field unknown because something was not read in full: older commits were not examined (the commit limit, the size budget of the call or the time), the clone is shallow, more than 256 distinct keys, one key longer than 4096 characters, or keys adding up to more than 65,536 UTF-16 code units turned up, so every non-empty value, diff segment, subject and author name was replaced by `[REDACTED]`, a commit could not be read or parsed, was above its size limit or held a value that is too long, or a lock-file, provenance file or the source file could not be read, parsed or was above its size limit. `false` means every commit and record examined was read; the file on disk is reported only by `workingTreeUnreadable`. */
+    readonly truncated: boolean;
+    /** Why `truncated` is `true`: every member of {@link KEY_HISTORY_TRUNCATION_REASONS} that applies, in that order. Empty exactly when `truncated` is `false`. */
+    readonly truncatedBy: readonly KeyHistoryTruncation[];
+    /** How many examined commits held the locale file in a state that could not be read or whose value was too long. */
+    readonly unreadableRevisions: number;
+};
+/** Input for {@link keyHistory}. */
+interface KeyHistoryInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** Directory the `files.pattern` is resolved against and git runs in. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory; pass `cwd` from {@link resolveProjectRoot} for a copied config. */
+    readonly cwd?: string;
+    /** A configured target locale. */
+    readonly locale: string;
+    /** The key, at most {@link KEY_HISTORY_MAX_KEY_CHARS} characters. It is compared with parsed keys and never passed to git. */
+    readonly key: string;
+    /**
+     * The most commits to examine. Rounded down and clamped to between 1 and
+     * {@link LOCALE_HISTORY_LIMIT_CAP}; defaults to {@link LOCALE_HISTORY_LIMIT_DEFAULT}.
+     */
+    readonly limit?: number;
+}
+/** Injectable dependencies for {@link keyHistory}. Every field has a working default. */
+interface KeyHistoryDeps {
+    /** Runs `git`. Defaults to a real `child_process.execFile`. */
+    readonly execFile?: GitExecFile;
+}
+/**
+ * Lists the git commits in which one key's value changed in one target locale, newest first, each
+ * with its author, date, subject, the value, where the value came from and a word-level
+ * difference from the key's previous value. When the value on disk differs from the one at `HEAD`
+ * it is returned as `workingTree`. It writes nothing and calls no provider.
+ *
+ * The locale file's commits come from `git log --first-parent` on that file alone (and its
+ * `.stringsdict` file for `apple-strings`), so a change brought in by a merge appears on the merge
+ * commit. Each commit's file is read with `git cat-file blob` over the safeguards of
+ * {@link localeGitDiff}, parsed by the built-in adapter over an in-memory file system, and a
+ * commit is listed only when the key's value differs from the value in the commit right before it
+ * in the file's history, which must have been read. A commit that removes the key is not listed.
+ * A value is compared exactly, so a change of whitespace alone is a revision. `origin` comes
+ * from the provenance file and `sourceChanged` from the lock-file as committed with the
+ * revision. At most {@link LOCALE_HISTORY_LIMIT_CAP} commits are examined,
+ * {@link LOCALE_HISTORY_LIMIT_DEFAULT} by default, four files are read at a time, and after
+ * {@link KEY_HISTORY_DEADLINE_MS} no further commit is examined and no commit file read starts (the file on disk is still read); the
+ * `git log` call, a size listing and a read already running keep their own 10 second limit. A revision whose records were not read has no `origin` and `sourceChanged`
+ * `"unknown"`.
+ *
+ * `truncated` is `true` whenever anything the call examined was skipped, unreadable, above a size
+ * limit, past a budget or stopped by the deadline: older commits exist that were not examined, the
+ * repository is a shallow clone, a commit could not be read or parsed, held a value that is too
+ * long or had a log line that did not parse, the lock file, the provenance file or the source file
+ * could not be read, parsed or was above its size limit, or the deadline passed. A commit is
+ * listed as a change only when the commit before it was read, so a commit whose older neighbour
+ * could not be read is not claimed as the key's change; `truncated` says so.
+ *
+ * What is read is bounded by sizes git reports before anything is parsed, so the same repository
+ * gets the same byte-limit and budget decisions on every machine; a git call that times out, the
+ * deadline and the provider keys in the environment (which decide what {@link redact} changes)
+ * can still change an answer. A locale file above 512 KiB for `yaml` and the XML
+ * formats (`xliff`, `android-xml`, `resx`, `apple-strings`) or above 4 MiB for the other formats
+ * is skipped without being parsed, and the two files of an `apple-strings` commit count as their
+ * sum. In one call the locale files read add up to at most 16 MiB for those formats and 128 MiB
+ * for the others: past that, older commits are not examined. A lock file or provenance file above
+ * 4 MiB is not read, and together they add up to at most 128 MiB per call: past that, older
+ * revisions have no `origin` and `sourceChanged` is `"unknown"`. The source file follows the cap
+ * of the locale files, and `sourceChanged` is `"unknown"` when it is above it. A commit skipped
+ * for its size, or that cannot be read or parsed, counts in `unreadableRevisions`; a commit past
+ * the budget is not examined and does not. Parsing yields to the event loop between files. The
+ * file on disk follows the same cap; when it cannot be compared with `HEAD` the answer still lists
+ * the revisions, has no `workingTree` and sets `workingTreeUnreadable`. That also happens when
+ * `HEAD`'s own copy could not be read or the time ran out.
+ *
+ * Every value and both sides of every difference pass {@link redact}: a value that changes is
+ * returned with `[REDACTED]` for the key and flagged `valueRedacted`, and must not be offered
+ * for restore.
+ *
+ * Limits: renames are not followed, so history before a locale file was renamed is not listed;
+ * edits that were never committed, other than the one on disk, are not seen; a key renamed in
+ * the source looks like a new key. A file shared by locales, as in `apple-xcstrings`, is read for
+ * the requested locale only. A `custom:` format answers `custom-adapter`. Author names and
+ * subjects lose control and bidirectional formatting characters.
+ *
+ * @param input - The config, the locale, the key, the project directory and the commit limit.
+ * @param deps - Optional process runner override.
+ * @returns The revisions, or `available: false` with a {@link LocaleGitUnavailableReason}.
+ *
+ * @throws {@link SdkError} `UNKNOWN_LOCALE`: the locale is not a configured target locale.
+ * @throws {@link SdkError} `UNKNOWN_KEY`: the key is empty or longer than {@link KEY_HISTORY_MAX_KEY_CHARS}.
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a configured locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ *
+ * @example
+ * ```ts
+ * import { keyHistory, loadConfig } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const history = await keyHistory({ config, locale: "de", key: "cart.title" });
+ * if (history.available) {
+ *   for (const revision of history.revisions) {
+ *     console.log(revision.authorDate, revision.author, revision.value);
+ *   }
+ * }
+ * ```
+ */
+declare function keyHistory(input: KeyHistoryInput, deps?: KeyHistoryDeps): Promise<KeyHistoryResult>;
+
 /**
  * One key's placeholder, ICU, ICU-arm, and inline-markup verdict in a {@link LocaleKeyIntegrity}
  * report.
@@ -8404,16 +9387,21 @@ interface LocaleHistoryDeps {
  * bidirectional formatting characters are removed from the author and the subject, and a commit
  * whose metadata does not parse as a full hash, an ISO date, an author and a subject is left out.
  * Renames are not followed, so history from before a locale file was renamed is not listed. Every
- * locale path is resolved inside `cwd` and passed after a `--` separator, and a path that would
- * leave `cwd` or start with a dash is dropped, so a config value is never read as a git option.
- * `git log` runs with commit signature display off and terminal prompts disabled, is stopped after
- * {@link LOCALE_HISTORY_TIMEOUT_MS}, and may write at most {@link LOCALE_HISTORY_MAX_OUTPUT_BYTES}.
+ * locale path is resolved inside `cwd`, a path that would leave `cwd` is dropped, and the rest follow
+ * a `--` separator, so a config value is never read as a git option. `git log` runs with the same
+ * safeguards as {@link localeGitStatus}: a minimal environment with no inherited `GIT_*` variable,
+ * no bare-repository discovery, no lazy fetching from a partial clone's remote, `core.fsmonitor` and
+ * every configured content filter off. Commit signature display is off and terminal prompts are
+ * disabled; the command is killed after {@link LOCALE_HISTORY_TIMEOUT_MS} and may write at most
+ * {@link LOCALE_HISTORY_MAX_OUTPUT_BYTES}.
  *
  * @param input - The config, the project directory, and the optional commit limit.
  * @param deps - Optional process runner override.
  * @returns The commits, or `available: false` with a {@link LocaleHistoryUnavailableReason} when
- * git is missing, `cwd` is not inside a git repository, or `git log` timed out or wrote too much.
- * Any other git failure, such as a branch with no commits yet, reads as an empty history.
+ * git is missing, `cwd` is not inside a git repository or holds a bare one, git refused the
+ * repository's ownership, the repository configures a content filter that cannot be switched off,
+ * a partial clone needs a newer git, or `git log` timed out or wrote too much. Any other git
+ * failure, such as a branch with no commits yet, reads as an empty history.
  *
  * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
  * cannot be combined, or a configured locale has no valid path spelling under that style.
@@ -8744,6 +9732,76 @@ interface LocaleValuesPageInput extends LocaleValuesInput {
  */
 declare function localeValuesPage(input: LocaleValuesPageInput, deps?: LocaleValuesDeps): Promise<LocaleValuesPage>;
 
+/** The files that hold one locale's data. */
+interface LocaleWatchFiles {
+    /** The locale. */
+    readonly locale: string;
+    /** The absolute path of the locale's file, then the files next to it that hold part of its data, such as the `.stringsdict` file of `apple-strings`. */
+    readonly paths: readonly string[];
+}
+/**
+ * The files git rewrites when the checked-out commit changes: `available: false` with a reason when
+ * the project is not in a readable work tree, otherwise their absolute paths.
+ */
+type LocaleWatchGitPaths = {
+    /** `false`: the repository could not be read. */
+    readonly available: false;
+    /** Why the repository could not be read. */
+    readonly reason: LocaleGitRepositoryUnavailableReason;
+} | {
+    /** `true`: the repository was read. */
+    readonly available: true;
+    /** Absolute paths of this work tree's index, `HEAD` and `HEAD` reflog, in that order. */
+    readonly paths: readonly string[];
+};
+/** The result of {@link localeWatchPaths}. */
+interface LocaleWatchPathsResult {
+    /** Every configured locale with its files, source locale first. */
+    readonly locales: readonly LocaleWatchFiles[];
+    /** The files git rewrites on a commit, a branch switch, a reset or a staging operation. */
+    readonly git: LocaleWatchGitPaths;
+}
+/** Input for {@link localeWatchPaths}. */
+interface LocaleWatchPathsInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** Directory the `files.pattern` is resolved against and git runs in. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory; pass `cwd` from {@link resolveProjectRoot} for a copied config. */
+    readonly cwd?: string;
+}
+/** Injectable dependencies for {@link localeWatchPaths}. Every field has a working default. */
+interface LocaleWatchPathsDeps {
+    /** Runs `git`. Defaults to a real `child_process.execFile`. */
+    readonly execFile?: GitExecFile;
+}
+/**
+ * Names the files a watcher needs to notice that what {@link localeGitStatus} reports has changed:
+ * each configured locale's file with the files next to it that hold part of its data (the
+ * `.stringsdict` file of `apple-strings`), and the files git rewrites when a commit, a branch
+ * switch, a reset or a staging operation moves the checked-out state. It reads paths and writes
+ * nothing; git is asked where this work tree keeps its index, `HEAD` and `HEAD` reflog, which also
+ * answers for a linked work tree and a repository whose git directory lives elsewhere. The command
+ * safeguards of {@link localeGitStatus} apply. A project outside a work tree still gets its locale
+ * files, with `git.available: false`.
+ *
+ * @param input - The config and the project directory.
+ * @param deps - Optional process runner override.
+ * @returns The locale files and the git paths.
+ *
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a configured locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ *
+ * @example
+ * ```ts
+ * import { loadConfig, localeWatchPaths } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const watch = await localeWatchPaths({ config });
+ * console.log(watch.locales, watch.git);
+ * ```
+ */
+declare function localeWatchPaths(input: LocaleWatchPathsInput, deps?: LocaleWatchPathsDeps): Promise<LocaleWatchPathsResult>;
+
 /** One locale's lock-file baseline and the drift measured against it. */
 interface LockLocaleState {
     /** The target locale this entry describes. */
@@ -9408,6 +10466,68 @@ type ReviewQueueResult = {
  */
 declare function reviewQueue(input: ReviewQueueInput, deps?: ReviewQueueDeps): Promise<ReviewQueueResult>;
 
+/** How many records {@link runHistory} returns when `limit` is left out. */
+declare const RUN_HISTORY_DEFAULT_LIMIT = 50;
+/** The most records {@link runHistory} returns, whatever `limit` asks for. */
+declare const RUN_HISTORY_MAX_LIMIT = 200;
+/** Input for {@link runHistory}. */
+interface RunHistoryInput {
+    /**
+     * Directory holding the `.verbatra-local` directory. Defaults to the process working directory,
+     * even when the config was found in a parent directory: pass the root {@link resolveProjectRoot}
+     * returns.
+     */
+    readonly cwd?: string;
+    /**
+     * How many of the newest records to return. A value below 1 returns one record, a value above
+     * 200 returns 200, and a value that is not a number returns the default of 50.
+     */
+    readonly limit?: number;
+}
+/** Injectable dependencies for {@link runHistory}. Every field has a working default. */
+interface RunHistoryDeps {
+    /** File-system port. Defaults to the real file system. */
+    readonly fs?: SdkFs;
+}
+/** The outcome of {@link runHistory}. */
+interface RunHistoryResult {
+    /** The newest records first, at most `limit` of them. */
+    readonly records: readonly RunHistoryRecord[];
+    /** How many readable records the file holds, which can exceed the number returned. */
+    readonly total: number;
+    /**
+     * How many lines of the file could not be read: not JSON, not the record shape, over 16 KiB, or
+     * written by a newer verbatra. They are left out of `records`, and the next recorded run rewrites
+     * the file without them.
+     */
+    readonly unreadableRecords: number;
+    /**
+     * Set when the whole file could not be read, so `records` is empty for that reason and not
+     * because no run was recorded. Absent when the file was read, or does not exist yet.
+     */
+    readonly unavailable?: RunHistoryUnavailableReason | undefined;
+}
+/**
+ * Reads the local run history that finished {@link translate}, {@link watch},
+ * {@link retranslateEntry} and {@link retranslateEntries} runs leave in
+ * `.verbatra-local/run-history.jsonl`: per run the time, trigger, provider, token usage, the cost
+ * frozen at the rates the config held then, and per locale the counts and, when measured, the
+ * coverage. It writes nothing and calls no provider.
+ *
+ * A record holds counts only, never a key name or a translation. A dry run is not recorded, and
+ * neither is a run that left no trace: every locale succeeded and nothing was translated, served
+ * from the cache, reused, generated, pruned, refused or failed, and no tokens were spent. A run
+ * that failed or was refused records too. The file keeps the newest 1,000 records. The read is
+ * total: a missing file is an empty history, an unreadable or oversized (over 8 MiB) file is an
+ * empty history with `unavailable` set, and a single bad line, one that is not valid UTF-8
+ * included, is dropped and counted in `unreadableRecords`, so this call throws nothing.
+ *
+ * @param input - The optional working directory and record limit.
+ * @param deps - Optional file-system override.
+ * @returns The newest records, how many the file holds, and how many lines could not be read.
+ */
+declare function runHistory(input?: RunHistoryInput, deps?: RunHistoryDeps): Promise<RunHistoryResult>;
+
 /**
  * One locale's entry in a persisted {@link RunStatusFile}. It is a deliberately narrow projection
  * of {@link LocaleSummary}: only the parts a later session still needs, namely the outcome, the
@@ -9549,6 +10669,87 @@ declare function runStatus(input?: RunStatusInput, deps?: RunStatusDeps): Promis
  */
 declare function assertTargetLocale(config: Pick<VerbatraConfig, "targetLocales">, locale: string): void;
 
+/** Input for {@link setKeyLengthLimit}. */
+interface SetKeyLengthLimitInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** Directory the `files.pattern` and `verbatra.limits.json` are resolved against. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory. */
+    readonly cwd?: string;
+    /** The key to limit. Must exist in the source resource, and the config's `maxLength` must not set it. */
+    readonly key: string;
+    /** The most characters a value of the key may have, a whole number of at least 1, or `null` to remove the key's entry from the limits file. */
+    readonly maxLength: number | null;
+    /**
+     * How long, in milliseconds, to wait for the project's limits write lock before failing with
+     * `LOCK_CONTENDED`. Defaults to ten minutes.
+     */
+    readonly lockAcquireTimeoutMs?: number;
+}
+/** Injectable dependencies for {@link setKeyLengthLimit}. Every field has a working default. */
+interface SetKeyLengthLimitDeps {
+    /** Format-adapter registry to resolve the configured format. Defaults to the built-in registry. */
+    readonly adapterRegistry?: AdapterRegistry;
+    /** File-system port. Defaults to the real file system. */
+    readonly fs?: SdkFs;
+}
+/** What {@link setKeyLengthLimit} did. */
+interface SetKeyLengthLimitResult {
+    /** The key the call was about. */
+    readonly key: string;
+    /** The limit the file now holds for the key, `null` when it holds none. */
+    readonly maxLength: number | null;
+    /** `false` when the file already held exactly this and nothing was written. */
+    readonly changed: boolean;
+}
+/**
+ * Sets, changes, or removes one key's length limit in `verbatra.limits.json`, the file beside the
+ * lock file that holds limits the config does not. A limit is advisory: a value over it is flagged
+ * `MAX_LENGTH_EXCEEDED` for review and never refused.
+ *
+ * The key must exist in the source resource, and a limit for a key the config's own `maxLength`
+ * sets is refused, because the config wins and the file could not change anything for it. Passing
+ * `null` removes the key's entry from the file, whatever the config says, also for a key that has
+ * since left the source or while the source cannot be read, so a stale or shadowed entry can be
+ * cleaned up. The file is written sorted, with a final newline.
+ *
+ * The whole read-modify-write runs under a project-wide limits lock, so two concurrent calls, from
+ * this process or another, are serialized and neither update is lost, and the file is replaced
+ * atomically. A call that leaves the file as it is succeeds and writes nothing. A file that cannot
+ * be read as a limits file is never overwritten.
+ *
+ * @param input - The config, the key, and the limit or `null`.
+ * @param deps - Optional adapter registry and file-system overrides.
+ * @returns The key, the limit the file holds for it afterwards, and whether anything was written.
+ *
+ * @throws {@link SdkError} `LENGTH_LIMIT_INVALID`: the key is empty or longer than 1024 characters,
+ * the limit is not a whole number from 1 to `Number.MAX_SAFE_INTEGER` or `null`, the limit is a
+ * number and the config's `maxLength` sets the key, or the write would take the file past 10,000
+ * entries or 1 MiB. The first three are thrown before anything is read or locked.
+ * @throws {@link SdkError} `LOCK_TIMEOUT_INVALID`: `lockAcquireTimeoutMs` is not a whole number of
+ * milliseconds of at least 0. Thrown before anything is read or locked.
+ * @throws {@link SdkError} `UNKNOWN_FORMAT`: no adapter is registered for the configured format.
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or the locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ * @throws {@link SdkError} `SOURCE_UNREADABLE`: the source locale file does not exist.
+ * @throws {@link SdkError} `SOURCE_INVALID`: the source locale file could not be parsed.
+ * @throws {@link SdkError} `UNKNOWN_KEY`: the key is not present in the source resource and the
+ * file holds no entry of that name to remove.
+ * @throws {@link SdkError} `LOCK_CONTENDED`: the project's limits write lock could not be acquired
+ * before the timeout elapsed, could not be reclaimed from an abandoned holder, or was taken over by
+ * another process before the file was written.
+ * @throws {@link SdkError} `RUN_CANCELLED`: {@link releaseHeldLocks} was running when the call
+ * went to take the write lock, so that lock was refused.
+ * @throws {@link SdkError} `LIMITS_FILE_UNUSABLE`: the limits file cannot be used (not a
+ * regular file, over 1 MiB, not UTF-8 or JSON, another shape, a newer version, or more than 10,000 entries). Nothing
+ * is overwritten.
+ * @throws {@link SdkError} `LIMITS_FILE_UNWRITABLE`: the limits file exists but the process may not read
+ * it (a permissions problem), or it or the limits lock could not be written, or the lock could not be
+ * released after the limit was saved, which the message says. A write failure carries the
+ * file-system error as its `cause`.
+ */
+declare function setKeyLengthLimit(input: SetKeyLengthLimitInput, deps?: SetKeyLengthLimitDeps): Promise<SetKeyLengthLimitResult>;
+
 /**
  * The zod 4 schema for a {@link LocaleSummary}, one locale of a {@link RunSummary}. `parse`
  * accepts fields it does not list and strips them from its result.
@@ -9602,6 +10803,7 @@ declare const localeSummarySchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         code: z.ZodEnum<{
             PLURAL_CATEGORIES_INCOMPLETE: "PLURAL_CATEGORIES_INCOMPLETE";
+            LIMITS_FILE_IGNORED: "LIMITS_FILE_IGNORED";
             SUB_BATCH_FAILED: "SUB_BATCH_FAILED";
             BLANK_ROW_BASELINE_RETAINED: "BLANK_ROW_BASELINE_RETAINED";
             HANDOFF_REVIEWS_RECORDED: "HANDOFF_REVIEWS_RECORDED";
@@ -9743,6 +10945,7 @@ declare const runSummarySchema: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             code: z.ZodEnum<{
                 PLURAL_CATEGORIES_INCOMPLETE: "PLURAL_CATEGORIES_INCOMPLETE";
+                LIMITS_FILE_IGNORED: "LIMITS_FILE_IGNORED";
                 SUB_BATCH_FAILED: "SUB_BATCH_FAILED";
                 BLANK_ROW_BASELINE_RETAINED: "BLANK_ROW_BASELINE_RETAINED";
                 HANDOFF_REVIEWS_RECORDED: "HANDOFF_REVIEWS_RECORDED";
@@ -10827,6 +12030,308 @@ declare function resolveDryRun(input: {
  */
 declare function translate(input: TranslateInput, deps?: TranslateDeps): Promise<RunSummary>;
 
+/**
+ * What {@link previewValueReplace} says about one value. `ready` and `stale-source` can be applied.
+ * `stale-source` marks a key whose source text changed since its translation was recorded: a
+ * replacement still applies, but the key stays reported as out of date. `gate-refused` carries the
+ * integrity rule the replaced value would break. `pinned` is a key matching the config's
+ * `pinnedKeys`. `protected` is a value a person wrote, imported, or changed outside verbatra, or
+ * any value when the provenance file cannot be read. `no-source-entry` is a key with no source
+ * text to check the new value against, such as an orphan or a generated plural form. `unchanged`
+ * is a value the replacement would leave as it is. `too-long` is a value the replacement would
+ * grow past 20,000 characters; it is not an integrity refusal and carries no `reason`.
+ */
+type ValueReplaceStatus = "ready" | "stale-source" | "gate-refused" | "pinned" | "protected" | "no-source-entry" | "unchanged" | "too-long";
+/** One matched value in a {@link ValueReplacePreview}. */
+interface ValueReplacePreviewEntry {
+    /** The target locale the value is in. */
+    readonly locale: string;
+    /** The key. */
+    readonly key: string;
+    /** Whether and how the replacement would apply. */
+    readonly status: ValueReplaceStatus;
+    /**
+     * Present, and `true`, only on a `pinned` entry whose value is also protected (a person wrote,
+     * imported, or changed it outside verbatra, or the provenance file cannot be read). Such a key is
+     * applied only when both `includePinned` and `includeProtected` are set. Absent otherwise.
+     */
+    readonly protected?: true;
+    /** The integrity rule the replaced value would break. Present only for `gate-refused`. */
+    readonly reason?: IntegrityGateReason;
+    /** What is behind a `gate-refused` reason, as {@link EditEntryResult} reports it. Absent otherwise. */
+    readonly details?: readonly string[];
+    /**
+     * The hash of the current value, the one the provenance record stores. Pass it back in
+     * {@link ApplyValueReplaceInput.entries} so {@link applyValueReplace} can tell whether the value
+     * changed since this preview. It is not the salted marker {@link approveEntry} takes, and it is
+     * blind to a change that only differs in Unicode normalization or line endings.
+     */
+    readonly valueHash: string;
+    /** Up to 200 characters of the current value around the first match. */
+    readonly before: string;
+    /** Up to 200 characters of the replaced value from the same position. Empty when the replaced value would exceed 20,000 characters. */
+    readonly after: string;
+    /** True when `before` or `after` is shorter than the value it comes from. */
+    readonly excerptCut: boolean;
+}
+/** The result of {@link previewValueReplace}. */
+interface ValueReplacePreview {
+    /** Matched values, by locale in the config's `targetLocales` order whatever order `locales` names them in, and by key in file order, at most 1,000. */
+    readonly entries: readonly ValueReplacePreviewEntry[];
+    /** True when more values matched than the 1,000 listed. */
+    readonly truncated: boolean;
+    /** How many of {@link ValueReplacePreview.entries} have each status. */
+    readonly counts: Readonly<Record<ValueReplaceStatus, number>>;
+    /**
+     * True when the lock file is corrupt, oversized, or from a newer verbatra, so no value could be
+     * compared with its recorded source text and none is reported as `stale-source`. Absent
+     * otherwise, including when there is no lock file.
+     */
+    readonly baselineUnavailable?: true;
+}
+interface ValueReplaceFindInput {
+    /** The resolved project config, normally from {@link loadConfig}. */
+    readonly config: VerbatraConfig;
+    /** Directory the `files.pattern` is resolved against. Defaults to the project root of the config object {@link loadConfig} returned, else the process working directory; a copied or rebuilt config loses that root, so pass `cwd` from {@link resolveProjectRoot}. */
+    readonly cwd?: string;
+    /** The text to find, matched literally in target values only: 1 to 20,000 characters, with no unpaired surrogate. */
+    readonly find: string;
+    /** The text to put in its place, inserted exactly as given, with no unpaired surrogate. `$&`, `$1` and the like have no special meaning. */
+    readonly replace: string;
+    /** Whether letter case must match. Defaults to `true`. */
+    readonly caseSensitive?: boolean;
+}
+/** Input for {@link previewValueReplace}. */
+interface PreviewValueReplaceInput extends ValueReplaceFindInput {
+    /** The target locales to search. Defaults to every configured target locale. */
+    readonly locales?: readonly string[];
+}
+/** One value to change in {@link ApplyValueReplaceInput.entries}. */
+interface ValueReplaceEntryRef {
+    /** The target locale the value is in. */
+    readonly locale: string;
+    /** The key. */
+    readonly key: string;
+    /** The `valueHash` {@link previewValueReplace} returned for the value. */
+    readonly valueHash: string;
+}
+/** Input for {@link applyValueReplace}. */
+interface ApplyValueReplaceInput extends ValueReplaceFindInput {
+    /** The values to change, as {@link previewValueReplace} listed them. Their locales must be configured target locales. */
+    readonly entries: readonly ValueReplaceEntryRef[];
+    /** Also change keys that match the config's `pinnedKeys`. Ignored when `actor` is `agent`. Defaults to `false`. */
+    readonly includePinned?: boolean;
+    /** Also change values a person wrote, imported, or changed outside verbatra. Defaults to `false`. */
+    readonly includeProtected?: boolean;
+    /**
+     * Who is making the change, recorded as the origin of every changed value in the provenance
+     * file. The calling surface asserts it; nothing verifies it.
+     */
+    readonly actor: EditEntryActor;
+    /** Called while waiting on another process's write lock for a locale. */
+    readonly onLockWait?: LockWaitListener;
+    /** How long, in milliseconds, to wait for each locale's write lock before failing with `LOCK_CONTENDED`. Defaults to ten minutes. */
+    readonly lockAcquireTimeoutMs?: number;
+}
+/** Injectable dependencies for {@link previewValueReplace} and {@link applyValueReplace}. Every field has a working default. */
+interface ValueReplaceDeps {
+    /** Format-adapter registry to resolve the configured format. Defaults to the built-in registry. */
+    readonly adapterRegistry?: AdapterRegistry;
+    /** File-system port. Defaults to the real file system. */
+    readonly fs?: SdkFs;
+}
+/** Why {@link applyValueReplace} left a value alone. */
+type ValueReplaceSkipReason = "pinned" | "protected" | "no-source-entry" | "unchanged" | "duplicate-entry" | "locale-failed";
+/** A locale {@link applyValueReplace} could not finish. */
+interface ValueReplaceLocaleFailure {
+    /** The locale that failed. */
+    readonly locale: string;
+    /** The failure's own code where it has one, and `LOCALE_FAILED` otherwise. */
+    readonly code: string;
+    /** What went wrong, with file paths relative to the project. Never carries a translation value. */
+    readonly message: string;
+    /**
+     * True when the failure came after the locale file was written, while the lock file or the
+     * provenance file was updated or the write lock was released. The accepted values are then on disk
+     * and reported `applied`, and the lock file or provenance record may lag behind them, so review the
+     * locale before any retry. Absent when nothing was written for the locale.
+     */
+    readonly fileWritten?: true;
+}
+/** What {@link applyValueReplace} did with one entry. */
+type ValueReplaceOutcome = {
+    readonly locale: string;
+    readonly key: string;
+    readonly status: "applied";
+    /** True when the key's source text had changed since its translation was recorded, so it still reads as out of date. */
+    readonly staleSource: boolean;
+} | {
+    readonly locale: string;
+    readonly key: string;
+    readonly status: "skipped";
+    readonly reason: ValueReplaceSkipReason;
+} | {
+    readonly locale: string;
+    readonly key: string;
+    readonly status: "refused";
+    /** The integrity rule the replaced value broke. */
+    readonly reason: IntegrityGateReason;
+    readonly details?: readonly string[];
+} | {
+    readonly locale: string;
+    readonly key: string;
+    /** The value no longer matches the `valueHash`, no longer contains the text, or is gone. Nothing was written. */
+    readonly status: "changed";
+} | {
+    readonly locale: string;
+    readonly key: string;
+    /** The replaced value would be longer than 20,000 characters. Nothing was written. */
+    readonly status: "too-long";
+};
+/** The result of {@link applyValueReplace}. */
+interface ApplyValueReplaceResult {
+    /** One outcome per entry passed, in the same order. */
+    readonly outcomes: readonly ValueReplaceOutcome[];
+    /** How many outcomes have each status. */
+    readonly counts: Readonly<Record<ValueReplaceOutcome["status"], number>>;
+    /** The locales that failed, in the order they were processed. Empty when every locale finished. */
+    readonly localeFailures: readonly ValueReplaceLocaleFailure[];
+}
+/**
+ * Lists the values that a literal find-and-replace would change, and says for each whether it
+ * would apply. It reads target locale values only, never the source locale, writes nothing, and
+ * calls no provider.
+ *
+ * Matching is literal and compares UTF-16 text as it is stored: no pattern syntax, no Unicode
+ * normalization, and no line-ending translation, so an NFD `find` does not match an NFC value and
+ * `\n` does not match `\r\n`. With `caseSensitive: false` letters are compared by their lower-case
+ * form, one character at a time. A match never starts or ends inside a surrogate pair. The
+ * replacement is inserted as given.
+ *
+ * Every candidate value is held to the same integrity gate as an edit, against its current source
+ * text, so a replacement that drops a placeholder, breaks markup or ICU syntax, blanks the value,
+ * or runs away into a repetition-dominated value is listed as `gate-refused`. For the ICU formats
+ * (next-intl and ARB) the replacement is also refused as `gate-refused` with the reason `icu` when
+ * it changes what an argument does: an argument's type, a number or date style or skeleton, or how
+ * many `#` a plural arm holds, compared with the current value, or with the source text when the
+ * current value is not valid ICU. An argument renamed away from the source text is refused as
+ * `placeholder`. The `details` list each difference, prefixed `-` for what the compared value had
+ * and `+` for what the replaced value has. A replaced value longer than 20,000 characters is listed as `too-long`, which is not an
+ * integrity refusal and carries no `reason`. Keys that
+ * match `pinnedKeys`, and values a person wrote, imported, or changed outside verbatra, are listed
+ * as `pinned` and `protected` whatever the config's `humanEdits` says (a key that is both is
+ * listed as `pinned` with `protected: true`), and every value counts as
+ * protected when the provenance file cannot be read, which includes a file from a newer verbatra:
+ * that file is never rewritten, and a value changed with `includeProtected` gets no record in it. A
+ * key whose source text changed since its translation was recorded is `stale-source`, and its
+ * replacement is checked against the current source text.
+ *
+ * At most 1,000 matched values are listed, `truncated` says when there were more, and each
+ * excerpt is at most 200 characters. The preview is advisory: {@link applyValueReplace} decides
+ * again, under the write lock, from the values on disk at that moment.
+ *
+ * @param input - The config, locales, and the find and replace text.
+ * @param deps - Optional adapter registry and file-system overrides.
+ * @returns The matched values with a status each, a truncation flag, and counts per status.
+ *
+ * @throws {@link SdkError} `FIND_TEXT_INVALID`: `find` is empty or longer than 20,000 characters, or
+ * `find` or `replace` holds an unpaired surrogate.
+ * @throws {@link SdkError} `UNKNOWN_FORMAT`: no adapter is registered for the configured format.
+ * @throws {@link SdkError} `UNKNOWN_LOCALE`: a requested locale is not a configured target locale.
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a configured locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ * @throws {@link SdkError} `SOURCE_UNREADABLE`: the source locale file does not exist.
+ * @throws {@link SdkError} `SOURCE_INVALID`: the source locale file could not be parsed.
+ * @throws `AdapterError`: the adapter refused a target locale file because it is malformed. Its
+ * own code is preserved rather than remapped onto an {@link SdkErrorCode}.
+ *
+ * @example
+ * ```ts
+ * import { loadConfig, previewValueReplace } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const preview = await previewValueReplace({ config, find: "Colour", replace: "Color" });
+ * const ready = preview.entries.filter((entry) => entry.status === "ready");
+ * ```
+ */
+declare function previewValueReplace(input: PreviewValueReplaceInput, deps?: ValueReplaceDeps): Promise<ValueReplacePreview>;
+/**
+ * Replaces literal text in the target values the caller picked from a {@link previewValueReplace}
+ * result. For each entry the server recomputes the new value from `find` and `replace` over the
+ * value currently on disk, inside the locale's write lock; it never takes a computed value from
+ * the caller, so a stale or forged preview cannot write anything the replacement would not.
+ *
+ * Under the lock every entry is decided again. A value whose `valueHash` no longer matches, or
+ * that no longer contains the text, or is gone, is `changed` and nothing is written for it. The
+ * hash ignores Unicode normalization and line endings, so a value that differs from the preview
+ * only that way is replaced when the text still matches, and is `changed` when it no longer does.
+ * A key with no source text, and a replacement that leaves the value as it is, are `skipped`. A
+ * pinned key is `skipped` unless `includePinned` is set and `actor` is `human`; an agent never
+ * changes a pinned key. A value that is protected as {@link previewValueReplace} describes it is
+ * `skipped` unless `includeProtected` is set, and this holds whatever `humanEdits` the config
+ * sets, so a key that is both pinned and protected needs both options. A value the integrity gate
+ * refuses is `refused`, with its reason. Everything else is written.
+ *
+ * Locales are processed one after another, each under its own write lock, with one write of the
+ * locale file, one update of the lock-file and provenance file, and one translation-memory update
+ * for all of that locale's values. A key whose source text changed since its translation was
+ * recorded keeps its old lock-file hash, so {@link check} still reports it out of date, and its
+ * value is not added to the translation memory. Every written value gets a fresh provenance
+ * record with `actor` as its origin and no review decision, whatever it had before.
+ *
+ * A locale that fails does not stop the others. Failures that only one locale's own processing
+ * can cause, such as `LOCK_CONTENDED` when its write lock is not free within `lockAcquireTimeoutMs`,
+ * `TARGET_UNWRITABLE`, `LOCALE_STATE_NOT_CARRIED_OVER`, `RUN_CANCELLED`, `SOURCE_UNREADABLE` and
+ * `SOURCE_INVALID` (the source file is read before any locale is touched and again under each locale's
+ * lock), or an `AdapterError` from its file, are recorded in `localeFailures`. An entry the
+ * integrity gate refused still comes back `refused`, and one a check had settled before the failure
+ * keeps its outcome; the rest come back `skipped` with the reason `locale-failed`, and nothing was
+ * written for them. When the failure came after the locale file was written, such as a failed lock
+ * file or provenance update or a write lock that could not be released, the failure carries `fileWritten: true` and the
+ * accepted entries come back `applied`: their values are on disk and the lock file or provenance may
+ * lag, so review the locale before any retry. Do not run a replacement again whose `find` occurs in
+ * its `replace` without checking, because it would change the written values a second time. The
+ * wait for the lock file's own guard uses the default of ten minutes, not `lockAcquireTimeoutMs`.
+ *
+ * Entries are grouped by locale in the order each locale first appears in `entries`. When the same
+ * `locale` and `key` appear more than once, the first one decides: it is processed whatever its
+ * `valueHash` is, and every later one is `skipped` with the reason `duplicate-entry`.
+ *
+ * @param input - The config, the find and replace text, the entries, and the actor.
+ * @param deps - Optional adapter registry and file-system overrides.
+ * @returns One outcome per entry, in order, counts per status, and the locales that failed.
+ *
+ * @throws {@link SdkError} `FIND_TEXT_INVALID`: `find` is empty or longer than 20,000 characters, or
+ * `find` or `replace` holds an unpaired surrogate.
+ * @throws {@link SdkError} `UNKNOWN_FORMAT`: no adapter is registered for the configured format.
+ * @throws {@link SdkError} `UNKNOWN_LOCALE`: an entry names a locale that is not a configured target
+ * locale. Thrown before anything is written.
+ * @throws {@link SdkError} `LOCALE_LAYOUT_INVALID`: the `files.pattern` and `files.localeStyle`
+ * cannot be combined, or a locale has no valid path spelling under that style.
+ * @throws {@link SdkError} `LOCALE_PATH_COLLISION`: two configured locales resolve to the same path.
+ * @throws {@link SdkError} `LOCK_TIMEOUT_INVALID`: `lockAcquireTimeoutMs` is not a whole number of
+ * milliseconds of at least 0. Thrown before anything is read or locked.
+ * @throws {@link SdkError} `LOCK_FILE_INVALID`: the lock-file is corrupt, oversized, or at an
+ * unsupported version. Checked before anything is written.
+ * @throws {@link SdkError} `PROVENANCE_FILE_INVALID`: the provenance file is corrupt, oversized, or
+ * structurally wrong. Checked before anything is written.
+ *
+ * @example
+ * ```ts
+ * import { applyValueReplace, loadConfig, previewValueReplace } from "@verbatra/sdk";
+ *
+ * const config = await loadConfig();
+ * const criteria = { config, find: "Colour", replace: "Color" };
+ * const preview = await previewValueReplace(criteria);
+ * const entries = preview.entries
+ *   .filter((entry) => entry.status === "ready")
+ *   .map(({ locale, key, valueHash }) => ({ locale, key, valueHash }));
+ * const result = await applyValueReplace({ ...criteria, entries, actor: "human" });
+ * ```
+ */
+declare function applyValueReplace(input: ApplyValueReplaceInput, deps?: ValueReplaceDeps): Promise<ApplyValueReplaceResult>;
+
 /**
  * The two XLIFF handoff shapes: `xliff2` writes XLIFF 2.0 and `xliff12` writes XLIFF 1.2, for a
  * CAT tool that does not read 2.0 yet. On import both read either version, which is taken from the
@@ -10930,6 +12435,12 @@ interface ExportWorkbookResult {
      * newer verbatra (`unavailable`). The export itself succeeds either way.
      */
     readonly provenanceMarkers?: ProvenanceMarkers;
+    /**
+     * Present when `verbatra.limits.json` could not be used, so the `max-length-exceeded` review
+     * reasons in the handoff were judged against the config's `maxLength` budgets alone. The export
+     * itself succeeds.
+     */
+    readonly limitsNotice?: LimitsFileNotice;
 }
 /**
  * Writes the strings awaiting translation to a handoff a human translator can work in: a styled
@@ -10966,6 +12477,9 @@ interface ExportWorkbookResult {
  * written surfaces as `EXPORT_UNWRITABLE`, never as a raw file-system error. An existing file at
  * the output path is replaced.
  *
+ * A `verbatra.limits.json` that cannot be used is ignored, so only the config's `maxLength`
+ * budgets apply, and the result's `limitsNotice` says so; {@link doctor} names the problem.
+ *
  * @param input - The config, output path, config and glossary paths to protect, locale filter, and
  * handoff format.
  * @param deps - Optional adapter registry and file-system overrides.
@@ -11008,6 +12522,10 @@ declare const exportWorkbookResultSchema: z.ZodObject<{
         written: "written";
         unavailable: "unavailable";
     }>>;
+    limitsNotice: z.ZodExactOptional<z.ZodObject<{
+        code: z.ZodLiteral<"LIMITS_FILE_IGNORED">;
+        message: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 
 /** Input for {@link importWorkbook}. */
@@ -11076,10 +12594,12 @@ interface ImportWorkbookDeps {
  * Imported values are held to the same integrity gate as provider output, so a translator who drops
  * a placeholder, breaks inline markup or breaks ICU syntax has that row refused rather than
  * written, and a row whose source text changed since the export is refused the same way. A row
- * holding exactly `[[CLEAR]]` empties that key's translation. Each locale takes its write lock, and
- * the lock-file and translation memory are updated exactly as in a {@link translate} run, so an
- * imported translation counts as up to date afterwards. Each accepted row is recorded in the
- * provenance file with the origin `import`.
+ * holding exactly `[[CLEAR]]` empties that key's translation. In a CSV, TSV or xlsx file, a filled
+ * row equal to the value an up-to-date key already holds is left alone and reported unchanged once
+ * it passes the same gate. Each locale takes its write lock, and the lock-file and translation
+ * memory are updated exactly as in a {@link translate} run, so an imported translation counts as up
+ * to date afterwards. Each accepted row is recorded in the provenance file with the origin
+ * `import`.
  *
  * Damage is contained rather than fatal: a blank row keeps the existing translation and its
  * baseline, an unreadable row is reported as a {@link MalformedRowReport}, and a repeated key is
@@ -11828,5 +13348,5 @@ interface WatchController {
  */
 declare function watch(input: WatchInput, deps?: WatchDeps): Promise<WatchController>;
 
-export { AdapterError, AdapterRegistry, BatchInterruptedError, CACHE_FILE_NAME, DATA_FLOW_MANIFEST_VERSION, DEFAULT_DELIMITED_PATH, DEFAULT_EXCHANGE_FORMAT, DEFAULT_TMX_PATH, DEFAULT_TYPES_PATH, DEFAULT_WORKBOOK_PATH, EXCHANGE_FORMATS, INTEGRITY_GATE_REASONS, JSON_SCHEMA_BASE_URL, KNOWN_ERROR_CODES, LOCALE_HISTORY_LIMIT_CAP, LOCALE_HISTORY_LIMIT_DEFAULT, LOCALE_HISTORY_MAX_OUTPUT_BYTES, LOCALE_HISTORY_TIMEOUT_MS, LOCALE_HISTORY_UNAVAILABLE_REASONS, LOCALE_VALUES_QUERY_MAX_LENGTH, LOCK_FILE_NAME, MACHINE_CLASS_ORIGINS, PAGE_CURSOR_MAX_LENGTH, PAGE_LIMIT_CAP, PAGE_LIMIT_DEFAULT, PROVENANCE_BUCKETS, PROVENANCE_FILE_NAME, PSEUDO_MODES, ProviderError, QA_SEVERITIES, REVIEW_REASON_CODES, RUN_STATUS_UNAVAILABLE_REASONS, SDK_JSON_SCHEMAS, SdkError, approveEntries, approveEntry, approveLocale, assertMachineTranslationEnabled, assertTargetLocale, budgetStanding, check, checkFile, checkFileSummarySchema, checkSummarySchema, configCandidatePaths, createDefaultRegistry, createFlatFileAdapter, createLocalePathResolver, createTreeFileAdapter, createValueMarker, dataFlow, dataFlowManifestSchema, declareProviderKeyEnvVar, defineConfig, detectProject, diff, diffLocaleSnapshots, diffSummarySchema, doctor, doctorResultSchema, editConfiguredGlossaryTerm, editEntry, errorHint, exportTmx, exportTmxResultSchema, exportWorkbook, exportWorkbookResultSchema, extract, extractResultSchema, generateTypes, generateTypesResultSchema, glossaryDraftCheck, glossaryForLocale, glossaryHits, importTmx, importTmxResultSchema, importWorkbook, isCustomFormatId, isMachineTranslationEnabled, jsonSchemaUrl, keyContext, keyIntegrity, keyOriginSchema, keyProvenanceSchema, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, loadProvenance, localeHistory, localeIntegrity, localeSummarySchema, localeValues, localeValuesPage, lockState, lockWaitEventSchema, nodeAdapterFs, normalizeGlossary, progressEventSchema, projectRelativeMessage, provenanceReport, provenanceReportPage, provenanceReportResultSchema, provenanceSummarySchema, pseudolocalize, pseudolocalizeResultSchema, readCurrentGlossary, readGlossaryFile, readLocaleFileSnapshot, redact, redactGlossary, rejectEntries, rejectEntry, releaseHeldLocks, renderJsonSchemas, renderOutputJsonSchema, resolveDryRun, resolveProjectRoot, retranslateEntries, retranslateEntry, reviewQueue, runStatus, runSummarySchema, scaffoldingMetadata, sharedGlossaryTranslations, tmxErrorLocation, translate, updateGlossaryTerm, verbatraConfigSchema, watch };
-export type { AdapterErrorCode, AdapterFs, AdapterResolution, AddedKey, ApproveLocaleDeps, ApproveLocaleInput, ApproveLocaleResult, AuthoringConfig, AuthoringConfigFor, BatchEntry, BatchEntryFailure, BatchEntrySkipped, BatchFinishedEvent, BillingUnit, BoundedBytesRead, BoundedFileRead, BoundedReadOutcome, BudgetBehavior, BudgetStanding, BuildWriteTree, ChangeDetectedEvent, CharacterRate, CharacterRunQuantity, CheckDeps, CheckFileDeps, CheckFileFinding, CheckFileInput, CheckFileRole, CheckFileSummary, CheckInput, CheckQaSummary, CheckReviewCode, CheckReviewSummary, CheckSensitiveSummary, CheckSummary, CompareBranchArms, ComparePlaceholders, ComputeInvalidIcuKeys, ConfigCandidateOptions, ConfigSource, CreateProvider, CreateProviderContext, CreateProviderHooks, CreateWatcher, CustomFormatId, DataFlowAgentSurface, DataFlowApiKey, DataFlowCounts, DataFlowDeps, DataFlowDestination, DataFlowField, DataFlowInput, DataFlowLocalFile, DataFlowLocale, DataFlowManifest, DataFlowNetwork, DataFlowOtherRequest, DataFlowProvider, DataFlowProviderKind, DataFlowSent, DataFlowVerdict, DeriveDescriptions, DeriveEntry, DetectProjectDeps, DetectProjectInput, DetectedFormat, DetectedFormatSource, DetectedLocaleLayout, DetectionAmbiguity, DetectionConfidence, DiffDeps, DiffInput, DiffSummary, DirectoryEntry, DoNotTranslateTerm, DoctorCheck, DoctorCheckId, DoctorCheckStatus, DoctorDeps, DoctorInput, DoctorResult, DuplicateKeyReport, EditConfiguredGlossaryTermInput, EditEntryActor, EditEntryDeps, EditEntryInput, EditEntryResult, EstimateCaveatCode, EstimateIdentity, EstimatePricing, ExchangeFormat, ExportTmxDeps, ExportTmxInput, ExportTmxLocaleCount, ExportTmxResult, ExportWorkbookDeps, ExportWorkbookInput, ExportWorkbookResult, ExtractDeps, ExtractInput, ExtractPlaceholders, ExtractResult, ExtractionConfig, FileQaReport, FlatFileAdapterOptions, FlatParseOutcome, FlatParseResult, FormatAdapter, FormatId, FuzzyCacheHit, GenerateTypesDeps, GenerateTypesInput, GenerateTypesResult, GitExecFile, GitExecFileResult, Glossary, GlossaryConfig, GlossaryDefinition, GlossaryDoNotTranslateDefinition, GlossaryDraftCheck, GlossaryDraftCheckInput, GlossaryDraftDoNotTranslateCheck, GlossaryDraftTermCheck, GlossaryFileDeps, GlossaryFileInput, GlossaryHitsInput, GlossaryInput, GlossaryProvenance, GlossaryTerm, GlossaryTermDefinition, HumanEditsPolicy, IdleEvent, ImportTmxDeps, ImportTmxInput, ImportTmxLocaleResult, ImportTmxResult, ImportWorkbookDeps, ImportWorkbookInput, IncompletePlural, InconsistencyGroup, InconsistentTranslation, IntegrityGateReason, IntegrityRefusal, JsonLeaf, JsonRecord, JsonSchemaDocument, JsonSchemaObject, JsonTree, KeyConflict, KeyContext, KeyContextDeps, KeyContextGlossaryNotice, KeyContextInput, KeyIntegrityDeps, KeyIntegrityEntry, KeyIntegrityInput, KeyMode, KeyOrigin, KeyProvenance, KeyReviewState, KeyValueDeps, KeyValueInput, KeyValuePair, KeyValueResult, LanguageTableRefresh, LanguageTableRefreshStatus, LiteralFinding, LiteralScan, LiteralSuppressionReason, LoadConfigOptions, LoadLockFileDeps, LoadLockFileInput, LoadProvenanceDeps, LoadProvenanceInput, LoadedConfig, LocaleCapability, LocaleCapabilityReport, LocaleCapabilityWarning, LocaleCapabilityWarningCode, LocaleCheckSummary, LocaleDiff, LocaleEstimate, LocaleEstimateQuantity, LocaleFileCheck, LocaleFileSnapshot, LocaleFinishedEvent, LocaleGlossary, LocaleGlossaryTerm, LocaleHistoryCommit, LocaleHistoryDeps, LocaleHistoryInput, LocaleHistoryResult, LocaleHistoryUnavailableReason, LocaleIntegrityDeps, LocaleIntegrityInput, LocaleKeyIntegrity, LocaleNotice, LocalePathResolver, LocalePathResolverConfig, LocalePlannedEvent, LocaleQaReport, LocaleResource, LocaleReviewReport, LocaleSnapshotDelta, LocaleStartedEvent, LocaleStyle, LocaleSummary, LocaleSupport, LocaleValues, LocaleValuesDeps, LocaleValuesInput, LocaleValuesPage, LocaleValuesPageEntry, LocaleValuesPageInput, LocaleValuesPageLocale, LockFile, LockHolder, LockLocaleState, LockStateDeps, LockStateInput, LockStateResult, LockWaitEvent, LockWaitListener, MachineClassOrigin, MalformedRowReport, ModelRate, NeedsReviewEntry, NetworkPolicy, NetworkRule, OrderedRecord, OrderedValue, PlaceholderComparator, PlaceholderExtractor, PlaceholderIntegrityResult, PluralCategories, PluralCategory, PluralCategoryLookup, PluralRuleType, PossiblyDynamicKey, PricedLocaleEstimate, PricedRunEstimate, ProgressEvent, ProgressListener, ProjectDetection, ProtectedKey, ProtectionReason, ProvenanceBucket, ProvenanceFile, ProvenanceMarkers, ProvenanceOrigin, ProvenanceRecord, ProvenanceReport, ProvenanceReportDeps, ProvenanceReportEntry, ProvenanceReportInput, ProvenanceReportLocale, ProvenanceReportPage, ProvenanceReportPageInput, ProvenanceReportPageLocale, ProvenanceReportPageResult, ProvenanceReportResult, ProvenanceReviewState, ProvenanceSummary, ProviderBilling, ProviderConfig, ProviderErrorCode, ProviderId, ProviderKind, ProviderNetwork, ProviderNotice, ProviderNoticeCode, ProviderRetry, ProviderRetryEvent, ProviderRetryListener, PseudoMode, PseudolocalizeDeps, PseudolocalizeInput, PseudolocalizeResult, QaFinding, QaIntegrityFinding, QaReviewFinding, QaSeverity, QaSyntaxFinding, RateCard, ReadCurrentGlossaryInput, ReadLocaleFileSnapshotDeps, ReadLocaleFileSnapshotInput, ReadResult, RedactedGlossary, RepairEvent, ResolveOptions, RetranslateBatchOutcome, RetranslateEntriesInput, RetranslateEntriesResult, RetranslateEntryDeps, RetranslateEntryInput, RetranslateEntryResult, ReviewBatchEntry, ReviewBatchOutcome, ReviewDecisionDeps, ReviewDecisionInput, ReviewDecisionResult, ReviewEntriesInput, ReviewEntriesResult, ReviewFlag, ReviewQueueDeps, ReviewQueueEntry, ReviewQueueInput, ReviewQueueLocale, ReviewQueueResult, ReviewReasonCode, RunBudget, RunEstimate, RunEstimateQuantity, RunFinishedEvent, RunStatusDeps, RunStatusFile, RunStatusInput, RunStatusLocale, RunStatusResult, RunStatusUnavailableReason, RunSummary, RunTranslate, ScaffoldableProviderId, ScanDiagnostic, ScanDiagnosticReason, ScanProgressEvent, ScanProgressListener, SdkErrorCode, SdkFs, SdkNotice, SdkNoticeCode, SensitiveField, SensitiveFindingSource, SensitiveKeyFinding, Sniff, SourceExtractor, SourceFramework, SourceLocaleCapability, SourceLocation, SplitRetryEvent, SubBatchProgressEvent, SuggestionStatus, SupportedFormat, SuppressedLiteral, SyntaxPosition, TmxErrorLocation, TmxLanguageReport, TmxOrigin, TmxRejectionCounts, TmxRejectionReason, TmxReview, TmxUnitRefusal, TokenRate, TokenRunQuantity, Tone, TranslateDeps, TranslateInput, TranslateRequest, TranslateResult, TranslationEntry, TranslationMemory, TranslationProvider, TreeFileAdapterOptions, UnpricedLocaleEstimate, UnpricedRunEstimate, UnresolvedArgumentReason, UnresolvedMessage, UnusedKey, UnusedKeysNotRun, UnusedKeysNotRunReason, UnusedKeysPrefixSite, UnusedKeysReport, UnusedKeysScan, UnusedKeysSite, UnusedKeysUnreliability, UnusedKeysUnreliableReason, UpdateGlossaryTermInput, Usage, UsageSummary, ValidateMessage, ValidateTree, ValueMarker, VerbatraConfig, VerbatraConfigInput, WatchController, WatchDeps, WatchInput, WatchRunResult, Watcher, WriteContext, WritingEvent, XliffFormat };
+export { AdapterError, AdapterRegistry, BatchInterruptedError, CACHE_FILE_NAME, DATA_FLOW_MANIFEST_VERSION, DEFAULT_DELIMITED_PATH, DEFAULT_EXCHANGE_FORMAT, DEFAULT_TMX_PATH, DEFAULT_TYPES_PATH, DEFAULT_WORKBOOK_PATH, EXCHANGE_FORMATS, INTEGRITY_GATE_REASONS, JSON_SCHEMA_BASE_URL, KEY_HISTORY_DEADLINE_MS, KEY_HISTORY_MAX_KEY_CHARS, KEY_HISTORY_MAX_VALUE_CHARS, KEY_HISTORY_TRUNCATION_REASONS, KNOWN_ERROR_CODES, LOCALE_GIT_BLOB_MAX_BYTES, LOCALE_GIT_DIFF_MAX_ENTRIES, LOCALE_GIT_DIFF_MAX_VALUE_CHARS, LOCALE_GIT_FILE_STATES, LOCALE_GIT_MAX_OUTPUT_BYTES, LOCALE_GIT_TIMEOUT_MS, LOCALE_GIT_UNAVAILABLE_REASONS, LOCALE_HISTORY_LIMIT_CAP, LOCALE_HISTORY_LIMIT_DEFAULT, LOCALE_HISTORY_MAX_OUTPUT_BYTES, LOCALE_HISTORY_TIMEOUT_MS, LOCALE_HISTORY_UNAVAILABLE_REASONS, LOCALE_VALUES_QUERY_MAX_LENGTH, LOCK_FILE_NAME, MACHINE_CLASS_ORIGINS, PAGE_CURSOR_MAX_LENGTH, PAGE_LIMIT_CAP, PAGE_LIMIT_DEFAULT, PROVENANCE_BUCKETS, PROVENANCE_FILE_NAME, PSEUDO_MODES, ProviderError, QA_SEVERITIES, REVIEW_REASON_CODES, RUN_COST_BASES, RUN_HISTORY_DEFAULT_LIMIT, RUN_HISTORY_MAX_LIMIT, RUN_HISTORY_UNAVAILABLE_REASONS, RUN_STATUS_UNAVAILABLE_REASONS, SDK_JSON_SCHEMAS, SdkError, applyValueReplace, approveEntries, approveEntry, approveLocale, assertMachineTranslationEnabled, assertTargetLocale, budgetStanding, check, checkFile, checkFileSummarySchema, checkSummarySchema, configCandidatePaths, createDefaultRegistry, createFlatFileAdapter, createLocalePathResolver, createTreeFileAdapter, createValueMarker, dataFlow, dataFlowManifestSchema, declareProviderKeyEnvVar, defineConfig, detectProject, diff, diffLocaleSnapshots, diffSummarySchema, doctor, doctorResultSchema, editConfiguredGlossaryTerm, editEntry, errorHint, exportTmx, exportTmxResultSchema, exportWorkbook, exportWorkbookResultSchema, extract, extractResultSchema, generateTypes, generateTypesResultSchema, glossaryDraftCheck, glossaryForLocale, glossaryHits, importTmx, importTmxResultSchema, importWorkbook, isCustomFormatId, isMachineTranslationEnabled, jsonSchemaUrl, keyContext, keyHistory, keyIntegrity, keyOriginSchema, keyProvenanceSchema, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, loadProvenance, localeGitDiff, localeGitStatus, localeHistory, localeIntegrity, localeSummarySchema, localeValues, localeValuesPage, localeWatchPaths, lockState, lockWaitEventSchema, nodeAdapterFs, normalizeGlossary, previewIcuMessage, previewValueReplace, progressEventSchema, projectRelativeMessage, provenanceReport, provenanceReportPage, provenanceReportResultSchema, provenanceSummarySchema, pseudolocalize, pseudolocalizeResultSchema, readCurrentGlossary, readGlossaryFile, readLocaleFileSnapshot, redact, redactGlossary, rejectEntries, rejectEntry, releaseHeldLocks, renderJsonSchemas, renderOutputJsonSchema, resolveDryRun, resolveProjectRoot, retranslateEntries, retranslateEntry, reviewQueue, runHistory, runHistoryResultSchema, runStatus, runSummarySchema, scaffoldingMetadata, setKeyLengthLimit, sharedGlossaryTranslations, tmxErrorLocation, translate, updateGlossaryTerm, verbatraConfigSchema, watch };
+export type { AdapterErrorCode, AdapterFs, AdapterResolution, AddedKey, ApplyValueReplaceInput, ApplyValueReplaceResult, ApproveLocaleDeps, ApproveLocaleInput, ApproveLocaleResult, AuthoringConfig, AuthoringConfigFor, BatchEntry, BatchEntryFailure, BatchEntrySkipped, BatchFinishedEvent, BillingUnit, BoundedBytesRead, BoundedFileRead, BoundedReadOutcome, BudgetBehavior, BudgetStanding, BuildWriteTree, ChangeDetectedEvent, CharacterRate, CharacterRunQuantity, CheckDeps, CheckFileDeps, CheckFileFinding, CheckFileInput, CheckFileRole, CheckFileSummary, CheckInput, CheckQaSummary, CheckReviewCode, CheckReviewSummary, CheckSensitiveSummary, CheckSummary, CompareBranchArms, ComparePlaceholders, ComputeInvalidIcuKeys, ConfigCandidateOptions, ConfigSource, CreateProvider, CreateProviderContext, CreateProviderHooks, CreateWatcher, CustomFormatId, DataFlowAgentSurface, DataFlowApiKey, DataFlowCounts, DataFlowDeps, DataFlowDestination, DataFlowField, DataFlowInput, DataFlowLocalFile, DataFlowLocale, DataFlowManifest, DataFlowNetwork, DataFlowOtherRequest, DataFlowProvider, DataFlowProviderKind, DataFlowSent, DataFlowVerdict, DeriveDescriptions, DeriveEntry, DetectProjectDeps, DetectProjectInput, DetectedFormat, DetectedFormatSource, DetectedLocaleLayout, DetectionAmbiguity, DetectionConfidence, DiffDeps, DiffInput, DiffSummary, DirectoryEntry, DoNotTranslateTerm, DoctorCheck, DoctorCheckId, DoctorCheckStatus, DoctorDeps, DoctorInput, DoctorResult, DuplicateKeyReport, EditConfiguredGlossaryTermInput, EditEntryActor, EditEntryDeps, EditEntryInput, EditEntryResult, EstimateCaveatCode, EstimateIdentity, EstimatePricing, ExchangeFormat, ExportTmxDeps, ExportTmxInput, ExportTmxLocaleCount, ExportTmxResult, ExportWorkbookDeps, ExportWorkbookInput, ExportWorkbookResult, ExtractDeps, ExtractInput, ExtractPlaceholders, ExtractResult, ExtractionConfig, FileQaReport, FlatFileAdapterOptions, FlatParseOutcome, FlatParseResult, FormatAdapter, FormatId, FuzzyCacheHit, GenerateTypesDeps, GenerateTypesInput, GenerateTypesResult, GitExecFile, GitExecFileResult, Glossary, GlossaryConfig, GlossaryDefinition, GlossaryDoNotTranslateDefinition, GlossaryDraftCheck, GlossaryDraftCheckInput, GlossaryDraftDoNotTranslateCheck, GlossaryDraftTermCheck, GlossaryFileDeps, GlossaryFileInput, GlossaryHitsInput, GlossaryInput, GlossaryProvenance, GlossaryTerm, GlossaryTermDefinition, HumanEditsPolicy, IcuPreviewAxis, IcuPreviewFailure, IcuPreviewInput, IcuPreviewResult, IcuPreviewRow, IcuSegment, IcuSegmentKind, IdleEvent, ImportTmxDeps, ImportTmxInput, ImportTmxLocaleResult, ImportTmxResult, ImportWorkbookDeps, ImportWorkbookInput, IncompletePlural, InconsistencyGroup, InconsistentTranslation, IntegrityGateReason, IntegrityRefusal, JsonLeaf, JsonRecord, JsonSchemaDocument, JsonSchemaObject, JsonTree, KeyConflict, KeyContext, KeyContextDeps, KeyContextGlossaryNotice, KeyContextInput, KeyHistoryDeps, KeyHistoryInput, KeyHistoryResult, KeyHistorySegment, KeyHistorySegmentKind, KeyHistoryTruncation, KeyIntegrityDeps, KeyIntegrityEntry, KeyIntegrityInput, KeyMode, KeyOrigin, KeyProvenance, KeyReviewState, KeyRevision, KeyValueDeps, KeyValueInput, KeyValuePair, KeyValueResult, KeyWorkingTreeValue, LanguageTableRefresh, LanguageTableRefreshStatus, LimitsFileNotice, LiteralFinding, LiteralScan, LiteralSuppressionReason, LoadConfigOptions, LoadLockFileDeps, LoadLockFileInput, LoadProvenanceDeps, LoadProvenanceInput, LoadedConfig, LocaleCapability, LocaleCapabilityReport, LocaleCapabilityWarning, LocaleCapabilityWarningCode, LocaleCheckSummary, LocaleDiff, LocaleEstimate, LocaleEstimateQuantity, LocaleFileCheck, LocaleFileSnapshot, LocaleFinishedEvent, LocaleGitDiffChange, LocaleGitDiffDeps, LocaleGitDiffEntry, LocaleGitDiffInput, LocaleGitDiffResult, LocaleGitDiffState, LocaleGitFile, LocaleGitFileState, LocaleGitRepositoryUnavailableReason, LocaleGitStatusDeps, LocaleGitStatusInput, LocaleGitStatusResult, LocaleGitUnavailableReason, LocaleGlossary, LocaleGlossaryTerm, LocaleHistoryCommit, LocaleHistoryDeps, LocaleHistoryInput, LocaleHistoryResult, LocaleHistoryUnavailableReason, LocaleIntegrityDeps, LocaleIntegrityInput, LocaleKeyIntegrity, LocaleNotice, LocalePathResolver, LocalePathResolverConfig, LocalePlannedEvent, LocaleQaReport, LocaleResource, LocaleReviewReport, LocaleSnapshotDelta, LocaleStartedEvent, LocaleStyle, LocaleSummary, LocaleSupport, LocaleValues, LocaleValuesDeps, LocaleValuesInput, LocaleValuesPage, LocaleValuesPageEntry, LocaleValuesPageInput, LocaleValuesPageLocale, LocaleWatchFiles, LocaleWatchGitPaths, LocaleWatchPathsDeps, LocaleWatchPathsInput, LocaleWatchPathsResult, LockFile, LockHolder, LockLocaleState, LockStateDeps, LockStateInput, LockStateResult, LockWaitEvent, LockWaitListener, MachineClassOrigin, MalformedRowReport, MaxLengthSource, MessageArgumentType, MessageArguments, ModelRate, NamedMessageArgument, NeedsReviewEntry, NetworkPolicy, NetworkRule, OrderedRecord, OrderedValue, PlaceholderComparator, PlaceholderExtractor, PlaceholderIntegrityResult, PluralCategories, PluralCategory, PluralCategoryLookup, PluralRuleType, PossiblyDynamicKey, PreviewValueReplaceInput, PricedLocaleEstimate, PricedRunEstimate, ProgressEvent, ProgressListener, ProjectDetection, ProtectedKey, ProtectionReason, ProvenanceBucket, ProvenanceFile, ProvenanceMarkers, ProvenanceOrigin, ProvenanceRecord, ProvenanceReport, ProvenanceReportDeps, ProvenanceReportEntry, ProvenanceReportInput, ProvenanceReportLocale, ProvenanceReportPage, ProvenanceReportPageInput, ProvenanceReportPageLocale, ProvenanceReportPageResult, ProvenanceReportResult, ProvenanceReviewState, ProvenanceSummary, ProviderBilling, ProviderConfig, ProviderErrorCode, ProviderId, ProviderKind, ProviderNetwork, ProviderNotice, ProviderNoticeCode, ProviderRetry, ProviderRetryEvent, ProviderRetryListener, PseudoMode, PseudolocalizeDeps, PseudolocalizeInput, PseudolocalizeResult, QaFinding, QaIntegrityFinding, QaReviewFinding, QaSeverity, QaSyntaxFinding, RateCard, ReadCurrentGlossaryInput, ReadLocaleFileSnapshotDeps, ReadLocaleFileSnapshotInput, ReadResult, RedactedGlossary, RepairEvent, ResolveOptions, RetranslateBatchOutcome, RetranslateEntriesInput, RetranslateEntriesResult, RetranslateEntryDeps, RetranslateEntryInput, RetranslateEntryResult, ReviewBatchEntry, ReviewBatchOutcome, ReviewDecisionDeps, ReviewDecisionInput, ReviewDecisionResult, ReviewEntriesInput, ReviewEntriesResult, ReviewFlag, ReviewQueueDeps, ReviewQueueEntry, ReviewQueueInput, ReviewQueueLocale, ReviewQueueResult, ReviewReasonCode, RunBudget, RunCostBasis, RunCostCaveat, RunEstimate, RunEstimateQuantity, RunFinishedEvent, RunHistoryCost, RunHistoryCoverage, RunHistoryDeps, RunHistoryInput, RunHistoryLocale, RunHistoryRecord, RunHistoryResult, RunHistoryTrigger, RunHistoryUnavailableReason, RunStatusDeps, RunStatusFile, RunStatusInput, RunStatusLocale, RunStatusResult, RunStatusUnavailableReason, RunSummary, RunTranslate, ScaffoldableProviderId, ScanDiagnostic, ScanDiagnosticReason, ScanProgressEvent, ScanProgressListener, SdkErrorCode, SdkFs, SdkNotice, SdkNoticeCode, SensitiveField, SensitiveFindingSource, SensitiveKeyFinding, SetKeyLengthLimitDeps, SetKeyLengthLimitInput, SetKeyLengthLimitResult, Sniff, SourceExtractor, SourceFramework, SourceLocaleCapability, SourceLocation, SplitRetryEvent, SubBatchProgressEvent, SuggestionStatus, SupportedFormat, SuppressedLiteral, SyntaxPosition, TmxErrorLocation, TmxLanguageReport, TmxOrigin, TmxRejectionCounts, TmxRejectionReason, TmxReview, TmxUnitRefusal, TokenRate, TokenRunQuantity, Tone, TranslateDeps, TranslateInput, TranslateRequest, TranslateResult, TranslationEntry, TranslationMemory, TranslationProvider, TreeFileAdapterOptions, UnpricedLocaleEstimate, UnpricedRunEstimate, UnresolvedArgumentReason, UnresolvedMessage, UnusedKey, UnusedKeysNotRun, UnusedKeysNotRunReason, UnusedKeysPrefixSite, UnusedKeysReport, UnusedKeysScan, UnusedKeysSite, UnusedKeysUnreliability, UnusedKeysUnreliableReason, UpdateGlossaryTermInput, Usage, UsageSummary, ValidateMessage, ValidateTree, ValueMarker, ValueReplaceDeps, ValueReplaceEntryRef, ValueReplaceLocaleFailure, ValueReplaceOutcome, ValueReplacePreview, ValueReplacePreviewEntry, ValueReplaceSkipReason, ValueReplaceStatus, VerbatraConfig, VerbatraConfigInput, WatchController, WatchDeps, WatchInput, WatchRunResult, Watcher, WriteContext, WritingEvent, XliffFormat };