@lingo.dev/cli 1.0.0 → 1.0.1

package/dist/update-C-JdpZwG.js

@@ -1,816 +0,0 @@
-import { createRequire } from "node:module";
-import { Context, Data, Effect, Layer } from "effect";
-import * as fs$1 from "node:fs/promises";
-import * as path from "node:path";
-import { buildIcuPlural, buildIcuSelect, computeKey, getActiveEntries, getActiveEntries as getActiveEntries$1, readLocaleFile as readLocaleFile$1 } from "@lingo.dev/spec";
-import { parse } from "@babel/parser";
-import _traverse from "@babel/traverse";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as cp from "node:child_process";
-import * as ci from "ci-info";
-import semver from "semver";
-//#region src/services/fs.ts
-/**
-* Shared filesystem utilities for CLI commands.
-*/
-/**
-* Reads a file, returning null if it doesn't exist.
-* Rethrows non-ENOENT errors (permission denied, I/O errors, etc.)
-*/
-async function tryReadFile(filePath) {
-	try {
-		return await fs$1.readFile(filePath, "utf-8");
-	} catch (e) {
-		if (e?.code === "ENOENT") return null;
-		throw e;
-	}
-}
-/**
-* Recursively finds .ts/.tsx source files, skipping node_modules, dotfiles, and .d.ts.
-*/
-async function findSourceFiles(dir) {
-	const files = [];
-	async function walk(d) {
-		let entries;
-		try {
-			entries = await fs$1.readdir(d, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-			const fullPath = path.join(d, entry.name);
-			if (entry.isDirectory()) await walk(fullPath);
-			else if (/\.(ts|tsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) files.push(fullPath);
-		}
-	}
-	await walk(dir);
-	return files.sort();
-}
-/**
-* Lists locale codes from .jsonc files in a directory, excluding the source locale.
-*/
-async function discoverLocales(outDir, sourceLocale) {
-	let files;
-	try {
-		files = await fs$1.readdir(outDir);
-	} catch {
-		return [];
-	}
-	return files.filter((f) => f.endsWith(".jsonc") && f !== `${sourceLocale}.jsonc`).map((f) => f.replace(/\.jsonc$/, "")).sort();
-}
-//#endregion
-//#region src/services/jsonc.ts
-function formatComment(metadata) {
-	const lines = [];
-	if (metadata.context) lines.push(` * @context ${metadata.context}`);
-	if (metadata.src) lines.push(` * @src ${metadata.src}`);
-	if (metadata.orphan) lines.push(` * @orphan`);
-	if (lines.length === 0) return "";
-	return `  /*\n  ${lines.join("\n  ")}\n   */`;
-}
-/**
-* Generates a JSONC string from locale entries with metadata comments.
-* Entries are sorted by key for deterministic output.
-*/
-function writeLocaleFile(file) {
-	const sorted = [...file.entries].sort((a, b) => a.key.localeCompare(b.key));
-	if (sorted.length === 0) return "{}\n";
-	const parts = ["{"];
-	for (let i = 0; i < sorted.length; i++) {
-		const entry = sorted[i];
-		const comment = formatComment(entry.metadata);
-		if (comment) parts.push(comment);
-		const escapedValue = JSON.stringify(entry.value);
-		const comma = i < sorted.length - 1 ? "," : "";
-		parts.push(`  "${entry.key}": ${escapedValue}${comma}`);
-		if (i < sorted.length - 1) parts.push("");
-	}
-	parts.push("}\n");
-	return parts.join("\n");
-}
-/**
-* Merges newly extracted entries into an existing locale file.
-* - Preserves existing translations (values not overwritten)
-* - Updates metadata (context, src) from fresh extraction
-* - Marks keys present in existing but absent from extracted as @orphan
-* - Adds new keys from extraction
-*/
-function mergeEntries(existing, extracted) {
-	const extractedByKey = new Map(extracted.map((e) => [e.key, e]));
-	const existingByKey = new Map(existing.entries.map((e) => [e.key, e]));
-	const merged = [];
-	for (const entry of existing.entries) {
-		const fresh = extractedByKey.get(entry.key);
-		if (fresh) {
-			const metadata = { ...fresh.metadata };
-			delete metadata.orphan;
-			merged.push({
-				key: entry.key,
-				value: entry.value,
-				metadata
-			});
-		} else merged.push({
-			key: entry.key,
-			value: entry.value,
-			metadata: {
-				...entry.metadata,
-				orphan: true
-			}
-		});
-	}
-	for (const entry of extracted) if (!existingByKey.has(entry.key)) merged.push(entry);
-	return { entries: merged };
-}
-//#endregion
-//#region src/services/extractor.ts
-/**
-* AST-based extraction of translatable strings from TypeScript/TSX source files.
-* Uses Babel to parse and traverse, extracting l.text(), l.jsx(), l.plural(),
-* and l.select() calls with source text, context, and source location.
-*
-* Scope rules:
-* - Tracks variables assigned from useLingo() or createLingo()
-* - Always matches `l` as a heuristic fallback (convention: `const l = useLingo()`)
-* - Ignores calls on any other objects (no false positives from document.text(), etc.)
-* - Warns on destructured usage: `const { text } = useLingo()`
-*/
-const traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
-/** Methods where the first arg is the source string */
-const TEXT_METHODS = new Set(["text", "jsx"]);
-/** Methods where the second arg is a forms object that becomes the ICU source */
-const FORMS_METHODS = new Set(["plural", "select"]);
-const ALL_METHODS = new Set([...TEXT_METHODS, ...FORMS_METHODS]);
-/** Functions that return a Lingo object */
-const LINGO_FACTORIES = new Set(["useLingo", "createLingo"]);
-function getLingoMethodName(node, lingoVars) {
-	const callee = node.callee;
-	if (callee.type !== "MemberExpression") return null;
-	if (callee.object.type !== "Identifier" || !lingoVars.has(callee.object.name)) return null;
-	if (callee.property.type !== "Identifier") return null;
-	const name = callee.property.name;
-	return ALL_METHODS.has(name) ? name : null;
-}
-function extractStaticString(node) {
-	if (node.type === "StringLiteral") return node.value;
-	if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
-	return null;
-}
-function extractContextFromOptions(node) {
-	if (!node || node.type !== "ObjectExpression") return void 0;
-	for (const prop of node.properties) if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "context" && (prop.value.type === "StringLiteral" || prop.value.type === "TemplateLiteral")) return extractStaticString(prop.value) ?? void 0;
-}
-function extractFormsObject(node) {
-	if (node.type !== "ObjectExpression") return null;
-	const forms = {};
-	for (const prop of node.properties) {
-		if (prop.type !== "ObjectProperty") return null;
-		const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "StringLiteral" ? prop.key.value : null;
-		if (key === null) return null;
-		const value = extractStaticString(prop.value);
-		if (value === null) return null;
-		forms[key] = value;
-	}
-	return forms;
-}
-function formatSrc(filePath, line) {
-	return line ? `${filePath}:${line}` : filePath;
-}
-/**
-* Extracts translatable messages from a single source file's code string.
-* Pure function - no filesystem access.
-*/
-function extractMessages(code, filePath) {
-	const ast = parse(code, {
-		sourceType: "module",
-		plugins: ["typescript", "jsx"],
-		errorRecovery: true
-	});
-	const messages = [];
-	const warnings = [];
-	const lingoVars = new Set(["l"]);
-	traverse(ast, {
-		VariableDeclarator(path) {
-			const init = path.node.init;
-			if (!init || init.type !== "CallExpression") return;
-			const callee = init.callee;
-			if (callee.type !== "Identifier" || !LINGO_FACTORIES.has(callee.name)) return;
-			if (path.node.id.type === "Identifier") lingoVars.add(path.node.id.name);
-			else if (path.node.id.type === "ObjectPattern") {
-				const src = formatSrc(filePath, path.node.loc?.start.line);
-				warnings.push({
-					src,
-					message: "Destructured usage of useLingo() cannot be statically extracted. Use `const l = useLingo()` instead."
-				});
-			}
-		},
-		CallExpression(path) {
-			const methodName = getLingoMethodName(path.node, lingoVars);
-			if (!methodName) return;
-			const src = formatSrc(filePath, path.node.loc?.start.line);
-			if (TEXT_METHODS.has(methodName)) {
-				const firstArg = path.node.arguments[0];
-				if (!firstArg) return;
-				const source = extractStaticString(firstArg);
-				if (source === null) {
-					warnings.push({
-						src,
-						message: `Dynamic expression in l.${methodName}() cannot be statically extracted`
-					});
-					return;
-				}
-				const context = extractContextFromOptions(path.node.arguments[1]);
-				if (!context) warnings.push({
-					src,
-					message: `Missing context in l.${methodName}(). Provide { context: "..." } for type safety and better translations.`
-				});
-				messages.push({
-					key: computeKey(source, context),
-					source,
-					context,
-					src
-				});
-			} else {
-				const formsArg = path.node.arguments[1];
-				if (!formsArg) return;
-				const forms = extractFormsObject(formsArg);
-				if (forms === null) {
-					warnings.push({
-						src,
-						message: `Dynamic forms in l.${methodName}() cannot be statically extracted`
-					});
-					return;
-				}
-				const source = methodName === "plural" ? buildIcuPlural(forms) : buildIcuSelect(forms);
-				const context = extractContextFromOptions(path.node.arguments[2]);
-				if (!context) warnings.push({
-					src,
-					message: `Missing context in l.${methodName}(). Provide { context: "..." } as third argument.`
-				});
-				messages.push({
-					key: computeKey(source, context),
-					source,
-					context,
-					src
-				});
-			}
-		}
-	});
-	return {
-		messages,
-		warnings
-	};
-}
-/**
-* Detects hash collisions: different (source, context) pairs that produce the same key.
-* Same source + same context appearing in multiple files is NOT a collision.
-* Call this after extracting all messages from a project, before writing locale files.
-*/
-function detectCollisions(messages) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const msg of messages) {
-		const group = byKey.get(msg.key);
-		if (group) group.push(msg);
-		else byKey.set(msg.key, [msg]);
-	}
-	const collisions = [];
-	for (const [key, entries] of byKey) {
-		const unique = /* @__PURE__ */ new Map();
-		for (const e of entries) {
-			const identity = `${e.source}\0${e.context ?? ""}`;
-			if (!unique.has(identity)) unique.set(identity, e);
-		}
-		if (unique.size <= 1) continue;
-		collisions.push({
-			key,
-			entries: [...unique.values()].map((e) => ({
-				source: e.source,
-				context: e.context,
-				src: e.src
-			}))
-		});
-	}
-	return collisions;
-}
-//#endregion
-//#region src/services/pipeline.ts
-/**
-* Extraction pipeline orchestration.
-* Runs AST extraction across source files, detects collisions,
-* and produces structured results for JSONC writing and type generation.
-*/
-/**
-* Runs the extraction pipeline across multiple source files.
-* Pure function - takes source code strings, returns structured results.
-*
-* The caller is responsible for:
-* - Reading source files from disk
-* - Writing JSONC/JSON output
-* - Displaying warnings and errors
-*/
-function runExtractionPipeline(sourceFiles) {
-	const messages = [];
-	const warnings = [];
-	for (const { code, filePath } of sourceFiles) {
-		const result = extractMessages(code, filePath);
-		messages.push(...result.messages);
-		warnings.push(...result.warnings);
-	}
-	return {
-		messages,
-		warnings,
-		collisions: detectCollisions(messages)
-	};
-}
-/**
-* Converts extracted messages to locale entries for JSONC writing.
-* Deduplicates by key (same message in multiple files produces one entry).
-*/
-function toLocaleEntries(messages) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const msg of messages) {
-		if (byKey.has(msg.key)) continue;
-		byKey.set(msg.key, {
-			key: msg.key,
-			value: msg.source,
-			metadata: {
-				...msg.context ? { context: msg.context } : {},
-				src: msg.src
-			}
-		});
-	}
-	return [...byKey.values()];
-}
-//#endregion
-//#region src/services/typegen.ts
-function icuTypeToTsType(icuType) {
-	switch (icuType) {
-		case "plural":
-		case "selectordinal":
-		case "number": return "number";
-		case "date":
-		case "time": return "Date | number";
-		case "select": return "string";
-		default: return "string | number";
-	}
-}
-/**
-* Extracts top-level ICU placeholders from a template string.
-* Handles nested braces (plural/select alternatives) and ICU quote escaping.
-*
-* Examples:
-* - "{name}" → [{ name: "name", tsType: "string | number" }]
-* - "{count, plural, one {# item} other {# items}}" → [{ name: "count", tsType: "number" }]
-*/
-function extractPlaceholders(template) {
-	const placeholders = /* @__PURE__ */ new Map();
-	let depth = 0;
-	let start = -1;
-	for (let i = 0; i < template.length; i++) {
-		const ch = template[i];
-		if (ch === "'") {
-			const end = template.indexOf("'", i + 1);
-			if (end > i) i = end;
-			continue;
-		}
-		if (ch === "{") {
-			if (depth === 0) start = i;
-			depth++;
-		} else if (ch === "}") {
-			depth--;
-			if (depth === 0 && start >= 0) {
-				const content = template.slice(start + 1, i);
-				const commaIdx = content.indexOf(",");
-				const name = (commaIdx >= 0 ? content.slice(0, commaIdx) : content).trim();
-				const icuType = commaIdx >= 0 ? content.slice(commaIdx + 1).trim().split(/[\s,]/)[0] : void 0;
-				if (name && /^\w+$/.test(name) && !placeholders.has(name)) placeholders.set(name, {
-					name,
-					tsType: icuTypeToTsType(icuType)
-				});
-				start = -1;
-			}
-		}
-	}
-	return [...placeholders.values()];
-}
-function escapeForTs(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
-}
-/**
-* Generates a TypeScript declaration file from a source locale file.
-* The output augments @lingo.dev/react's LingoMessages interface via
-* `declare module` so that l.text() and l.jsx() get:
-*
-* 1. Autocomplete on source strings
-* 2. Compile errors for typos
-* 3. Required values validation per message
-* 4. Required context enforcement with exact union narrowing
-*
-* Entries without context are skipped - they fail `lingo check` instead.
-* Output is deterministic (same input = same output, safe to commit).
-*/
-function generateTypes(file) {
-	const sources = /* @__PURE__ */ new Map();
-	for (const entry of file.entries) {
-		if (entry.metadata.orphan) continue;
-		const existing = sources.get(entry.value);
-		if (!existing) sources.set(entry.value, {
-			placeholders: extractPlaceholders(entry.value),
-			contexts: new Set(entry.metadata.context ? [entry.metadata.context] : [])
-		});
-		else if (entry.metadata.context) existing.contexts.add(entry.metadata.context);
-	}
-	const sorted = [...sources.entries()].filter(([, data]) => data.contexts.size > 0).sort(([a], [b]) => a.localeCompare(b));
-	const lines = [
-		"// Generated by lingo - do not edit",
-		"export {};",
-		"",
-		"declare module \"@lingo.dev/react\" {",
-		"  interface LingoMessages {"
-	];
-	for (const [source, { placeholders, contexts }] of sorted) {
-		const escaped = escapeForTs(source);
-		const contextUnion = [...contexts].sort().map((c) => `"${escapeForTs(c)}"`).join(" | ");
-		const fields = [];
-		if (placeholders.length > 0) {
-			const valueFields = placeholders.map((p) => `${p.name}: ${p.tsType}`).join("; ");
-			fields.push(`values: { ${valueFields} }`);
-		}
-		fields.push(`context: ${contextUnion}`);
-		lines.push(`    "${escaped}": { ${fields.join("; ")} };`);
-	}
-	lines.push("  }");
-	lines.push("}");
-	lines.push("");
-	return lines.join("\n");
-}
-//#endregion
-//#region src/services/localize.ts
-/**
-* Localization planning: diffs source locale against target locales
-* to find missing translations, and converts between JSONC entries
-* and the processing API's data format.
-*/
-/**
-* Computes what needs to be localized: source entries that don't exist
-* in the target file. Orphaned entries are excluded from both sides.
-*/
-function planLocalization(sourceFile, targetFile, targetLocale) {
-	const targetKeys = new Set(getActiveEntries(targetFile.entries).map((e) => e.key));
-	return {
-		targetLocale,
-		missing: getActiveEntries(sourceFile.entries).filter((e) => !targetKeys.has(e.key)),
-		existing: getActiveEntries(targetFile.entries).length
-	};
-}
-/**
-* Converts locale entries to the processing API's data + hints format.
-* Hints include @context and @src metadata for translation quality.
-*/
-function toApiPayload(entries) {
-	const data = {};
-	const hints = {};
-	for (const entry of entries) {
-		data[entry.key] = entry.value;
-		const h = [];
-		if (entry.metadata.context) h.push(`context: ${entry.metadata.context}`);
-		if (entry.metadata.src) h.push(`src: ${entry.metadata.src}`);
-		if (h.length > 0) hints[entry.key] = h;
-	}
-	return {
-		data,
-		hints
-	};
-}
-/**
-* Merges API response translations into locale entries,
-* preserving source metadata (context, src) on the new entries.
-*/
-function applyTranslations(missing, translated) {
-	return missing.map((entry) => ({
-		key: entry.key,
-		value: translated[entry.key] ?? entry.value,
-		metadata: { ...entry.metadata }
-	}));
-}
-//#endregion
-//#region src/services/status.ts
-/**
-* Translation completeness reporting.
-* Compares target locale files against the source locale to compute
-* per-locale stats: total, translated, missing, orphaned.
-*/
-/**
-* Computes translation completeness for a single target locale
-* by comparing its keys against the source locale.
-*/
-function computeLocaleStatus(sourceFile, targetFile, locale) {
-	const sourceKeys = new Set(getActiveEntries(sourceFile.entries).map((e) => e.key));
-	const targetKeys = new Set(getActiveEntries(targetFile.entries).map((e) => e.key));
-	const total = sourceKeys.size;
-	const translated = [...sourceKeys].filter((k) => targetKeys.has(k)).length;
-	return {
-		locale,
-		total,
-		translated,
-		missing: total - translated,
-		orphaned: targetFile.entries.filter((e) => e.metadata.orphan).length
-	};
-}
-/**
-* Computes completeness for the source locale itself
-* (always 100% translated, but may have orphans).
-*/
-function computeSourceStatus(sourceFile, locale) {
-	const active = getActiveEntries(sourceFile.entries);
-	const orphaned = sourceFile.entries.length - active.length;
-	return {
-		locale,
-		total: active.length,
-		translated: active.length,
-		missing: 0,
-		orphaned
-	};
-}
-/**
-* Formats a status report as a human-readable table.
-*/
-function formatStatusTable(statuses) {
-	return [
-		"Locale   Total   Translated   Missing   Orphaned",
-		"-".repeat(48),
-		...statuses.map((s) => `${s.locale.padEnd(9)}${String(s.total).padEnd(8)}${String(s.translated).padEnd(13)}${String(s.missing).padEnd(10)}${s.orphaned}`)
-	].join("\n");
-}
-//#endregion
-//#region src/services/check.ts
-/**
-* Extracts missing-context issues from extraction warnings.
-*/
-function checkMissingContext(warnings) {
-	return warnings.filter((w) => w.message.includes("Missing context")).map((w) => ({
-		type: "missing-context",
-		src: w.src,
-		message: w.message
-	}));
-}
-/**
-* Compares generated JSONC/types with existing files on disk.
-*/
-function checkStaleness(generatedJsonc, existingJsonc, generatedTypes, existingTypes) {
-	const issues = [];
-	if (generatedJsonc !== existingJsonc) issues.push({
-		type: "stale-jsonc",
-		message: "Source locale file is stale. Run `lingo extract` to update."
-	});
-	if (generatedTypes !== existingTypes) issues.push({
-		type: "stale-types",
-		message: "lingo.d.ts is stale. Run `lingo extract` to update."
-	});
-	return issues;
-}
-/**
-* Checks target locale files for missing translations.
-*/
-function checkTranslations(sourceFile, targetFiles) {
-	const issues = [];
-	const activeSourceKeys = new Set(sourceFile.entries.filter((e) => !e.metadata.orphan).map((e) => e.key));
-	for (const { locale, file } of targetFiles) {
-		const translatedKeys = new Set(file.entries.filter((e) => !e.metadata.orphan && e.value).map((e) => e.key));
-		const missing = [...activeSourceKeys].filter((k) => !translatedKeys.has(k));
-		if (missing.length > 0) issues.push({
-			type: "missing-translation",
-			message: `${locale}: ${missing.length}/${activeSourceKeys.size} messages missing`
-		});
-	}
-	return issues;
-}
-/**
-* Counts orphaned entries in the source locale file.
-*/
-function checkOrphaned(sourceFile) {
-	const orphaned = sourceFile.entries.filter((e) => e.metadata.orphan);
-	if (orphaned.length === 0) return [];
-	return [{
-		type: "orphaned",
-		message: `${orphaned.length} orphaned entries in source locale. Run \`lingo extract\` to mark, \`lingo cleanup\` to remove.`
-	}];
-}
-/**
-* Runs all checks and returns a unified result.
-*/
-function runChecks(params) {
-	const contextIssues = checkMissingContext(params.warnings);
-	const stalenessIssues = checkStaleness(params.generatedJsonc, params.existingJsonc, params.generatedTypes, params.existingTypes);
-	const translationIssues = checkTranslations(params.sourceFile, params.targetFiles);
-	const orphanIssues = checkOrphaned(params.sourceFile);
-	return {
-		issues: [
-			...contextIssues,
-			...stalenessIssues,
-			...translationIssues,
-			...orphanIssues
-		],
-		stats: {
-			messages: params.messageCount,
-			locales: params.targetFiles.length + 1,
-			missingContext: contextIssues.length,
-			missingTranslations: translationIssues.reduce((sum, i) => {
-				const match = i.message.match(/(\d+)\//);
-				return sum + (match ? parseInt(match[1]) : 0);
-			}, 0),
-			orphaned: params.sourceFile.entries.filter((e) => e.metadata.orphan).length,
-			staleJsonc: stalenessIssues.some((i) => i.type === "stale-jsonc"),
-			staleTypes: stalenessIssues.some((i) => i.type === "stale-types")
-		}
-	};
-}
-/**
-* Formats check results for human-readable CLI output.
-*/
-function formatCheckResult(result) {
-	const lines = [];
-	if (result.issues.length === 0) {
-		lines.push(`  All checks passed. ${result.stats.messages} messages, ${result.stats.locales} locale(s).`);
-		return lines.join("\n");
-	}
-	for (const issue of result.issues) {
-		const prefix = issue.src ? `${issue.src} - ` : "";
-		lines.push(`  ${prefix}${issue.message}`);
-	}
-	lines.push("");
-	lines.push(`  ${result.issues.length} issue(s) found.`);
-	return lines.join("\n");
-}
-const VERSION = createRequire(import.meta.url)("../package.json").version;
-//#endregion
-//#region src/services/update.ts
-var UpdateError = class extends Data.TaggedError("UpdateError") {};
-var UpdateService = class extends Context.Tag("UpdateService")() {};
-function detectInstallMethod() {
-	if (process.env.npm_lifecycle_event === "npx" || process.env.npm_execpath?.includes("npx") || process.env.npm_execpath?.includes("dlx")) return { type: "npx" };
-	const dir = typeof __dirname !== "undefined" ? __dirname : path.dirname(new URL(import.meta.url).pathname);
-	if (dir.includes(".bun/install/global")) return { type: "bun-global" };
-	if (dir.includes("pnpm/global") || dir.includes(".pnpm-global")) return { type: "pnpm-global" };
-	if (dir.includes(".config/yarn/global") || dir.includes("/yarn/global/")) return { type: "yarn-global" };
-	if (dir.includes("/lib/node_modules/")) return { type: "npm-global" };
-	const pm = detectLocalPm();
-	if (pm) return {
-		type: "local",
-		pm
-	};
-	return { type: "unknown" };
-}
-function detectLocalPm() {
-	const lockfiles = [
-		["pnpm-lock.yaml", "pnpm"],
-		["bun.lockb", "bun"],
-		["bun.lock", "bun"],
-		["yarn.lock", "yarn"],
-		["package-lock.json", "npm"]
-	];
-	let dir = process.cwd();
-	while (true) {
-		for (const [file, pm] of lockfiles) try {
-			fs.accessSync(path.join(dir, file));
-			return pm;
-		} catch {}
-		const parent = path.dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-}
-function compareVersions(current, latest) {
-	if (!semver.gt(latest, current)) return null;
-	return {
-		current,
-		latest,
-		isMajor: semver.major(latest) > semver.major(current)
-	};
-}
-const PACKAGE_NAME = "@lingo.dev/cli";
-const CHECK_INTERVAL_MS = 1440 * 60 * 1e3;
-const CHECK_TIMEOUT_MS = 3e3;
-function cacheFile() {
-	return path.join(os.homedir(), ".lingo", "update-check.json");
-}
-function readCache() {
-	try {
-		return JSON.parse(fs.readFileSync(cacheFile(), "utf-8"));
-	} catch {
-		return null;
-	}
-}
-function writeCache(cache) {
-	try {
-		const dir = path.join(os.homedir(), ".lingo");
-		fs.mkdirSync(dir, { recursive: true });
-		fs.writeFileSync(cacheFile(), JSON.stringify(cache));
-	} catch {}
-}
-function shouldSkipCheck() {
-	if (ci.isCI) return true;
-	if (process.env.NO_UPDATE_NOTIFIER === "1") return true;
-	if (process.env.LINGO_DISABLE_UPDATE_CHECK === "1") return true;
-	return false;
-}
-function fetchLatestVersion() {
-	return Effect.catchAll(Effect.tryPromise({
-		try: async () => {
-			const controller = new AbortController();
-			const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-			try {
-				const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
-					headers: { Accept: "application/json" },
-					signal: controller.signal
-				});
-				if (!res.ok) return null;
-				return (await res.json()).version ?? null;
-			} finally {
-				clearTimeout(timeout);
-			}
-		},
-		catch: (e) => e
-	}), () => Effect.succeed(null));
-}
-function checkForUpdate() {
-	return Effect.gen(function* () {
-		if (shouldSkipCheck()) return null;
-		const cached = readCache();
-		if (cached && Date.now() - cached.lastCheck < CHECK_INTERVAL_MS) return compareVersions(VERSION, cached.latest);
-		const latest = yield* fetchLatestVersion();
-		if (!latest) return cached ? compareVersions(VERSION, cached.latest) : null;
-		writeCache({
-			lastCheck: Date.now(),
-			latest
-		});
-		return compareVersions(VERSION, latest);
-	});
-}
-function generateUpdateCommand(method, version) {
-	const pkg = version ? `${PACKAGE_NAME}@${version}` : `${PACKAGE_NAME}@latest`;
-	switch (method.type) {
-		case "npm-global": return [
-			"npm",
-			"install",
-			"-g",
-			pkg
-		];
-		case "pnpm-global": return [
-			"pnpm",
-			"add",
-			"-g",
-			pkg
-		];
-		case "bun-global": return [
-			"bun",
-			"add",
-			"-g",
-			pkg
-		];
-		case "yarn-global": return [
-			"yarn",
-			"global",
-			"add",
-			pkg
-		];
-		case "local": {
-			const addCmd = method.pm === "yarn" ? "add" : method.pm === "npm" ? "install" : "add";
-			const devFlag = method.pm === "npm" ? "--save-dev" : "-D";
-			return [
-				method.pm,
-				addCmd,
-				devFlag,
-				pkg
-			];
-		}
-		case "npx":
-		case "unknown": return null;
-	}
-}
-function executeUpdate(method, version) {
-	const command = generateUpdateCommand(method, version);
-	if (!command) return Effect.fail(new UpdateError({ message: method.type === "npx" ? `Running via npx. Use: npx ${PACKAGE_NAME}@latest` : `Could not detect package manager. Update manually:\n  npm i -g ${PACKAGE_NAME}@latest\n  pnpm add -g ${PACKAGE_NAME}@latest\n  bun add -g ${PACKAGE_NAME}@latest` }));
-	return Effect.tryPromise({
-		try: () => new Promise((resolve, reject) => {
-			const child = cp.spawn(command[0], command.slice(1), {
-				stdio: "inherit",
-				shell: process.platform === "win32"
-			});
-			child.on("close", (code) => {
-				if (code === 0) resolve();
-				else reject(/* @__PURE__ */ new Error(`Process exited with code ${code}`));
-			});
-			child.on("error", reject);
-		}),
-		catch: (e) => new UpdateError({ message: `Update failed: ${e instanceof Error ? e.message : String(e)}` })
-	});
-}
-const UpdateServiceLive = Layer.succeed(UpdateService, {
-	check: checkForUpdate(),
-	execute: (version) => executeUpdate(detectInstallMethod(), version),
-	installMethod: detectInstallMethod()
-});
-//#endregion
-export { discoverLocales as C, writeLocaleFile as S, tryReadFile as T, runExtractionPipeline as _, detectInstallMethod as a, mergeEntries as b, formatCheckResult as c, computeSourceStatus as d, formatStatusTable as f, generateTypes as g, toApiPayload as h, compareVersions as i, runChecks as l, planLocalization as m, UpdateService as n, generateUpdateCommand as o, applyTranslations as p, UpdateServiceLive as r, VERSION as s, UpdateError as t, computeLocaleStatus as u, toLocaleEntries as v, findSourceFiles as w, readLocaleFile$1 as x, getActiveEntries$1 as y };