@i18nprune/core 0.1.0

package/dist/modeResolve-cGVaY5Hh.d.ts

@@ -0,0 +1,25 @@
+import { L as LocaleMetadataReport, a as LocaleLeafMode } from './index-DLwTogCo.js';
+import { R as ResolveLocaleLeafModeInput } from './index-B_ow_Xvr.js';
+
+declare function metadataModeEnabledFromConfig(mode: LocaleLeafMode | undefined): boolean;
+/** Resolve final leaf mode with stable precedence: strip > metadata > config > legacy default. */
+declare function resolveLocaleLeafMode(input: ResolveLocaleLeafModeInput): {
+    mode: LocaleLeafMode;
+    conflict: boolean;
+    reason: 'strip_precedence' | 'explicit_metadata' | 'config_structured' | 'default_legacy';
+};
+/**
+ * Resolve locale leaf mode ({@link resolveLocaleLeafMode}) then {@link applyLocaleLeafMode}.
+ * Shared by **generate** (including **`generate --resume`**) immediately after translation passes.
+ */
+declare function applyLocaleLeafNormalization(input: {
+    localeJson: unknown;
+    sourceMap: Map<string, string>;
+    resolveInput: ResolveLocaleLeafModeInput;
+}): {
+    next: unknown;
+    report: LocaleMetadataReport;
+    modeDecision: ReturnType<typeof resolveLocaleLeafMode>;
+};
+
+export { applyLocaleLeafNormalization as a, metadataModeEnabledFromConfig as m, resolveLocaleLeafMode as r };

package/dist/path-Bfn3SAts.d.ts

@@ -0,0 +1,11 @@
+type RuntimePathPort = {
+    join: (...parts: string[]) => string;
+    dirname: (value: string) => string;
+    basename: (value: string, ext?: string) => string;
+    normalize: (value: string) => string;
+    relative: (from: string, to: string) => string;
+    resolve: (...parts: string[]) => string;
+    isAbsolute: (value: string) => boolean;
+};
+
+export type { RuntimePathPort as R };

package/dist/profile-BwOP9WKh.d.ts

@@ -0,0 +1,9 @@
+/** Named cache presets; resolved via {@link resolveCacheConfig}. */
+type CacheProfileId = 'safe' | 'balanced' | 'fast';
+type CacheProfileDefaults = {
+    rebuild: 'partial' | 'full';
+    fullRescanThresholdPercent: number;
+    mode: 'readWrite' | 'readOnly';
+};
+
+export type { CacheProfileId as C, CacheProfileDefaults as a };

package/dist/providers-0uMEfT6q.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Translation provider registry — **ids**, **descriptors** for clients (CLI help, doctor), and
+ * **resolved options** passed into {@link resolveTranslator} (secrets supplied by the client, never logged by core).
+ *
+ * **LLM backends:** resolved options carry **OpenAI-compatible** fields (`baseUrl`, `apiKey`, `model`); implementations follow later.
+ */
+/** Registered translation backends (`resolveTranslator` may not implement every id yet). */
+type TranslationProviderId = 'google' | 'mymemory' | 'deepl' | 'libre' | 'llm';
+type TranslationProviderKind = 'public_http' | 'api_key' | 'llm';
+/** Declares an env var for docs / CLI validation (names only — never values). */
+type TranslationProviderEnvVar = {
+    key: string;
+    description: string;
+    required: boolean;
+};
+/**
+ * Static metadata for **`--help`**, **`doctor`**, and programmatic discovery.
+ * Safe to serialize to JSON (no secrets).
+ */
+type TranslationProviderDescriptor = {
+    id: TranslationProviderId;
+    label: string;
+    kind: TranslationProviderKind;
+    /** Env vars this provider may read (documented for tooling — values are merged by CLI, not core). */
+    envVars: readonly TranslationProviderEnvVar[];
+    /** Optional notes for authoring **`translate.providers`** `{ id, … }` rows in **`i18nprune.config.*`**. */
+    configKeys?: readonly {
+        key: string;
+        description: string;
+        optional: boolean;
+    }[];
+};
+/**
+ * Optional execution hints from the **client** (CLI / host). Core may apply these for retries,
+ * pacing, or future AI rate limits — **never** store API tokens here.
+ */
+type TranslationClientHints = {
+    /** Override max attempts for transient failures (default from `translateLeaf` / provider). */
+    maxRetries?: number;
+    /** Minimum delay ms between outbound translation requests (future: AI rate limits). */
+    minDelayMs?: number;
+};
+type GoogleResolvedTranslationOptions = {
+    provider: 'google';
+    hints?: TranslationClientHints;
+};
+type MymemoryResolvedTranslationOptions = {
+    provider: 'mymemory';
+    /** Optional — raises MyMemory quota when set (per MyMemory docs). */
+    contactEmail?: string;
+    hints?: TranslationClientHints;
+};
+type LibreResolvedTranslationOptions = {
+    provider: 'libre';
+    /** LibreTranslate-compatible API origin (no trailing slash), e.g. `https://libretranslate.de`. */
+    baseUrl?: string;
+    hints?: TranslationClientHints;
+};
+type DeeplResolvedTranslationOptions = {
+    provider: 'deepl';
+    /** DeepL API token (provided by CLI from config/env — core must not log). */
+    apiKey?: string;
+    hints?: TranslationClientHints;
+};
+/**
+ * OpenAI-compatible HTTP API (`/v1/chat/completions`-style hosts).
+ * Resolved by CLI from the **`llm`** **`translate.providers`** row + `I18NPRUNE_TRANSLATE_LLM_*` env.
+ */
+type LlmResolvedTranslationOptions = {
+    provider: 'llm';
+    apiKey?: string;
+    /** Base URL including protocol, e.g. `https://api.openai.com/v1` or a proxy. */
+    baseUrl?: string;
+    model?: string;
+    hints?: TranslationClientHints;
+};
+/**
+ * Discriminated union — clients construct this from argv + env + config file; core only consumes.
+ */
+type ResolvedTranslationProviderOptions = GoogleResolvedTranslationOptions | MymemoryResolvedTranslationOptions | LibreResolvedTranslationOptions | DeeplResolvedTranslationOptions | LlmResolvedTranslationOptions;
+
+export type { DeeplResolvedTranslationOptions as D, GoogleResolvedTranslationOptions as G, LibreResolvedTranslationOptions as L, MymemoryResolvedTranslationOptions as M, ResolvedTranslationProviderOptions as R, TranslationProviderId as T, LlmResolvedTranslationOptions as a, TranslationClientHints as b, TranslationProviderDescriptor as c, TranslationProviderEnvVar as d, TranslationProviderKind as e };

package/dist/prune-c6hKZCv_.d.ts

@@ -0,0 +1,33 @@
+type MergeToTemplateOptions = {
+    /**
+     * Keep extra **object** keys present in `target` but not in `template` when their dotted path
+     * matches any prefix (uncertain / dynamic key protection). Array length extras are unchanged.
+     */
+    uncertainKeepPrefixes?: string[];
+    /** Source leaf paths that should keep target values but should not hydrate missing target paths. */
+    skipFillPaths?: readonly string[];
+    /** Target leaf paths that should be overwritten from the template source value. */
+    forceFillPaths?: readonly string[];
+};
+/**
+ * Merge `target` toward `template` shape: keep existing translations where paths match;
+ * fill missing from template (source strings); remove extras; preserve paths forced to source.
+ *
+ * Terminals follow the template type: plain string leaves preserve **whole** `{ value, … }` locale objects
+ * when the template leaf is a string (structured metadata is not flattened here — use strip flows when needed).
+ */
+declare function mergeToTemplateShape(template: unknown, target: unknown, preserve: unknown | undefined, options?: MergeToTemplateOptions): unknown;
+/** Apply preserve: set paths in `target` from `source` verbatim. */
+declare function applyPreserveFromSource(target: unknown, source: unknown, paths: string[]): unknown;
+
+type PruneToTemplateOptions = {
+    /** Keep extra object keys in `target` when their path matches (same semantics as merge). */
+    uncertainKeepPrefixes?: string[];
+};
+/**
+ * Remove keys from `target` that are not present in `template` (recursive object shape only).
+ * Optionally retains extra branches that match uncertain key prefixes (sync with dynamic keys).
+ */
+declare function pruneToTemplateShape(template: unknown, target: unknown, options?: PruneToTemplateOptions): unknown;
+
+export { type MergeToTemplateOptions as M, type PruneToTemplateOptions as P, applyPreserveFromSource as a, mergeToTemplateShape as m, pruneToTemplateShape as p };

package/dist/quality.d.ts

@@ -0,0 +1,36 @@
+import { Q as QualityFileLine, a as QualityJsonData, C as ComputeEnglishIdenticalCountsInput, b as QualityRunOptions, c as QualityHostHooks, d as QualityRunResult } from './index-DVT26v11.js';
+import { C as CoreContext } from './coreContext-DMaWLvmB.js';
+import './index-X50E1FIX.js';
+import './index-BQuLEQ9b.js';
+import './root-2-kCaBvQ.js';
+import 'zod';
+import './path-Bfn3SAts.js';
+import './fs-BUYD8ZhA.js';
+import './providers-0uMEfT6q.js';
+import './index-BgG01AKL.js';
+import './capabilities-x74cD2Hu.js';
+import './adapters-gp1lXp0T.js';
+
+declare function buildQualityJsonData(input: {
+    total: number;
+    perFile: Record<string, number>;
+    dynamicKeySites: number;
+    sourceLocale: string;
+    localesDir: string;
+    localeCount: number;
+    targetLocaleCount: number;
+    files: QualityFileLine[];
+}): QualityJsonData;
+
+/**
+ * Count target locale leaves whose string value equals the source locale at the same path,
+ * after applying parity exclusions (same rules as the quality operation).
+ */
+declare function computeEnglishIdenticalCounts(input: ComputeEnglishIdenticalCountsInput): {
+    total: number;
+    perFile: Record<string, number>;
+};
+
+declare function runQuality(ctx: CoreContext, opts: QualityRunOptions, host: QualityHostHooks): QualityRunResult;
+
+export { QualityFileLine, QualityHostHooks, QualityJsonData, QualityRunOptions, QualityRunResult, buildQualityJsonData, computeEnglishIdenticalCounts, runQuality };