@fluid-app/fluid-cli-localization 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3965 @@
+import { NAV_HELP, assertInteractive, createDomainCommand, terminalPrompter } from "@fluid-app/fluid-cli";
+import prompts from "prompts";
+import { readFileSync } from "node:fs";
+//#region src/shared/errors.ts
+/** A failure the user can act on, printed as a JSON `error` on stderr. */
+var LocalizationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LocalizationError";
+	}
+};
+//#endregion
+//#region src/shared/agreements.ts
+const MAX_AGREEMENT_PAGES = 50;
+/** GET /api/agreements, every page. Refuses rather than returning a partial
+*  list, which would make an existing agreement look missing. */
+async function listAgreements(client) {
+	const all = [];
+	for (let page = 1;; page++) {
+		const body = await client.get("/api/agreements", {
+			page,
+			per_page: 100
+		});
+		all.push(...body.agreements ?? []);
+		const totalPages = body.meta?.pagination?.total_pages ?? 1;
+		if (page >= totalPages) break;
+		if (page >= MAX_AGREEMENT_PAGES) throw new LocalizationError(`The company has more than ${MAX_AGREEMENT_PAGES * 100} agreements, too many to match by title. Check the agreements in Settings > Agreements.`);
+	}
+	return all;
+}
+/** GET /api/agreements/:id, in `lang` when given. */
+async function readAgreement(client, id, lang) {
+	const wire = (await client.get(`/api/agreements/${id}`, lang ? { language_iso: lang } : void 0)).agreement ?? {};
+	return {
+		id,
+		title: wire.title ?? "",
+		description: wire.description ?? "",
+		languageIso: wire.language_iso ?? null,
+		active: wire.active ?? null
+	};
+}
+/**
+* Whether an agreement has a translation in `iso`. A read in a language
+* with no translation falls back to the default text and says so in
+* `language_iso`, which is how fluid-admin's translation sheet tells them
+* apart. The title falls back silently, so it can't be compared.
+*/
+async function agreementTranslated(client, id, iso) {
+	return ((await readAgreement(client, id, iso)).languageIso ?? "").toLowerCase() === iso.toLowerCase();
+}
+/**
+* Save one language's title and text. The API needs both, non-empty. Only
+* these are sent, so the agreement's checkout settings and countries stay
+* as they are.
+*/
+async function writeAgreementTranslation(client, id, lang, text) {
+	if (text.title.trim().length === 0 || text.description.trim().length === 0) throw new LocalizationError("An agreement translation needs both a title and a description.");
+	await client.put(`/api/agreements/${id}?language_iso=${encodeURIComponent(lang)}`, { agreement: {
+		title: text.title,
+		description: text.description
+	} });
+}
+//#endregion
+//#region src/shared/cli.ts
+/**
+* Changes to live configuration or content need an explicit yes. Scripts and
+* agents pass `--yes`; an interactive terminal is asked. With neither,
+* nothing runs.
+*/
+async function confirmChange(question, yes, interactive = Boolean(process.stdin.isTTY)) {
+	if (yes) return;
+	if (!interactive) throw new LocalizationError(`${question} Pass --yes to confirm.`);
+	if (!(await prompts({
+		type: "confirm",
+		name: "ok",
+		message: question,
+		initial: false
+	})).ok) throw new LocalizationError("Cancelled.");
+}
+/**
+* The API's error message. Endpoints answer in three envelopes:
+* `{ error: { message, details } }`, `{ error: "..." }`, and
+* `{ error_message, errors }`.
+*/
+function errorDetail(err) {
+	const body = err?.body;
+	const error = body?.["error"];
+	if (error && typeof error === "object") {
+		const { message, details } = error;
+		if (typeof message === "string") return {
+			message,
+			...details ? { details } : {}
+		};
+	}
+	if (typeof error === "string") return { message: error };
+	if (typeof body?.["error_message"] === "string") return {
+		message: body["error_message"],
+		...body["errors"] ? { details: body["errors"] } : {}
+	};
+	if (typeof body?.["message"] === "string") return { message: body["message"] };
+	return { message: err instanceof Error ? err.message : String(err) };
+}
+/** One line for a per-item failure report: the API's message and status. */
+function failureOf(err) {
+	const status = err?.status;
+	return {
+		error: errorDetail(err).message,
+		...typeof status === "number" ? { status } : {}
+	};
+}
+/** Print a failure as JSON on stderr and exit non-zero. */
+function fail(err) {
+	const status = err?.status;
+	const { message, details } = errorDetail(err);
+	process.stderr.write(JSON.stringify({
+		error: message,
+		...typeof status === "number" ? { status } : {},
+		...details ? { details } : {}
+	}) + "\n");
+	process.exitCode = 1;
+}
+function run(action) {
+	return action().catch(fail);
+}
+/** Commander collector for a repeatable option. */
+const collect = (value, previous = []) => [...previous, value];
+function positiveInt(raw, flag) {
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) throw new LocalizationError(`${flag} takes a whole number above 0, not "${raw}".`);
+	return value;
+}
+//#endregion
+//#region src/shared/languages.ts
+const LANGUAGES_PATH = "/api/settings/languages";
+function toLanguage(wire) {
+	return {
+		id: wire.id,
+		name: wire.name ?? "",
+		iso: wire.iso ?? "",
+		active: wire.active_in_company === true,
+		usersCount: wire.company_users_count ?? null
+	};
+}
+/** Every language Fluid supports, with whether it is on for this company. */
+async function listLanguages(client, activeOnly = false) {
+	return ((await client.get(LANGUAGES_PATH, activeOnly ? { active: true } : void 0)).languages ?? []).map(toLanguage);
+}
+function normalizeIso(iso) {
+	return iso.trim().toLowerCase();
+}
+function sameIso(a, b) {
+	return normalizeIso(a) === normalizeIso(b);
+}
+/** A supported language by ISO code from a list already read, or undefined. */
+function languageIn(languages, iso) {
+	return languages.find((language) => sameIso(language.iso, iso));
+}
+/** One supported language by ISO code, or a LocalizationError naming close matches. */
+async function findLanguage(client, iso) {
+	const languages = await listLanguages(client);
+	const match = languageIn(languages, iso);
+	if (match) return match;
+	const prefix = normalizeIso(iso).split("-")[0] ?? normalizeIso(iso);
+	const close = languages.filter((language) => normalizeIso(language.iso).startsWith(prefix)).map((language) => language.iso);
+	throw new LocalizationError(`"${iso}" isn't a language Fluid supports.` + (close.length > 0 ? ` Did you mean ${close.join(", ")}?` : "") + " Run `fluid translations languages` to see every code.");
+}
+/** The language, or a LocalizationError if it isn't on for the company. */
+async function requireActiveLanguage(client, iso) {
+	const language = await findLanguage(client, iso);
+	if (!language.active) throw new LocalizationError(`${language.name} (${language.iso}) isn't on for this company, so translations can't be written to it. Run \`fluid translations enable ${language.iso} --yes\` first.`);
+	return language;
+}
+/** Turn a language on. The body is the documented and tested top-level `id`. */
+async function enableLanguage(client, language) {
+	const data = await client.post(LANGUAGES_PATH, { id: language.id });
+	return data.language ? toLanguage(data.language) : {
+		...language,
+		active: true
+	};
+}
+/** Turn a language off. Its saved translations are kept. */
+async function disableLanguage(client, language) {
+	await client.delete(`${LANGUAGES_PATH}/${language.id}`);
+	return {
+		...language,
+		active: false
+	};
+}
+//#endregion
+//#region src/shared/parsing.ts
+/** Keys that would reach an object's prototype instead of an own property. */
+const RESERVED_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Split a dotted path, refusing empty and reserved segments. */
+function keyPath(path) {
+	const parts = path.split(".");
+	if (parts.some((p) => p.length === 0)) throw new LocalizationError(`"${path}" has an empty key segment.`);
+	if (parts.some((p) => RESERVED_KEYS.has(p))) throw new LocalizationError(`"${path}" uses a reserved key name.`);
+	return parts;
+}
+function splitAssignment(assignment, example) {
+	const at = assignment.indexOf("=");
+	if (at <= 0) throw new LocalizationError(`"${assignment}" isn't key=value, e.g. ${example}.`);
+	return [assignment.slice(0, at).trim(), assignment.slice(at + 1)];
+}
+/**
+* Parse `--set field=value` text pairs into a flat object. Values are kept as
+* written, so translated text is never reinterpreted; only the first `=`
+* separates the key, and a theme key keeps its dots (`cart.title=Panier`).
+*/
+function parseTextAssignments(assignments) {
+	const out = {};
+	for (const assignment of assignments) {
+		const [key, value] = splitAssignment(assignment, "title=\"Mélange de betteraves\"");
+		keyPath(key);
+		out[key] = value;
+	}
+	return out;
+}
+/**
+* Parse `--set key=value` setting overrides. `legal_settings.cooling_off_period_days=30`
+* nests; values that read as JSON (true, 42, ["a"], {"x":1}) are parsed and
+* anything else stays a string.
+*/
+function parseSettingAssignments(assignments) {
+	const out = {};
+	for (const assignment of assignments) {
+		const [key, raw] = splitAssignment(assignment, "tax_inclusive_pricing=false");
+		const path = keyPath(key);
+		let node = out;
+		for (const part of path.slice(0, -1)) {
+			const next = Object.hasOwn(node, part) ? node[part] : void 0;
+			if (typeof next !== "object" || next === null || Array.isArray(next)) node[part] = {};
+			node = node[part];
+		}
+		node[path[path.length - 1]] = parseValue(raw);
+	}
+	return out;
+}
+function parseValue(raw) {
+	if (/^(true|false|null|-?\d+(\.\d+)?)$/.test(raw) || /^[[{]/.test(raw)) try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+	return raw;
+}
+/**
+* Read `--file`: a JSON object of field (or key) to string. Long or HTML
+* values are easier to pass this way than on the command line.
+*/
+function readValuesFile(path) {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new LocalizationError(`Couldn't read ${path} as JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new LocalizationError(`${path} must hold a JSON object of field to text.`);
+	const out = {};
+	for (const [key, value] of Object.entries(parsed)) {
+		if (typeof value !== "string") throw new LocalizationError(`${path}: "${key}" must be a string.`);
+		keyPath(key);
+		out[key] = value;
+	}
+	return out;
+}
+/** `--set` and `--file` together, `--set` winning on a clash. */
+function collectValues(sets, file) {
+	return {
+		...file ? readValuesFile(file) : {},
+		...parseTextAssignments(sets)
+	};
+}
+//#endregion
+//#region src/shared/client.ts
+/** The HTTP status of an API error, if it carries one. */
+function statusOf(error) {
+	const status = error?.status;
+	return typeof status === "number" ? status : void 0;
+}
+//#endregion
+//#region src/countries/atlas.ts
+const ATLAS_PATH_PREFIX = "/api/v202604/country/atlas/";
+/** The operating modes the atlas describes, as the CLI accepts them. */
+const MODES = [
+	"nfr",
+	"otg",
+	"usd"
+];
+function parseMode(value) {
+	const mode = value.trim().toLowerCase();
+	if (!MODES.includes(mode)) throw new LocalizationError(`"${value}" isn't an operating mode. Use one of: ${MODES.join(", ")}.`);
+	return mode;
+}
+/** Common aliases, as Mist resolves them: people type "UK" and alpha-3. */
+const ALIASES = {
+	UK: "GB",
+	DEU: "DE",
+	FRA: "FR",
+	GBR: "GB",
+	CAN: "CA",
+	MEX: "MX",
+	AUS: "AU",
+	JPN: "JP",
+	USA: "US"
+};
+function normalizeCountryCode(code) {
+	const upper = code.trim().toUpperCase();
+	return ALIASES[upper] ?? upper;
+}
+/** The ISO alpha-2 code, or a LocalizationError for anything else. */
+function countryCodeOf(code) {
+	const iso = normalizeCountryCode(code);
+	if (!/^[A-Z]{2}$/.test(iso)) throw new LocalizationError(`"${code}" isn't a two-letter ISO country code, e.g. DE or JP.`);
+	return iso;
+}
+/** Flatten the atlas's simple HTML (overviews, notes) to readable text. */
+function htmlToText(html) {
+	return html.replace(/<\s*(br|\/p|\/li|\/ul|\/ol|\/h[1-6]|\/blockquote)[^>]*>/gi, "\n").replace(/<\s*li[^>]*>/gi, "• ").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, "\"").replace(/&#0?39;|&apos;/gi, "'").replace(/&amp;/gi, "&").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Whether a response body is an atlas. The endpoint answers 404 for an
+*  unknown ISO, and a country with no configuration renders an empty body. */
+function isAtlas(body) {
+	return typeof body === "object" && body !== null && typeof body.modes === "object" && body.modes !== null;
+}
+/** Fetch a country's atlas. A 404 or an empty configuration is an uncovered
+*  market, not an error. Other failures throw. */
+async function fetchAtlas(client, code) {
+	const countryCode = countryCodeOf(code);
+	let body;
+	try {
+		body = await client.get(`${ATLAS_PATH_PREFIX}${countryCode.toLowerCase()}`);
+	} catch (error) {
+		if (statusOf(error) === 404) return {
+			countryCode,
+			covered: false,
+			atlas: null
+		};
+		throw error;
+	}
+	if (!isAtlas(body)) return {
+		countryCode,
+		covered: false,
+		atlas: null
+	};
+	return {
+		countryCode,
+		covered: true,
+		atlas: body
+	};
+}
+/** The atlas, or a LocalizationError explaining that the market is uncovered. */
+async function requireAtlas(client, code) {
+	const result = await fetchAtlas(client, code);
+	if (!result.covered || !result.atlas) throw new LocalizationError(`Fluid publishes no Country Atlas for ${result.countryCode} yet, so there is nothing to seed from. Set the country up by hand in Settings > Countries.`);
+	return {
+		countryCode: result.countryCode,
+		atlas: result.atlas
+	};
+}
+const NOTES_SUMMARY_MAX = 2e3;
+/** The translation an agreement is created from: English, else the first. */
+function primaryTranslation(agreement) {
+	return agreement.translations.find((t) => t.language_iso === "en") ?? agreement.translations[0];
+}
+function summarizeAgreement(agreement) {
+	const primary = primaryTranslation(agreement);
+	return {
+		localId: agreement._localId,
+		title: primary?.title ?? agreement._localId,
+		languages: agreement.translations.map((t) => t.language_iso),
+		requiredOnCheckout: agreement.required_on_checkout,
+		showAtCheckout: agreement.show_at_checkout,
+		defaultChecked: agreement.default_checked,
+		bodyChars: primary?.description.length ?? 0
+	};
+}
+/** The atlas without the agreement legal bodies, which run to thousands of
+*  characters each; `fluid countries atlas <iso> --agreement <id>` prints one. */
+function summarizeAtlas(atlas) {
+	const notes = htmlToText(atlas.notes ?? "");
+	const modes = {};
+	for (const [key, mode] of Object.entries(atlas.modes ?? {})) modes[key] = {
+		overview: htmlToText(mode.overview ?? ""),
+		launchChecklist: mode.launchChecklist ?? []
+	};
+	return {
+		defaultCurrency: atlas.defaultCurrency,
+		majorLanguages: atlas.majorLanguages ?? [],
+		requires3ds: atlas.requires3ds ?? false,
+		marketNotes: notes.length > NOTES_SUMMARY_MAX ? `${notes.slice(0, NOTES_SUMMARY_MAX)}… [truncated]` : notes,
+		modes,
+		taxSettings: atlas.taxSettings,
+		legalSettings: atlas.legalSettings ?? {},
+		paymentMethods: sortedPaymentMethods(atlas),
+		enrollmentFormFields: [...atlas.enrollmentFormFields ?? []].sort((a, b) => a.order - b.order),
+		addressFields: atlas.addressFields ?? [],
+		agreements: (atlas.agreements ?? []).map(summarizeAgreement)
+	};
+}
+function sortedPaymentMethods(atlas) {
+	return [...atlas.paymentMethods ?? []].sort((a, b) => a.priority - b.priority);
+}
+/** The launch checklist for one mode, verbatim. */
+function launchChecklist(atlas, mode) {
+	return atlas.modes?.[mode]?.launchChecklist ?? [];
+}
+/** One agreement's full translations, by its atlas local id. */
+function atlasAgreement(atlas, localId) {
+	const agreement = (atlas.agreements ?? []).find((a) => a._localId === localId);
+	if (!agreement) throw new LocalizationError(`The atlas has no agreement "${localId}". It has: ${(atlas.agreements ?? []).map((a) => a._localId).join(", ") || "none"}.`);
+	return agreement;
+}
+//#endregion
+//#region src/countries/api.ts
+/** GET /api/countries: the global country catalog. */
+async function listCatalogCountries(client) {
+	const body = await client.get("/api/countries");
+	return Array.isArray(body) ? body : body.countries ?? [];
+}
+/** One country from the global catalog. */
+async function catalogCountry(client, iso) {
+	const match = (await listCatalogCountries(client)).find((c) => c.iso?.toUpperCase() === iso);
+	if (!match) throw new LocalizationError(`Fluid's country catalog has no country ${iso}.`);
+	return match;
+}
+/** GET /api/settings/company_countries: the countries the company sells in. */
+async function listCompanyCountries(client) {
+	return (await client.get("/api/settings/company_countries")).company_countries ?? [];
+}
+async function findCompanyCountry(client, iso) {
+	return (await listCompanyCountries(client)).find((cc) => cc.country?.iso?.toUpperCase() === iso);
+}
+/** The company country, or a LocalizationError saying to open it first. */
+async function requireCompanyCountry(client, iso) {
+	const found = await findCompanyCountry(client, iso);
+	if (!found) throw new LocalizationError(`${iso} isn't open for this company yet. Run \`fluid countries open ${iso} --mode <nfr|otg|usd>\` first.`);
+	return found;
+}
+/** POST /api/settings/company_countries. `seedLegacyDefaults: false` skips
+*  the server's generic country agreements and forms, so the company gets
+*  the atlas selection instead. */
+async function createCompanyCountry(client, attributes, seedLegacyDefaults) {
+	const body = await client.post("/api/settings/company_countries", {
+		company_country: attributes,
+		seed_legacy_defaults: seedLegacyDefaults
+	});
+	return {
+		...body.company_country,
+		...body.warnings ? { warnings: body.warnings } : {}
+	};
+}
+/** PUT /api/settings/company_countries/:id, guarded by the revision read
+*  just before so a concurrent admin edit answers 409 instead of being lost. */
+async function updateCompanyCountry(client, id, attributes, expectedRevision) {
+	const { country_id: _ignored, ...rest } = attributes;
+	return (await client.put(`/api/settings/company_countries/${id}`, {
+		company_country: rest,
+		...expectedRevision ? { expected_revision: expectedRevision } : {}
+	})).company_country;
+}
+/**
+* Create an atlas agreement for a company country. POST writes the base
+* (English) text: the English translation when the atlas has one, else the
+* first. Each translation that is not English is then written in its own
+* locale with PUT ?language_iso=, which needs that language enabled for the
+* company. A translation that fails is reported, not fatal.
+*/
+async function createAgreementFromAtlas(client, agreement, companyCountryId) {
+	const primary = primaryTranslation(agreement);
+	if (!primary) throw new LocalizationError(`Atlas agreement ${agreement._localId} has no text.`);
+	const flags = {
+		active: true,
+		required_on_checkout: agreement.required_on_checkout === true,
+		show_at_checkout: agreement.show_at_checkout === true,
+		default_checked: agreement.default_checked === true,
+		company_country_ids: [companyCountryId]
+	};
+	const id = (await client.post("/api/agreements", { agreement: {
+		title: primary.title,
+		description: primary.description,
+		...flags
+	} })).agreement.id;
+	const { translations, failedTranslations } = await writeTranslations(client, id, agreement);
+	return {
+		localId: agreement._localId,
+		id,
+		title: primary.title,
+		translations,
+		failedTranslations
+	};
+}
+/**
+* Write each of an atlas agreement's translations that isn't English onto a
+* company agreement, in its own locale. Only the title and text are sent, so
+* the agreement's checkout settings and countries are left as they are. A
+* translation that fails is reported, not fatal, and can be written again.
+*/
+async function writeTranslations(client, agreementId, agreement) {
+	const translations = [];
+	const failedTranslations = [];
+	for (const t of agreement.translations) {
+		if (t.language_iso === "en") continue;
+		try {
+			await writeAgreementTranslation(client, agreementId, t.language_iso, t);
+			translations.push(t.language_iso);
+		} catch (error) {
+			failedTranslations.push({
+				language: t.language_iso,
+				...failureOf(error)
+			});
+		}
+	}
+	return {
+		translations,
+		failedTranslations
+	};
+}
+/**
+* The atlas languages an agreement has no translation in, checked the way
+* `fluid translations missing --type agreements` checks them: a read in a
+* language without a translation falls back and says so in `language_iso`.
+* English is the base text an agreement is created from, so it isn't checked.
+*/
+async function missingTranslations(client, agreementId, agreement) {
+	const missing = [];
+	for (const t of agreement.translations) {
+		if (t.language_iso === "en") continue;
+		if (!await agreementTranslated(client, agreementId, t.language_iso)) missing.push(t.language_iso);
+	}
+	return missing;
+}
+/** GET /api/settings/warehouses. */
+async function listWarehouses(client) {
+	return (await client.get("/api/settings/warehouses")).warehouses ?? [];
+}
+//#endregion
+//#region src/countries/compliance.ts
+/** Privacy regulators matched against the market notes. Not exhaustive: an
+*  unmatched market reads "See market notes", never an invented name. */
+const KNOWN_REGULATORS = [
+	"BfDI",
+	"CNIL",
+	"ICO",
+	"Garante",
+	"AEPD",
+	"OPC",
+	"CAI",
+	"INAI",
+	"OAIC",
+	"PPC",
+	"PDPC",
+	"FTC"
+];
+/** The first statute-like reference in a legal body, or "". */
+function extractCitation(bodyText) {
+	for (const re of [
+		/§\s?\d+[a-z]?/i,
+		/Art(?:icle)?\.?\s?\d+[-\w]*/i,
+		/Regulation\s+\d+/i,
+		/\b\d{4}[-/]\d+\b/
+	]) {
+		const m = bodyText.match(re);
+		if (m) return m[0].trim();
+	}
+	return "";
+}
+function languageName$1(iso) {
+	try {
+		return new Intl.DisplayNames(["en"], { type: "language" }).of(iso) ?? iso;
+	} catch {
+		return iso;
+	}
+}
+function unitPriceRule(atlas, notes) {
+	const match = [notes, ...Object.values(atlas.modes ?? {}).flatMap((m) => (m.launchChecklist ?? []).map((c) => `${c.label} ${c.description}`))].join("\n").toLowerCase().match(/[^\n]*(unit[\s-]?pric|price marking|grundpreis)[^\n]*/);
+	return match ? {
+		required: true,
+		notes: match[0].trim().slice(0, 200)
+	} : {
+		required: false,
+		notes: ""
+	};
+}
+function complianceView(countryCode, atlas) {
+	const notes = htmlToText(atlas.notes ?? "");
+	const languages = atlas.majorLanguages ?? [];
+	const primaryLanguage = languages[0] ?? "en";
+	const cookieRequired = atlas.legalSettings?.cookieConsentRequired ?? false;
+	const regulator = KNOWN_REGULATORS.find((r) => new RegExp(`\\b${r}\\b`).test(notes));
+	return {
+		countryCode,
+		currencyCode: atlas.defaultCurrency,
+		languageCode: primaryLanguage,
+		languageName: languageName$1(primaryLanguage),
+		widelySpokenLanguages: languages.slice(1),
+		vat: atlas.taxSettings?.taxName ? {
+			name: atlas.taxSettings.taxName,
+			standardRatePct: null
+		} : null,
+		vatInclusiveDisplay: atlas.taxSettings ? atlas.taxSettings.taxInclusive ? "inclusive" : "exclusive_at_sticker" : "unspecified",
+		legalSettings: atlas.legalSettings ?? {},
+		cookieRule: {
+			framework: cookieRequired ? "Consent-based cookie law (see market notes)" : "None documented",
+			requirement: cookieRequired ? "Obtain consent before non-essential cookies; provide an equally-prominent Reject All and log consent." : "No cookie-consent mandate documented for this market.",
+			regulator: regulator ?? "See market notes"
+		},
+		unitPriceRule: unitPriceRule(atlas, notes),
+		mandatoryDisclosurePages: (atlas.agreements ?? []).map((a) => {
+			const primary = primaryTranslation(a);
+			const body = htmlToText(primary?.description ?? "");
+			return {
+				localId: a._localId,
+				name: primary?.title ?? a._localId,
+				description: body.slice(0, 160),
+				citation: extractCitation(body)
+			};
+		}),
+		paymentMethods: sortedPaymentMethods(atlas).map((m) => ({
+			integrationType: m.integration_type,
+			label: m.name,
+			recommended: m.enabled
+		}))
+	};
+}
+//#endregion
+//#region src/countries/prices.ts
+/** The money fields a conversion can write, as the variants API names them. */
+const PRICE_FIELDS = [
+	"price",
+	"subscription_price",
+	"compare_price",
+	"wholesale",
+	"wholesale_subscription_price"
+];
+/**
+* What shoppers pay. Wholesale prices are left out by default: they drive
+* member commissions, and an admin token's product reads can show retail in
+* their place, so converting them is opt-in with --fields.
+*/
+const DEFAULT_PRICE_FIELDS = [
+	"price",
+	"subscription_price",
+	"compare_price"
+];
+/** Currencies Fluid stores with no minor unit (the API rounds the same way). */
+const ZERO_DECIMAL_CURRENCIES = new Set([
+	"BIF",
+	"CLP",
+	"DJF",
+	"GNF",
+	"HUF",
+	"ISK",
+	"JPY",
+	"KMF",
+	"KRW",
+	"MGA",
+	"PYG",
+	"RWF",
+	"TWD",
+	"UGX",
+	"VND",
+	"VUV",
+	"XAF",
+	"XOF",
+	"XPF"
+]);
+function currencyDecimals(currency) {
+	return ZERO_DECIMAL_CURRENCIES.has(currency.toUpperCase()) ? 0 : 2;
+}
+/** `amount × rate`, rounded half up to the currency's minor unit. */
+function convertAmount(amount, rate, currency) {
+	const factor = 10 ** currencyDecimals(currency);
+	const scaled = amount * rate * factor;
+	return Math.round(scaled + Math.sign(scaled) * 1e-7) / factor;
+}
+function parseRate(raw) {
+	const rate = Number(raw);
+	if (!Number.isFinite(rate) || rate <= 0) throw new LocalizationError(`--rate takes a positive number, such as 0.92, not "${raw}".`);
+	return rate;
+}
+function parsePriceFields(raw) {
+	if (!raw) return [...DEFAULT_PRICE_FIELDS];
+	const fields = raw.split(",").map((f) => f.trim()).filter(Boolean);
+	const unknown = fields.filter((f) => !PRICE_FIELDS.includes(f));
+	if (unknown.length > 0 || fields.length === 0) throw new LocalizationError(`--fields takes a comma-separated list of ${PRICE_FIELDS.join(", ")}${unknown.length > 0 ? `; not ${unknown.join(", ")}` : ""}.`);
+	if (!fields.includes("price")) throw new LocalizationError("--fields must include price: a variant can't be sold in a country without one.");
+	return [...new Set(fields)];
+}
+function amount(value) {
+	if (value === null || value === void 0 || value === "") return null;
+	const n = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(n) ? n : null;
+}
+const PRODUCTS_PATH = "/api/company/v1/products";
+/** The products list renders every variant, so the API caps a page at 50. */
+const PER_PAGE$1 = 50;
+const MAX_PAGES$2 = 2e3;
+/** Every product with its variants, following the list's pages. */
+async function listProductsWithVariants(client, statuses) {
+	const products = [];
+	for (let page = 1; page <= MAX_PAGES$2; page += 1) {
+		const data = await client.get(PRODUCTS_PATH, {
+			page,
+			per_page: PER_PAGE$1,
+			status: [...statuses]
+		});
+		const batch = data.products ?? [];
+		for (const product of batch) if (!Array.isArray(product.variants)) {
+			const full = await client.get(`${PRODUCTS_PATH}/${product.id}`);
+			products.push(full.product ?? product);
+		} else products.push(product);
+		const totalPages = data.meta?.pagination?.total_pages ?? 1;
+		if (page >= totalPages || batch.length === 0) return products;
+	}
+	throw new LocalizationError(`The catalog has more than ${MAX_PAGES$2 * PER_PAGE$1} products, more than one run can read. Narrow it with --status.`);
+}
+/**
+* Whether the price editor owns this company's prices (member-pricing
+* catalog writes), or null when the token can't read the company profile.
+*/
+async function priceEditorOwnsPrices(client) {
+	try {
+		return (await client.get("/api/company/v1/companies/me")).data?.company?.member_pricing?.catalog_writes === true;
+	} catch (error) {
+		if (statusOf(error) === 401 || statusOf(error) === 403) return null;
+		throw error;
+	}
+}
+/**
+* Decide, per variant, what a conversion writes. A variant needs a positive
+* source price. One whose target row already has a positive price is skipped
+* unless `overwrite`, which is what makes a rerun safe: the first run's
+* prices count as "already priced". A positive price saved in another
+* currency (the country's currency changed since) is skipped too, and
+* reported apart so it can be reviewed. Opening a country creates a zero-priced,
+* inactive row for every variant, so a zero price counts as unpriced. Only
+* the fields with a positive source amount are sent; the rest of the row is
+* left as it is.
+*/
+function planConversion(products, options) {
+	const plans = [];
+	for (const product of products) for (const variant of product.variants ?? []) {
+		const rows = variant.variant_countries ?? {};
+		const source = rowFor(rows, options.sourceIso);
+		const target = rowFor(rows, options.targetIso);
+		const before = Object.fromEntries(options.fields.map((f) => [f, amount(target?.[f])]));
+		const base = {
+			productId: product.id,
+			product: product.title ?? null,
+			variantId: variant.id,
+			sku: variant.sku ?? null,
+			rowId: typeof target?.id === "number" ? target.id : null,
+			active: options.activate || target?.active === true,
+			before
+		};
+		const sourcePrice = amount(source?.price);
+		if (sourcePrice === null || sourcePrice <= 0) {
+			plans.push({
+				...base,
+				action: "skip",
+				reason: "no_source_price",
+				after: {}
+			});
+			continue;
+		}
+		if (!options.overwrite && (amount(target?.price) ?? 0) > 0) {
+			const currency = target?.currency_code;
+			const sameCurrency = !currency || currency.toUpperCase() === options.targetCurrency.toUpperCase();
+			plans.push({
+				...base,
+				action: "skip",
+				reason: sameCurrency ? "already_priced" : "priced_in_other_currency",
+				after: {}
+			});
+			continue;
+		}
+		const after = {};
+		for (const field of options.fields) {
+			const value = amount(source?.[field]);
+			if (value === null || value <= 0) continue;
+			const converted = convertAmount(value, options.rate, options.targetCurrency);
+			if (converted > 0) after[field] = converted;
+		}
+		if (after.price === void 0) {
+			plans.push({
+				...base,
+				action: "skip",
+				reason: "rounds_to_zero",
+				after: {}
+			});
+			continue;
+		}
+		plans.push({
+			...base,
+			action: "convert",
+			after
+		});
+	}
+	return plans;
+}
+function rowFor(rows, iso) {
+	const key = Object.keys(rows).find((k) => k.toUpperCase() === iso.toUpperCase());
+	return key ? rows[key] : void 0;
+}
+/** The variants API body that saves one plan's prices in the target country. */
+function variantBody(plan, targetCountryId) {
+	return { variant: { variant_countries_attributes: [{
+		...plan.rowId !== null ? { id: plan.rowId } : {},
+		country_id: targetCountryId,
+		active: plan.active,
+		...plan.after
+	}] } };
+}
+/** Messages the price editor's catalog writer refuses a save with. */
+const PRICE_EDITOR_REFUSAL = /could not be written to the catalog|another update to these prices is in progress/i;
+/**
+* Save the convertible plans, one variant at a time; a failure never stops
+* the run. Each product is read again just before its variants are written
+* and planned afresh, so a price someone set in the country after the
+* preview is skipped instead of overwritten (`changedSincePreview`).
+*/
+async function writeConversion(client, plans, options) {
+	const written = [];
+	const failed = [];
+	const changedSincePreview = [];
+	const byProduct = /* @__PURE__ */ new Map();
+	for (const plan of plans) {
+		if (plan.action !== "convert") continue;
+		byProduct.set(plan.productId, [...byProduct.get(plan.productId) ?? [], plan]);
+	}
+	for (const [productId, previewed] of byProduct) {
+		let fresh;
+		try {
+			const data = await client.get(`${PRODUCTS_PATH}/${productId}`);
+			fresh = data.product ? planConversion([data.product], options) : [];
+		} catch (error) {
+			for (const plan of previewed) failed.push(failureFor(plan, error));
+			continue;
+		}
+		for (const plan of previewed) {
+			const now = fresh.find((p) => p.variantId === plan.variantId);
+			if (!now || now.action !== "convert") {
+				changedSincePreview.push({
+					variantId: plan.variantId,
+					productId,
+					reason: now?.reason ?? "variant_gone"
+				});
+				continue;
+			}
+			try {
+				await client.put(`/api/company/v1/variants/${now.variantId}`, variantBody(now, options.targetCountryId));
+				written.push(now.variantId);
+			} catch (error) {
+				failed.push(failureFor(now, error));
+			}
+		}
+	}
+	return {
+		written,
+		failed,
+		changedSincePreview
+	};
+}
+function failureFor(plan, error) {
+	const details = error.body?.["errors"];
+	const { error: message, status } = failureOf(error);
+	const text = `${message} ${details ? JSON.stringify(details) : ""}`;
+	return {
+		variantId: plan.variantId,
+		productId: plan.productId,
+		sku: plan.sku,
+		error: message,
+		...status !== void 0 ? { status } : {},
+		refusedByPriceEditor: status === 422 && PRICE_EDITOR_REFUSAL.test(text),
+		...details ? { details } : {}
+	};
+}
+/** Counts and a before→after sample, the summary a dry run prints. */
+function summarizePlans(plans, sampleSize) {
+	const convert = plans.filter((p) => p.action === "convert");
+	return {
+		variants: plans.length,
+		toConvert: convert.length,
+		skipped: {
+			alreadyPriced: plans.filter((p) => p.reason === "already_priced").length,
+			pricedInOtherCurrency: plans.filter((p) => p.reason === "priced_in_other_currency").length,
+			noSourcePrice: plans.filter((p) => p.reason === "no_source_price").length,
+			roundsToZero: plans.filter((p) => p.reason === "rounds_to_zero").length
+		},
+		activeAfterWrite: convert.filter((p) => p.active).length,
+		sample: convert.slice(0, sampleSize).map((p) => ({
+			productId: p.productId,
+			product: p.product,
+			variantId: p.variantId,
+			sku: p.sku,
+			before: p.before,
+			after: p.after
+		}))
+	};
+}
+/** A company country by ISO, from a list already read. */
+function companyCountryIn(countries, iso) {
+	return countries.find((cc) => cc.country?.iso?.toUpperCase() === iso.toUpperCase());
+}
+/**
+* A reference rate to start from: the European Central Bank's daily rate,
+* through the Frankfurter API. Fluid has no exchange-rate API. A write never
+* uses this on its own; it needs the rate passed with --rate, so the rate
+* saved is one a person or agent reviewed.
+*/
+async function referenceRate(from, to, fetchImpl = fetch) {
+	const url = `https://api.frankfurter.app/latest?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
+	try {
+		const response = await fetchImpl(url);
+		if (!response.ok) return null;
+		const body = await response.json();
+		const rate = body.rates?.[to.toUpperCase()];
+		if (typeof rate !== "number" || !(rate > 0)) return null;
+		return {
+			rate,
+			date: body.date ?? "",
+			source: "European Central Bank reference rate (frankfurter.app)"
+		};
+	} catch {
+		return null;
+	}
+}
+/** How many variants have a price in the country and how many are on sale there; bundles listed apart. */
+function priceCoverage(products, iso) {
+	const coverage = {
+		variants: 0,
+		priced: 0,
+		onSale: 0,
+		bundles: []
+	};
+	for (const product of products) {
+		if (product.bundle === true) {
+			coverage.bundles.push({
+				id: product.id,
+				title: product.title ?? null
+			});
+			continue;
+		}
+		for (const variant of product.variants ?? []) {
+			coverage.variants += 1;
+			const row = rowFor(variant.variant_countries ?? {}, iso);
+			if ((amount(row?.price) ?? 0) <= 0) continue;
+			coverage.priced += 1;
+			if (row?.active === true) coverage.onSale += 1;
+		}
+	}
+	return coverage;
+}
+//#endregion
+//#region src/countries/plan.ts
+/** Each of the market's major languages and whether the company has it on.
+*  A language the catalog lacks can't be enabled and is reported as such. */
+function languageStates(atlas, languages) {
+	return (atlas.majorLanguages ?? []).map((iso) => {
+		const match = languageIn(languages, iso);
+		return {
+			iso,
+			name: match?.name ?? null,
+			languageId: match?.id ?? null,
+			enabled: match?.active === true
+		};
+	});
+}
+/** Match atlas agreements to company agreements by title, case-insensitively,
+*  so a setup never creates a second agreement with the same title. */
+function agreementStates(atlas, agreements, companyCountryId) {
+	return (atlas.agreements ?? []).map((agreement) => {
+		const summary = summarizeAgreement(agreement);
+		const titles = new Set(agreement.translations.map((t) => t.title.trim().toLowerCase()));
+		const matches = agreements.filter((a) => titles.has(a.title?.trim().toLowerCase()));
+		const onCountry = companyCountryId === null ? [] : matches.filter((a) => (a.company_country_ids ?? []).includes(companyCountryId));
+		const linked = onCountry.find((a) => a.active !== false);
+		const inactive = linked ? void 0 : onCountry[0];
+		const match = linked ?? inactive ?? matches[0];
+		return {
+			localId: summary.localId,
+			title: summary.title,
+			languages: summary.languages,
+			requiredOnCheckout: summary.requiredOnCheckout,
+			showAtCheckout: summary.showAtCheckout,
+			status: linked ? "linked" : inactive ? "inactive" : match ? "exists" : "missing",
+			agreementId: match?.id ?? null
+		};
+	});
+}
+//#endregion
+//#region src/countries/seed.ts
+/** Address fields checkout both renders and stores; only these may be
+*  required (CompanyCountry::ContractSchema.storable_address_field_names). */
+const STORABLE_ADDRESS_FIELDS = [
+	"name",
+	"address1",
+	"address2",
+	"city",
+	"state",
+	"postal_code",
+	"country_code",
+	"phone"
+];
+const COLUMN_WIDTHS = [
+	"full",
+	"half",
+	"third"
+];
+/**
+* The atlas address layout in the contract shape the API validates. The
+* atlas marks first and last name required, but checkout cannot collect a
+* required field it does not store, so those keep their layout and become
+* optional. A required field is always visible. Repeats are dropped.
+*/
+function addressFieldsFromAtlas(atlas) {
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (const source of atlas.addressFields ?? []) {
+		if (typeof source.field !== "string" || source.field === "" || seen.has(source.field)) continue;
+		seen.add(source.field);
+		const required = source.required === true && STORABLE_ADDRESS_FIELDS.includes(source.field);
+		const entry = {
+			field: source.field,
+			visible: required || source.visible !== false,
+			required
+		};
+		if (typeof source.localLabel === "string") entry.local_label = source.localLabel;
+		if (typeof source.columnWidth === "string" && COLUMN_WIDTHS.includes(source.columnWidth)) entry.column_width = source.columnWidth;
+		if (typeof source.placeholder === "string") entry.placeholder = source.placeholder;
+		entries.push(entry);
+	}
+	return entries;
+}
+/** The atlas legal settings under the API's snake_case keys. Values of the
+*  wrong kind are left out rather than sent to be refused. */
+function legalSettingsFromAtlas(atlas) {
+	const legal = atlas.legalSettings ?? {};
+	const out = {};
+	const count = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+	if (count(legal.coolingOffPeriodDays)) out["cooling_off_period_days"] = legal.coolingOffPeriodDays;
+	if (count(legal.warrantyPeriodMonths)) out["warranty_period_months"] = legal.warrantyPeriodMonths;
+	if (typeof legal.cookieConsentRequired === "boolean") out["cookie_consent_required"] = legal.cookieConsentRequired;
+	if (typeof legal.recurringSubscriptionDisclosureRequired === "boolean") out["recurring_subscription_disclosure_required"] = legal.recurringSubscriptionDisclosureRequired;
+	return out;
+}
+/** The atlas's recommended payment methods (enabled ones), in its order, as
+*  the integration type names checkout ranks by. */
+function paymentPriorityFromAtlas(atlas) {
+	return sortedPaymentMethods(atlas).filter((m) => m.enabled).map((m) => m.integration_type);
+}
+/** The keys `company_country` accepts on create and update, so a `--set`
+*  typo is caught before it reaches the API. */
+const WRITABLE_KEYS = [
+	"currency",
+	"warehouse_id",
+	"handling_fee",
+	"default",
+	"tax_business_id",
+	"tax_strategy",
+	"tax_class",
+	"mode",
+	"settlement_currency",
+	"entity_id",
+	"entity_legally_registered",
+	"tax_inclusive_pricing",
+	"tax_name",
+	"requires_3ds",
+	"payment_method_priority",
+	"checkout_requires_terms",
+	"tax_invoice_required",
+	"legal_settings",
+	"address_fields"
+];
+/** The company_country attributes the atlas and the flags give. */
+function companyCountryFromAtlas(atlas, options) {
+	const body = {
+		country_id: options.countryId,
+		mode: options.mode.toUpperCase(),
+		currency: atlas.defaultCurrency,
+		requires_3ds: atlas.requires3ds === true
+	};
+	const tax = atlas.taxSettings;
+	if (tax) {
+		if (typeof tax.taxName === "string" && tax.taxName !== "") body["tax_name"] = tax.taxName;
+		if (typeof tax.taxInclusive === "boolean") body["tax_inclusive_pricing"] = tax.taxInclusive;
+		if (typeof tax.invoiceRequired === "boolean") body["tax_invoice_required"] = tax.invoiceRequired;
+	}
+	const priority = paymentPriorityFromAtlas(atlas);
+	if (priority.length > 0) body["payment_method_priority"] = priority;
+	const legal = legalSettingsFromAtlas(atlas);
+	if (Object.keys(legal).length > 0) body["legal_settings"] = legal;
+	const address = addressFieldsFromAtlas(atlas);
+	if (address.length > 0) body["address_fields"] = address;
+	if (options.warehouseId !== void 0) body["warehouse_id"] = options.warehouseId;
+	if (options.businessId !== void 0) body["tax_business_id"] = options.businessId;
+	if (options.entityRegistered !== void 0) body["entity_legally_registered"] = options.entityRegistered;
+	if (options.settlementCurrency !== void 0) body["settlement_currency"] = options.settlementCurrency.toUpperCase();
+	return body;
+}
+/** Apply `--set` overrides on top of the seeded body, refusing unknown keys. */
+function applyOverrides(body, overrides) {
+	const unknown = Object.keys(overrides).filter((key) => !WRITABLE_KEYS.includes(key));
+	if (unknown.length > 0) throw new LocalizationError(`Unknown company country setting(s): ${unknown.join(", ")}. Settable: ${WRITABLE_KEYS.join(", ")}.`);
+	const merged = { ...body };
+	for (const [key, value] of Object.entries(overrides)) {
+		const current = merged[key];
+		merged[key] = isPlainObject(current) && isPlainObject(value) ? {
+			...current,
+			...value
+		} : value;
+	}
+	return merged;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/countries/status.ts
+function same(a, b) {
+	return a === b || a == null && b == null;
+}
+/** Compare the company country with the atlas. A value an admin changed on
+*  purpose shows as a difference to review, not as a failure to fix. */
+function settingsChecks(atlas, cc) {
+	const checks = [];
+	checks.push({
+		id: "mode",
+		ok: typeof cc.mode === "string" && cc.mode !== "",
+		detail: cc.mode ? `Operating mode ${cc.mode}.` : "No operating mode set."
+	});
+	checks.push({
+		id: "currency",
+		ok: same(cc.currency, atlas.defaultCurrency),
+		detail: `Currency ${cc.currency ?? "unset"}; the atlas recommends ${atlas.defaultCurrency}.`
+	});
+	const tax = atlas.taxSettings;
+	if (tax) {
+		checks.push({
+			id: "tax_name",
+			ok: same(cc.tax_name, tax.taxName),
+			detail: `Tax name ${cc.tax_name ?? "unset"}; the atlas says ${tax.taxName}.`
+		});
+		checks.push({
+			id: "tax_inclusive_pricing",
+			ok: same(cc.tax_inclusive_pricing, tax.taxInclusive),
+			detail: `Tax-inclusive prices ${String(cc.tax_inclusive_pricing ?? "unset")}; the atlas says ${String(tax.taxInclusive)}.`
+		});
+	}
+	checks.push({
+		id: "requires_3ds",
+		ok: same(cc.requires_3ds ?? false, atlas.requires3ds ?? false),
+		detail: `3-D Secure required ${String(cc.requires_3ds ?? false)}; the atlas says ${String(atlas.requires3ds ?? false)}.`
+	});
+	if (tax && typeof tax.invoiceRequired === "boolean") checks.push({
+		id: "tax_invoice_required",
+		ok: same(cc.tax_invoice_required, tax.invoiceRequired),
+		detail: `Tax invoices required ${String(cc.tax_invoice_required ?? "unset")}; the atlas says ${String(tax.invoiceRequired)}.`
+	});
+	const priority = paymentPriorityFromAtlas(atlas);
+	if (priority.length > 0) {
+		const current = cc.payment_method_priority ?? [];
+		checks.push({
+			id: "payment_method_priority",
+			ok: JSON.stringify(current) === JSON.stringify(priority),
+			detail: `Payment order ${current.length > 0 ? current.join(", ") : "unset"}; the atlas recommends ${priority.join(", ")}.`
+		});
+	}
+	const legal = legalSettingsFromAtlas(atlas);
+	const legalDiffs = Object.entries(legal).filter(([key, value]) => cc.legal_settings?.[key] !== value).map(([key]) => key);
+	checks.push({
+		id: "legal_settings",
+		ok: legalDiffs.length === 0,
+		detail: legalDiffs.length === 0 ? "Legal settings match the atlas." : `Legal settings differ from the atlas: ${legalDiffs.join(", ")}.`
+	});
+	const requiredFields = addressFieldsFromAtlas(atlas).filter((f) => f.required).map((f) => f.field);
+	const current = Array.isArray(cc.address_fields) ? cc.address_fields : null;
+	const notRequired = requiredFields.filter((field) => !current?.some((f) => f["field"] === field && f["required"] === true));
+	checks.push({
+		id: "address_fields",
+		ok: current !== null && current.length > 0 && notRequired.length === 0,
+		detail: current === null ? "No address layout on the country; checkout uses the default fields." : notRequired.length > 0 ? `The atlas requires ${notRequired.join(", ")}, which the country doesn't.` : `${current.length} address fields set, with every field the atlas requires.`
+	});
+	return checks;
+}
+function statusReport(input) {
+	const { countryCode, atlas, companyCountry: cc, languages, agreements } = input;
+	if (!cc) return {
+		country: countryCode,
+		open: false,
+		done: false,
+		next: `fluid countries open ${countryCode} --mode <nfr|otg|usd>`
+	};
+	const priceChecks = input.prices ? [{
+		id: "prices",
+		ok: input.prices.priced === input.prices.variants,
+		detail: input.prices.priced === input.prices.variants ? `All ${input.prices.variants} variants of your active products have a price in ${countryCode}${input.prices.bundles.length > 0 ? ` (bundles aren't counted; see byHand.bundles)` : ""}.` : `${input.prices.variants - input.prices.priced} of ${input.prices.variants} variants of your active products have no price in ${countryCode}. Run \`fluid countries prices ${countryCode}\`.`
+	}, {
+		id: "on_sale",
+		ok: input.prices.onSale > 0 || input.prices.bundles.length > 0,
+		detail: input.prices.onSale > 0 ? `${input.prices.onSale} variants are on sale in ${countryCode}.` : input.prices.bundles.length > 0 ? `No single products are on sale in ${countryCode}; check the bundles under byHand.bundles.` : `Nothing is on sale in ${countryCode} yet. Turn on the products you'll sell there, or run prices with --activate.`
+	}] : [];
+	const checks = [
+		...settingsChecks(atlas, cc),
+		...priceChecks,
+		...languages.map((l) => ({
+			id: `language:${l.iso}`,
+			ok: l.enabled,
+			detail: l.enabled ? `${l.name ?? l.iso} is enabled.` : l.languageId === null ? `${l.iso} isn't in Fluid's language catalog.` : `${l.name ?? l.iso} isn't enabled.`
+		})),
+		...agreements.map((a) => ({
+			id: `agreement:${a.localId}`,
+			ok: a.status === "linked" && (a.missingTranslations ?? []).length === 0,
+			detail: a.status === "linked" ? (a.missingTranslations ?? []).length > 0 ? `"${a.title}" is on the country but has no ${a.missingTranslations.join(", ")} translation. Enable the language, then run agreements --translate.` : `"${a.title}" is on the country.` : a.status === "inactive" ? `"${a.title}" is on the country but inactive, so checkout doesn't show it. Activate it in Settings > Agreements.` : a.status === "exists" ? `"${a.title}" exists but isn't on this country. Add the country to it in Settings > Agreements.` : `"${a.title}" hasn't been created.`
+		}))
+	];
+	const mode = (cc.mode ?? "").toLowerCase();
+	return {
+		country: countryCode,
+		open: true,
+		companyCountryId: cc.id,
+		testMode: cc.test_mode ?? null,
+		done: checks.every((c) => c.ok),
+		checks,
+		translations: (atlas.majorLanguages ?? []).map((iso) => ({
+			language: iso,
+			report: `fluid translations missing ${iso}`,
+			translate: `fluid translations auto ${iso} --write --yes`
+		})),
+		prices: {
+			preview: `fluid countries prices ${countryCode}`,
+			convert: `fluid countries prices ${countryCode} --rate <rate> --write --yes`
+		},
+		byHand: {
+			bundles: input.prices && input.prices.bundles.length > 0 ? {
+				how: `Check each bundle's price and availability in ${countryCode} in the bundle editor. Bundles can be priced from their groups, and each group can be switched off per country.`,
+				items: input.prices.bundles
+			} : null,
+			paymentMethods: sortedPaymentMethods(atlas).map((m) => ({
+				integrationType: m.integration_type,
+				name: m.name,
+				recommended: m.enabled
+			})),
+			enrollmentFields: [...atlas.enrollmentFormFields ?? []].sort((a, b) => a.order - b.order).map((f) => ({
+				id: f.id,
+				label: f.label,
+				component: f.component,
+				required: f.required
+			})),
+			activatePrices: "Put the products you will sell on sale in the country: run prices with --activate, or activate them per product.",
+			leaveTestMode: cc.test_mode === true ? "The country is in test mode. Turn test mode off when payments are configured." : null
+		},
+		launchChecklist: mode ? launchChecklist(atlas, mode) : []
+	};
+}
+//#endregion
+//#region src/shared/walk.ts
+/** Thrown by `ask` when the person moves instead of answering. */
+var NavSignal = class extends Error {
+	constructor(nav) {
+		super(`nav:${nav}`);
+		this.nav = nav;
+		this.name = "NavSignal";
+	}
+};
+/** Run the steps in order, honouring back, skip, the menu and stop. */
+async function runSteps(prompter, steps, options = {}) {
+	const history = [];
+	const completed = [];
+	const skipped = [];
+	if (options.help !== false) prompter.note(NAV_HELP);
+	let index = nextActive(steps, 0);
+	const ctxFor = (step) => ({
+		prompter,
+		note: (text) => prompter.note(text),
+		ask: async (question) => {
+			const reply = await prompter.ask({
+				...question,
+				section: step.title,
+				canGoBack: history.length > 0
+			});
+			if ("nav" in reply) throw new NavSignal(reply.nav);
+			return reply.value;
+		},
+		choose: async (message, choices, current) => {
+			const reply = await prompter.ask({
+				section: step.title,
+				message,
+				kind: "select",
+				choices,
+				...current !== void 0 ? { current } : {},
+				canGoBack: history.length > 0
+			});
+			if ("nav" in reply) throw new NavSignal(reply.nav);
+			return reply.value;
+		}
+	});
+	while (index < steps.length) {
+		const step = steps[index];
+		try {
+			await step.run(ctxFor(step));
+			if (!completed.includes(step.id)) completed.push(step.id);
+			history.push(index);
+			index = nextActive(steps, index + 1);
+		} catch (error) {
+			if (!(error instanceof NavSignal)) throw error;
+			let nav = error.nav;
+			let target = -1;
+			if (nav === "menu") {
+				const choice = await prompter.menu("What next?", [
+					{
+						title: "Continue",
+						value: "continue"
+					},
+					{
+						title: "Back to the previous step",
+						value: "back",
+						disabled: history.length === 0
+					},
+					{
+						title: "Skip this step",
+						value: "skip"
+					},
+					{
+						title: "Go to a step",
+						value: "goto"
+					},
+					{
+						title: "Stop for now",
+						value: "quit"
+					}
+				]);
+				if (choice === null || choice === "quit") nav = "quit";
+				else if (choice === "continue") continue;
+				else if (choice === "goto") {
+					const picked = await prompter.menu("Which step?", steps.map((s, i) => ({
+						s,
+						i
+					})).filter(({ s }) => !s.when || s.when()).map(({ s, i }) => ({
+						title: `${completed.includes(s.id) ? "✓" : " "} ${s.title}`,
+						value: String(i)
+					})));
+					if (picked === null) continue;
+					nav = "goto";
+					target = Number(picked);
+				} else nav = choice;
+			}
+			if (nav === "quit") return {
+				completed,
+				skipped,
+				stopped: true
+			};
+			if (nav === "back") {
+				const previous = history.pop();
+				if (previous === void 0) prompter.note("This is the first step.");
+				else index = previous;
+				continue;
+			}
+			if (nav === "skip") {
+				if (!skipped.includes(step.id)) skipped.push(step.id);
+				history.push(index);
+				index = nextActive(steps, index + 1);
+				continue;
+			}
+			if (nav === "goto") {
+				history.push(index);
+				index = target;
+			}
+		}
+	}
+	return {
+		completed,
+		skipped,
+		stopped: false
+	};
+}
+function nextActive(steps, from) {
+	let i = from;
+	while (i < steps.length && steps[i].when && !steps[i].when()) i += 1;
+	return i;
+}
+const YES_NO = [{
+	title: "Yes",
+	value: "yes"
+}, {
+	title: "No",
+	value: "no"
+}];
+//#endregion
+//#region src/countries/walk.ts
+/** One line per mode, so the choice reads without the atlas open. */
+const MODE_LINES = {
+	nfr: "Not For Resale: ship cross-border from a warehouse outside the country",
+	otg: "On The Ground: a local entity, local tax registration, local fulfilment",
+	usd: "Sell cross-border and charge in US dollars, usually digital goods"
+};
+const yes = (v) => v === "yes";
+/** The company_country body the walk would send: the atlas seed with the person's changes. */
+function draftAttributes(draft) {
+	if (!draft.atlas || draft.countryId === void 0 || !draft.mode) return {};
+	const body = companyCountryFromAtlas(draft.atlas, {
+		countryId: draft.countryId,
+		mode: draft.mode,
+		...draft.warehouseId !== void 0 ? { warehouseId: draft.warehouseId } : {}
+	});
+	for (const [key, value] of Object.entries(draft.overrides)) if (value === void 0) delete body[key];
+	else body[key] = value;
+	return body;
+}
+async function walkCountry(deps, options = {}) {
+	const { api, prompter } = deps;
+	const draft = {
+		languages: [],
+		createAgreements: [],
+		translateAgreements: [],
+		overrides: {},
+		legacyDefaults: false
+	};
+	const result = {
+		opened: false,
+		reseeded: false,
+		enabled: [],
+		agreementsCreated: [],
+		pricesWritten: 0,
+		stopped: false,
+		translate: [],
+		failures: []
+	};
+	let catalog;
+	let languages = [];
+	let reseed = false;
+	let confirmed = false;
+	const run = await runSteps(prompter, [
+		{
+			id: "country",
+			title: "Country",
+			run: async (ctx) => {
+				catalog ??= await listCatalogCountries(api);
+				for (;;) {
+					const found = await fetchAtlas(api, (await ctx.ask({
+						message: "Which country are you opening?",
+						kind: "search",
+						hint: "type to filter",
+						choices: catalog.map((c) => ({
+							title: `${c.name} (${c.iso})`,
+							value: c.iso
+						})),
+						...draft.iso ? { current: draft.iso } : options.iso ? { current: options.iso.toUpperCase() } : {}
+					})).toUpperCase());
+					if (!found.covered || !found.atlas) {
+						ctx.note(`Fluid has no Country Atlas for ${found.countryCode} yet, so there's nothing to seed it from. Open it by hand in Settings > Countries, or pick another country.`);
+						continue;
+					}
+					if (draft.iso !== found.countryCode) Object.assign(draft, {
+						mode: void 0,
+						warehouseId: void 0,
+						languages: [],
+						createAgreements: [],
+						translateAgreements: [],
+						overrides: {},
+						legacyDefaults: false
+					});
+					const entry = catalog.find((c) => c.iso.toUpperCase() === found.countryCode);
+					draft.iso = found.countryCode;
+					draft.name = entry?.name ?? found.countryCode;
+					draft.countryId = entry?.id;
+					draft.atlas = found.atlas;
+					draft.existing = await findCompanyCountry(api, found.countryCode);
+					return;
+				}
+			}
+		},
+		{
+			id: "atlas",
+			title: "Country Atlas",
+			run: async (ctx) => {
+				const atlas = draft.atlas;
+				ctx.note([
+					`${draft.name}: ${atlas.defaultCurrency}, ${atlas.taxSettings?.taxName ?? "no tax name"} ${atlas.taxSettings?.taxInclusive ? "included in prices" : "added at checkout"}, 3-D Secure ${atlas.requires3ds ? "required" : "not required"}.`,
+					`Languages: ${(atlas.majorLanguages ?? []).join(", ") || "none listed"}. Agreements: ${(atlas.agreements ?? []).length}. Payment methods: ${(atlas.paymentMethods ?? []).filter((m) => m.enabled).map((m) => m.name).join(", ") || "none recommended"}.`,
+					...draft.existing ? [`${draft.iso} is already open for this company (${draft.existing.mode ?? "no mode"}, ${draft.existing.currency ?? "no currency"}).`] : []
+				].join("\n"));
+				await ctx.choose("Continue with this country?", [{
+					title: "Continue",
+					value: "go"
+				}]);
+			}
+		},
+		{
+			id: "mode",
+			title: "Operating mode",
+			run: async (ctx) => {
+				const atlas = draft.atlas;
+				draft.mode = await ctx.choose("How will you operate there?", MODES.map((m) => ({
+					title: `${m.toUpperCase()} — ${MODE_LINES[m]}`,
+					value: m,
+					description: htmlToText(atlas.modes?.[m]?.overview ?? "").split("\n")[0]?.slice(0, 160)
+				})), draft.mode ?? ((draft.existing?.mode ?? "").toLowerCase() || void 0));
+			}
+		},
+		{
+			id: "warehouse",
+			title: "Warehouse",
+			when: () => draft.mode !== "usd",
+			run: async (ctx) => {
+				const warehouses = await listWarehouses(api);
+				if (warehouses.length === 0) {
+					ctx.note("This company has no warehouses yet; add one in Settings > Warehouses later.");
+					return;
+				}
+				const id = await ctx.choose("Which warehouse fulfils its orders?", [...warehouses.map((w) => ({
+					title: `${w.name}${w.country?.iso ? ` (${w.country.iso})` : ""}${w.active === false ? " — inactive" : ""}`,
+					value: String(w.id)
+				})), {
+					title: "Decide later",
+					value: "none"
+				}], draft.warehouseId !== void 0 ? String(draft.warehouseId) : void 0);
+				draft.warehouseId = id === "none" ? void 0 : Number(id);
+			}
+		},
+		{
+			id: "languages",
+			title: "Languages",
+			run: async (ctx) => {
+				languages = await listLanguages(api);
+				const states = languageStates(draft.atlas, languages);
+				draft.languages = [];
+				for (const state of states) {
+					if (state.enabled) {
+						ctx.note(`${state.name ?? state.iso} is already on.`);
+						continue;
+					}
+					if (state.languageId === null) {
+						ctx.note(`${state.iso} isn't in Fluid's language catalog, so it can't be turned on.`);
+						continue;
+					}
+					if (yes(await ctx.choose(`Turn on ${state.name ?? state.iso} for the whole company?`, YES_NO))) draft.languages.push(state.iso);
+				}
+			}
+		},
+		{
+			id: "agreements",
+			title: "Agreements",
+			run: async (ctx) => {
+				const atlas = draft.atlas;
+				const states = agreementStates(atlas, await listAgreements(api), draft.existing?.id ?? null);
+				draft.createAgreements = [];
+				draft.translateAgreements = [];
+				for (const state of states) if (state.status === "missing") {
+					if (yes(await ctx.choose(`Create "${state.title}"${state.requiredOnCheckout ? " (required at checkout)" : ""} in ${state.languages.join(", ")}?`, YES_NO))) draft.createAgreements.push(state.localId);
+				} else if ((state.status === "linked" || state.status === "inactive") && state.agreementId !== null) {
+					if (yes(await ctx.choose(`"${state.title}" is already on ${draft.iso}. Write the atlas translations onto it?`, YES_NO))) draft.translateAgreements.push({
+						localId: state.localId,
+						id: state.agreementId
+					});
+				} else ctx.note(`"${state.title}" exists but isn't on ${draft.iso}; add the country to it in Settings > Agreements.`);
+			}
+		},
+		{
+			id: "defaults",
+			title: "Atlas defaults",
+			run: async (ctx) => {
+				const seeded = draftAttributes({
+					...draft,
+					overrides: {}
+				});
+				const overrides = {};
+				const keep = async (label, shown) => await ctx.choose(`${label}: ${shown}`, [{
+					title: "Keep",
+					value: "keep"
+				}, {
+					title: "Change",
+					value: "change"
+				}]) === "keep";
+				const currency = String(seeded["currency"] ?? "");
+				if (!await keep("Currency", currency)) for (;;) {
+					const value = (await ctx.ask({
+						message: "Currency code",
+						kind: "text",
+						current: currency
+					})).trim().toUpperCase() || currency;
+					if (/^[A-Z]{3}$/.test(value)) {
+						overrides["currency"] = value;
+						break;
+					}
+					ctx.note(`"${value}" isn't a three-letter currency code, such as EUR.`);
+				}
+				const taxName = String(seeded["tax_name"] ?? "");
+				if (!await keep("Tax name", taxName || "(none)")) overrides["tax_name"] = (await ctx.ask({
+					message: "Tax name",
+					kind: "text",
+					current: taxName
+				})).trim() || taxName;
+				const inclusive = seeded["tax_inclusive_pricing"] === true;
+				if (!await keep("Prices include tax", inclusive ? "yes" : "no")) overrides["tax_inclusive_pricing"] = !inclusive;
+				const threeDs = seeded["requires_3ds"] === true;
+				if (!await keep("Card payments need 3-D Secure", threeDs ? "yes" : "no")) overrides["requires_3ds"] = !threeDs;
+				const order = seeded["payment_method_priority"] ?? [];
+				if (!await keep("Payment method order", order.join(", ") || "checkout's default")) {
+					const list = (await ctx.ask({
+						message: "Payment methods in order, comma-separated (empty for checkout's default)",
+						kind: "text",
+						current: order.join(", ")
+					})).split(",").map((m) => m.trim()).filter(Boolean);
+					overrides["payment_method_priority"] = list.length > 0 ? list : void 0;
+				}
+				const fields = seeded["address_fields"] ?? [];
+				if (fields.length > 0 && !await keep("Address layout", fields.map((f) => `${f.field}${f.required ? "*" : ""}`).join(", "))) {
+					overrides["address_fields"] = void 0;
+					ctx.note("Checkout's default address layout will be used; edit it in Settings > Countries.");
+				}
+				draft.overrides = overrides;
+			}
+		},
+		{
+			id: "legacy",
+			title: "Fluid's generic defaults",
+			when: () => !draft.existing,
+			run: async (ctx) => {
+				draft.legacyDefaults = await ctx.choose("Fluid can also add its generic country agreements and forms.", [{
+					title: "Use the atlas agreements and forms only",
+					value: "atlas"
+				}, {
+					title: "Also add Fluid's generic ones",
+					value: "legacy"
+				}], draft.legacyDefaults ? "legacy" : "atlas") === "legacy";
+			}
+		},
+		{
+			id: "confirm",
+			title: "Review",
+			run: async (ctx) => {
+				const body = draftAttributes(draft);
+				ctx.note([
+					`${draft.existing ? "Update" : "Open"} ${draft.name} (${draft.iso}) in ${draft.mode?.toUpperCase()} mode.`,
+					`Currency ${String(body["currency"])}, tax ${String(body["tax_name"] ?? "none")}${body["tax_inclusive_pricing"] ? " (included)" : ""}, 3-D Secure ${body["requires_3ds"] ? "on" : "off"}.`,
+					`Payment order: ${(body["payment_method_priority"] ?? []).join(", ") || "checkout's default"}.`,
+					`Languages to turn on: ${draft.languages.join(", ") || "none"}.`,
+					`Agreements to create: ${draft.createAgreements.length}; to translate: ${draft.translateAgreements.length}.`,
+					...draft.existing ? [] : [draft.legacyDefaults ? "Fluid's generic country agreements and forms will be added too." : "Only the atlas agreements and forms; Fluid's generic ones are left out."]
+				].join("\n"));
+				const choices = draft.existing ? [{
+					title: `Write these settings over ${draft.iso}'s current ones`,
+					value: "reseed"
+				}, {
+					title: `Keep ${draft.iso}'s settings; just do languages and agreements`,
+					value: "keep"
+				}] : [{
+					title: `Open ${draft.iso} now`,
+					value: "open"
+				}];
+				reseed = await ctx.choose("Ready?", choices) === "reseed";
+				confirmed = true;
+			}
+		}
+	]);
+	result.country = draft.iso;
+	if (run.stopped || !confirmed || !draft.iso) {
+		result.stopped = true;
+		prompter.note("Stopped. Nothing was changed.");
+		return result;
+	}
+	const iso = draft.iso;
+	try {
+		const body = draftAttributes(draft);
+		if (!draft.existing) {
+			draft.existing = await createCompanyCountry(api, body, draft.legacyDefaults);
+			result.opened = true;
+			prompter.note(`Opened ${iso}.`);
+		} else if (reseed) {
+			draft.existing = await updateCompanyCountry(api, draft.existing.id, body, draft.existing.revision);
+			result.reseeded = true;
+			prompter.note(`Updated ${iso}'s settings.`);
+		}
+	} catch (error) {
+		result.failures.push({
+			step: "open",
+			error: failureOf(error).error
+		});
+		prompter.note(`${iso} couldn't be saved: ${failureOf(error).error}. Nothing else was changed.`);
+		return result;
+	}
+	for (const code of draft.languages) {
+		const language = languages.find((l) => l.iso.toLowerCase() === code.toLowerCase());
+		if (!language) continue;
+		try {
+			await enableLanguage(api, language);
+			result.enabled.push(language.iso);
+		} catch (error) {
+			result.failures.push({
+				step: `language:${code}`,
+				error: failureOf(error).error
+			});
+		}
+	}
+	if (result.enabled.length > 0) prompter.note(`Turned on ${result.enabled.join(", ")}.`);
+	for (const localId of draft.createAgreements) try {
+		const created = await createAgreementFromAtlas(api, atlasAgreement(draft.atlas, localId), draft.existing.id);
+		result.agreementsCreated.push(localId);
+		for (const f of created.failedTranslations) result.failures.push({
+			step: `agreement:${localId}:${f.language}`,
+			error: f.error
+		});
+	} catch (error) {
+		result.failures.push({
+			step: `agreement:${localId}`,
+			error: failureOf(error).error
+		});
+	}
+	for (const { localId, id } of draft.translateAgreements) {
+		const written = await writeTranslations(api, id, atlasAgreement(draft.atlas, localId));
+		for (const f of written.failedTranslations) result.failures.push({
+			step: `agreement:${localId}:${f.language}`,
+			error: f.error
+		});
+	}
+	if (draft.createAgreements.length + draft.translateAgreements.length > 0) prompter.note(`Agreements: ${result.agreementsCreated.length} created, ${draft.translateAgreements.length} translated.`);
+	for (const failure of result.failures) prompter.note(`Not saved (${failure.step}): ${failure.error}`);
+	const priced = await offerPrices(deps, iso);
+	result.pricesWritten = priced.written;
+	for (const f of priced.failed) result.failures.push({
+		step: `price:variant:${f.variantId}`,
+		error: f.error
+	});
+	const toTranslate = (draft.atlas.majorLanguages ?? []).filter((code) => {
+		const language = languages.find((l) => l.iso.toLowerCase() === code.toLowerCase());
+		return language?.active || result.enabled.includes(language?.iso ?? "");
+	});
+	for (const code of toTranslate) {
+		const answer = await prompter.menu(`Translate the storefront into ${code} now?`, [{
+			title: "Yes, walk through it",
+			value: "walk",
+			disabled: !deps.translate
+		}, {
+			title: "Later",
+			value: "later"
+		}]);
+		result.translate.push(code);
+		if (answer === "walk" && deps.translate) {
+			const walked = await deps.translate(code);
+			for (const f of walked?.failed ?? []) result.failures.push({
+				step: `translation:${code}:${f.id}`,
+				error: f.error
+			});
+		} else prompter.note(`Later: fluid translations walk ${code}`);
+	}
+	const checklist = draft.mode ? launchChecklist(draft.atlas, draft.mode) : [];
+	if (checklist.length > 0) prompter.note(`Before you launch (${draft.mode.toUpperCase()}):\n${checklist.map((c) => `- ${c.label}`).join("\n")}`);
+	prompter.note(`Check the result any time with: fluid countries status ${iso}`);
+	return result;
+}
+/** Show the conversion preview, ask for the rate, and write on a yes. */
+async function offerPrices(deps, iso) {
+	const none = {
+		written: 0,
+		failed: []
+	};
+	const { api, prompter } = deps;
+	const countries = await listCompanyCountries(api);
+	const target = companyCountryIn(countries, iso);
+	const source = companyCountryIn(countries, "US");
+	if (!target?.country || !source?.currency || !target.currency) {
+		prompter.note(`No US prices to convert from${source ? "" : " (the company doesn't sell in the US)"}. Convert from another country later with: fluid countries prices ${iso} --from-country <iso>`);
+		return none;
+	}
+	const from = source.currency.toUpperCase();
+	const to = target.currency.toUpperCase();
+	const reference = from === to ? {
+		rate: 1,
+		date: "",
+		source: "same currency"
+	} : await (deps.fetchRate ?? referenceRate)(from, to);
+	const editor = await priceEditorOwnsPrices(api);
+	const products = await listProductsWithVariants(api, ["active"]);
+	for (;;) {
+		const raw = await prompter.ask({
+			section: "Prices",
+			message: `Exchange rate, ${to} per ${from}${reference ? ` (reference ${reference.rate}${reference.date ? `, ${reference.date}` : ""})` : ""}`,
+			kind: "text",
+			hint: "Enter to use it, > to skip prices",
+			...reference ? { current: String(reference.rate) } : {},
+			canGoBack: false
+		});
+		if ("nav" in raw) {
+			prompter.note(`Prices skipped. Later: fluid countries prices ${iso}`);
+			return none;
+		}
+		const rate = Number(raw.value.trim() || reference?.rate);
+		if (!Number.isFinite(rate) || rate <= 0) {
+			prompter.note("Type a positive number, such as 0.92.");
+			continue;
+		}
+		const options = {
+			sourceIso: "US",
+			targetIso: iso,
+			targetCountryId: target.country.id,
+			targetCurrency: to,
+			rate,
+			fields: DEFAULT_PRICE_FIELDS,
+			overwrite: false,
+			activate: false
+		};
+		const plans = planConversion(products, options);
+		const summary = summarizePlans(plans, 5);
+		prompter.note([
+			`At ${rate} ${to} per ${from}, rounded half up to ${currencyDecimals(to)} decimals:`,
+			`${summary.toConvert} of ${summary.variants} variants get a price; ${summary.skipped.alreadyPriced} already have one, ${summary.skipped.noSourcePrice} have no US price, ${summary.skipped.roundsToZero} would round to zero.`,
+			...summary.sample.map((s) => `  ${s.product ?? s.productId}${s.sku ? ` (${s.sku})` : ""}: ${String(s.before.price ?? "—")} → ${String(s.after.price)} ${to}`),
+			...editor ? ["Your prices are managed in the price editor; any it can't take are listed."] : []
+		].join("\n"));
+		if (summary.toConvert === 0) return none;
+		const answer = await prompter.menu(`Save ${summary.toConvert} prices in ${to}?`, [
+			{
+				title: "Save them",
+				value: "write"
+			},
+			{
+				title: "Use a different rate",
+				value: "rate"
+			},
+			{
+				title: "Not now",
+				value: "later"
+			}
+		]);
+		if (answer === "rate") continue;
+		if (answer !== "write") {
+			prompter.note(`Prices skipped. Later: fluid countries prices ${iso} --rate ${rate} --write --yes`);
+			return none;
+		}
+		const written = await writeConversion(api, plans, options);
+		prompter.note(`Saved ${written.written.length} prices${written.failed.length > 0 ? `; ${written.failed.length} refused:\n${written.failed.map((f) => `  variant ${f.variantId}: ${f.error}`).join("\n")}` : "."}`);
+		return {
+			written: written.written.length,
+			failed: written.failed.map((f) => ({
+				variantId: f.variantId,
+				error: f.error
+			}))
+		};
+	}
+}
+//#endregion
+//#region src/translations/resources.ts
+/** Types whose source text is in the store's default language (theme types use --from). */
+function readsInStoreLanguage(type) {
+	return type.kind !== "theme" && type.kind !== "theme-sections";
+}
+function storefront(type, label, bodyKey, fields, urlFields = ["image_url"], showKey = bodyKey) {
+	return {
+		kind: "storefront",
+		type,
+		label,
+		path: type,
+		bodyKey,
+		showKey,
+		listKey: type.replace(/-/g, "_"),
+		fields: [...fields, ...urlFields],
+		textFields: fields
+	};
+}
+/**
+* The field sets match what fluid-admin's translation sheets read and write,
+* which in turn match each v2026-04 write schema's locale-scoped fields.
+* Enrollment packs have no per-locale image on that schema.
+*/
+const RESOURCE_TYPES = [
+	storefront("products", "Products", "product", [
+		"title",
+		"introduction",
+		"description",
+		"feature_text"
+	]),
+	storefront("categories", "Categories", "category", ["title", "description"]),
+	storefront("collections", "Collections", "collection", ["title", "description"]),
+	storefront("pages", "Pages", "page", ["title", "description"]),
+	storefront("posts", "Posts", "post", [
+		"title",
+		"description",
+		"summary"
+	]),
+	storefront("media", "Media", "medium", ["title", "description"], [
+		"image_url",
+		"video_url",
+		"pdf_url"
+	]),
+	storefront("playlists", "Playlists", "library", ["title", "description"], ["image_url"], "playlist"),
+	storefront("enrollment-packs", "Enrollment packs", "enrollment_pack", ["title", "description"], []),
+	{
+		kind: "menu-items",
+		type: "menu-items",
+		label: "Navigation menu items",
+		fields: ["title"],
+		textFields: ["title"]
+	},
+	{
+		kind: "theme",
+		type: "theme",
+		label: "Theme strings (locales/<iso>.json)",
+		fields: ["<key.path>"],
+		textFields: ["<key.path>"]
+	},
+	{
+		kind: "theme-sections",
+		type: "theme-sections",
+		label: "Theme page strings (a template's own translations)",
+		fields: ["<key.path>"],
+		textFields: ["<key.path>"]
+	},
+	{
+		kind: "agreements",
+		type: "agreements",
+		label: "Agreements",
+		fields: ["title", "description"],
+		textFields: ["title", "description"]
+	},
+	{
+		kind: "labels",
+		type: "labels",
+		label: "Product labels",
+		fields: ["title"],
+		textFields: ["title"]
+	}
+];
+const TYPE_NAMES = RESOURCE_TYPES.map((t) => t.type);
+function resourceType(name) {
+	const wanted = name.trim().toLowerCase();
+	const match = RESOURCE_TYPES.find((t) => t.type === wanted);
+	if (!match) throw new LocalizationError(`"${name}" isn't a translatable type. Use one of: ${TYPE_NAMES.join(", ")}.`);
+	return match;
+}
+/** The types `--type` selects, or every type when none is given. */
+function selectTypes(names) {
+	if (names.length === 0) return [...RESOURCE_TYPES];
+	const picked = names.flatMap((name) => name.split(",")).filter((name) => name.trim().length > 0).map(resourceType);
+	return RESOURCE_TYPES.filter((t) => picked.includes(t));
+}
+/** Reject fields a type can't translate, so a typo never reaches the API. */
+function checkFields(type, fields) {
+	const unknown = Object.keys(fields).filter((f) => !type.fields.includes(f));
+	if (unknown.length > 0) throw new LocalizationError(`${type.label} can't translate ${unknown.join(", ")}. Translatable fields: ${type.fields.join(", ")}.`);
+	if (Object.keys(fields).length === 0) throw new LocalizationError(`Pass at least one field, e.g. --set title=... (${type.fields.join(", ")}).`);
+}
+//#endregion
+//#region src/translations/storefront.ts
+const PAGE_LIMIT = 100;
+/** A guard against a cursor that never ends; 1,000 pages is 100,000 rows. */
+const MAX_PAGES$1 = 1e3;
+function companyPath(type, id) {
+	return `/api/v202604/company/${type.path}${id === void 0 ? "" : `/${id}`}`;
+}
+/** Every row of a type, following the cursor. Rows are in the default locale. */
+async function listAll(client, type) {
+	const rows = [];
+	let cursor;
+	for (let page = 0; page < MAX_PAGES$1; page += 1) {
+		const data = await client.get(companyPath(type), {
+			"page[limit]": PAGE_LIMIT,
+			...cursor ? { "page[cursor]": cursor } : {}
+		});
+		const batch = data[type.listKey];
+		if (Array.isArray(batch)) rows.push(...batch);
+		cursor = data.meta?.pagination?.next_cursor;
+		if (!cursor) return rows;
+	}
+	throw new LocalizationError(`${type.label} has more than ${MAX_PAGES$1 * PAGE_LIMIT} rows, more than one run can list. Translate it in fluid-admin or through the API.`);
+}
+/** One row, read in `lang` (fields with no translation fall back to `en`). */
+async function getRow(client, type, id, lang) {
+	let data;
+	try {
+		data = await client.get(companyPath(type, id), lang ? { lang } : void 0);
+	} catch (error) {
+		if (statusOf(error) === 404) throw new LocalizationError(`No ${type.label.toLowerCase()} row with id ${id}.`);
+		throw error;
+	}
+	const row = data[type.showKey];
+	if (!row || typeof row !== "object") throw new LocalizationError(`The API returned no ${type.showKey} for id ${id}.`);
+	return row;
+}
+/** The locales a row is translated into, always including the default. */
+function rowLanguages(row) {
+	const languages = row["languages"];
+	return Array.isArray(languages) ? languages.filter((l) => typeof l === "string") : [];
+}
+function isTranslated(row, iso) {
+	const wanted = iso.toLowerCase();
+	return rowLanguages(row).some((l) => l.toLowerCase() === wanted);
+}
+/**
+* Rich-text fields (descriptions on products, media, and enrollment packs)
+* can come back as a string or as `{ body }`. Normalize to a string, or
+* null when there is no value.
+*/
+function fieldText(value) {
+	if (typeof value === "string") return value.length > 0 ? value : null;
+	if (value && typeof value === "object") {
+		const body = value.body;
+		if (typeof body === "string") return body.length > 0 ? body : null;
+	}
+	return null;
+}
+/** A row's translatable fields as strings (or null), in `fields` order. */
+function pickFields(row, fields) {
+	return Object.fromEntries(fields.map((f) => [f, fieldText(row[f])]));
+}
+function rowTitle(row) {
+	return fieldText(row["title"]);
+}
+/**
+* Write one locale's translated fields. A translation PATCH writes only the
+* translated fields on every resource except products, where any other field
+* sent would also apply; the caller sends translated fields only.
+*/
+async function writeTranslation(client, type, id, lang, fields) {
+	const data = await client.patch(`${companyPath(type, id)}?lang=${encodeURIComponent(lang)}`, { [type.bodyKey]: fields });
+	const row = data[type.showKey] ?? data[type.bodyKey];
+	return row && typeof row === "object" ? row : { id };
+}
+/**
+* The store's default language. Every row's `languages` lists it first, so
+* the first row of any storefront type answers; null for an empty catalog.
+*/
+async function storeDefaultIso(client, types) {
+	for (const type of types) {
+		let data;
+		try {
+			data = await client.get(companyPath(type), { "page[limit]": 1 });
+		} catch {
+			continue;
+		}
+		const batch = data[type.listKey];
+		const first = Array.isArray(batch) ? batch[0] : void 0;
+		const iso = first ? rowLanguages(first)[0] : void 0;
+		if (iso) return iso;
+	}
+	return null;
+}
+//#endregion
+//#region src/translations/auto-languages.ts
+/**
+* The languages a machine translation runs between. Storefront rows, menu
+* items, agreements and labels read back in the store's default language,
+* so that is the language the translator is told they're in; it's read from
+* the rows (selected storefront types first), `storeLanguage` only fills in
+* when they can't be read, and it's never guessed. Theme strings translate
+* from `from`.
+*/
+async function autoLanguages(api, types, options) {
+	const target = options.write ? await requireActiveLanguage(api, options.iso) : await findLanguage(api, options.iso);
+	const source = await findLanguage(api, options.from);
+	let store = source;
+	if (types.some(readsInStoreLanguage)) {
+		const storeIso = await storeDefaultIso(api, [...types.filter((t) => t.kind === "storefront"), ...RESOURCE_TYPES.filter((t) => t.kind === "storefront" && !types.includes(t))]) ?? options.storeLanguage;
+		if (!storeIso) throw new LocalizationError("Couldn't read the store's default language from its storefront rows. Pass --store-language <iso>.");
+		store = sameIso(storeIso, source.iso) ? source : await findLanguage(api, storeIso);
+		if (sameIso(store.iso, target.iso)) throw new LocalizationError(`${target.name} is the store's default language, so storefront content in it is the source, not a translation. Use --type theme --type theme-sections to translate only theme strings.`);
+	}
+	if (types.some((t) => !readsInStoreLanguage(t)) && sameIso(source.iso, target.iso)) throw new LocalizationError(`--from and the target are both ${target.iso}; pass --from with the theme's source locale.`);
+	return {
+		target,
+		source,
+		store
+	};
+}
+//#endregion
+//#region src/translations/labels.ts
+const LABELS_PATH = "/api/company/labels";
+/**
+* The company's labels in the default language. The list isn't paginated and
+* holds only the labels an admin created; Fluid's own labels ("New",
+* "Trending") are translated by Fluid and can't be changed.
+*/
+async function listLabels(client) {
+	return ((await client.get(LABELS_PATH)).label ?? []).map((wire) => ({
+		id: wire.id,
+		title: wire.title ?? ""
+	}));
+}
+/** One label's title in `lang`, or in the default language without one. */
+async function getLabelTitle(client, id, lang) {
+	try {
+		return (await client.get(`${LABELS_PATH}/${id}`, lang ? { lang } : void 0)).label?.title ?? "";
+	} catch (error) {
+		if (statusOf(error) === 404) throw new LocalizationError(`No label with id ${id}, or it's one of Fluid's own labels, which Fluid translates.`);
+		throw error;
+	}
+}
+/** Whether a label's title in `lang` differs from its default title. */
+function labelTranslated(source, translated) {
+	return translated.trim().length > 0 && translated.trim() !== source.trim();
+}
+async function writeLabelTitle(client, id, lang, title) {
+	await client.put(`${LABELS_PATH}/${id}?lang=${encodeURIComponent(lang)}`, { label: { title } });
+}
+/**
+* Machine-translate id-keyed strings with Fluid AI
+* (`POST /api/v202604/ai/translate`). Languages are named, not coded
+* ("english", "french"), which is what the endpoint expects. Nothing is
+* saved; the caller writes the results back.
+*/
+async function machineTranslate(client, sourceLanguage, targetLanguage, fields, model) {
+	const entries = Object.entries(fields).filter(([, v]) => v.trim().length > 0);
+	const result = {
+		translations: {},
+		usage: {
+			inputTokens: 0,
+			outputTokens: 0
+		}
+	};
+	for (let start = 0; start < entries.length; start += 40) {
+		const batch = Object.fromEntries(entries.slice(start, start + 40));
+		const data = await client.post("/api/v202604/ai/translate", {
+			source_language: languageName(sourceLanguage),
+			target_language: languageName(targetLanguage),
+			fields: batch,
+			...model ? { model } : {}
+		});
+		for (const id of Object.keys(batch)) {
+			const value = data.translations?.[id];
+			if (typeof value === "string" && value.trim().length > 0) result.translations[id] = value;
+		}
+		result.usage.inputTokens += data.usage?.input_tokens ?? 0;
+		result.usage.outputTokens += data.usage?.output_tokens ?? 0;
+	}
+	return result;
+}
+/** "Spanish" → "spanish"; the endpoint takes lowercase names up to 64 characters. */
+function languageName(name) {
+	const value = name.trim().toLowerCase();
+	if (value.length === 0 || value.length > 64) throw new LocalizationError(`"${name}" isn't a usable language name.`);
+	return value;
+}
+//#endregion
+//#region src/translations/menus.ts
+const PER_PAGE = 100;
+const MAX_PAGES = 50;
+/**
+* Every menu item of every menu, flattened. With `lang`, titles come back
+* without the English fallback, so an item with no translation reads null.
+*/
+async function listMenuItems(client, lang) {
+	const items = [];
+	for (let page = 1; page <= MAX_PAGES; page += 1) {
+		const data = await client.get("/api/menus", {
+			page,
+			per_page: PER_PAGE,
+			...lang ? { lang } : {}
+		});
+		const menus = data.menus ?? [];
+		for (const menu of menus) flatten(menu, menu.menu_items ?? [], items);
+		const totalPages = data.meta?.total_pages ?? 1;
+		if (page >= totalPages || menus.length < PER_PAGE) return items;
+	}
+	throw new LocalizationError(`More than ${MAX_PAGES * PER_PAGE} menus.`);
+}
+function flatten(menu, nodes, out) {
+	for (const node of nodes) {
+		out.push({
+			id: `${menu.id}/${node.id}`,
+			menuId: menu.id,
+			itemId: node.id,
+			menu: menu.title ?? null,
+			title: typeof node.title === "string" && node.title.length > 0 ? node.title : null
+		});
+		flatten(menu, node.sub_menu_items ?? [], out);
+	}
+}
+/** Parse a `<menu id>/<item id>` reference. */
+function parseMenuItemId(ref) {
+	const match = /^(\d+)\/(\d+)$/.exec(ref.trim());
+	if (!match) throw new LocalizationError(`"${ref}" isn't a menu item id. Use <menu id>/<item id>, as \`fluid translations missing\` prints it, e.g. 12/340.`);
+	return {
+		menuId: Number(match[1]),
+		itemId: Number(match[2])
+	};
+}
+/** One menu item's title in the default locale and, without fallback, in `lang`. */
+async function getMenuItem(client, ref, lang) {
+	const { menuId, itemId } = parseMenuItemId(ref);
+	const path = `/api/menus/${menuId}/menu_items/${itemId}`;
+	const [source, translated] = await Promise.all([client.get(path), client.get(path, { lang })]);
+	const text = (wire) => typeof wire?.title === "string" && wire.title.length > 0 ? wire.title : null;
+	return {
+		source: text(source.menu_item),
+		translated: text(translated.menu_item)
+	};
+}
+async function writeMenuItemTitle(client, ref, lang, title) {
+	const { menuId, itemId } = parseMenuItemId(ref);
+	const data = await client.patch(`/api/menus/${menuId}/menu_items/${itemId}?lang=${encodeURIComponent(lang)}`, { menu_item: { title } });
+	return {
+		id: `${menuId}/${itemId}`,
+		title: data.menu_item?.title ?? null
+	};
+}
+//#endregion
+//#region src/translations/theme.ts
+/** The theme to work on: `--theme <id>`, else the company's active theme. */
+async function resolveThemeId(client, themeId) {
+	if (themeId !== void 0) {
+		const id = Number(themeId);
+		if (!Number.isInteger(id) || id <= 0) throw new LocalizationError(`"${themeId}" isn't a theme id.`);
+		return id;
+	}
+	try {
+		const data = await client.get("/api/v202604/themes/active");
+		if (typeof data.theme?.id === "number") return data.theme.id;
+	} catch (error) {
+		if (statusOf(error) !== 404) throw error;
+	}
+	throw new LocalizationError("This company has no active theme. Pass --theme <id> to work on another theme.");
+}
+/**
+* Every `locales/<iso>.json` file on the theme, plus the theme's
+* `content_version_sha`, from one read of the theme resources API.
+*/
+async function readThemeLocales(client, themeId) {
+	let data;
+	try {
+		data = await client.get(`/api/application_themes/${themeId}/resources`);
+	} catch (error) {
+		if (statusOf(error) !== 422) throw error;
+		return readLocaleTemplates(client, themeId);
+	}
+	const files = /* @__PURE__ */ new Map();
+	for (const resource of data.application_theme_resources ?? []) {
+		const match = /^locales\/([^/]+)\.json$/.exec(resource.key ?? "");
+		if (!match) continue;
+		const iso = match[1];
+		files.set(iso.toLowerCase(), {
+			iso,
+			doc: parseLocale(resource.content, resource.key)
+		});
+	}
+	return {
+		themeId,
+		sha: data.content_version_sha ?? null,
+		files
+	};
+}
+/** Locale files through the v2026-04 templates endpoints, with no theme version. */
+async function readLocaleTemplates(client, themeId) {
+	const list = await client.get(`/api/v202604/themes/${themeId}/templates`, { themeable_type: "locales" });
+	const files = /* @__PURE__ */ new Map();
+	for (const summary of list.templates ?? []) {
+		if (!summary.name) continue;
+		const data = await client.get(`/api/v202604/themes/${themeId}/templates/${summary.id}`);
+		const key = `locales/${summary.name}.json`;
+		files.set(summary.name.toLowerCase(), {
+			iso: summary.name,
+			doc: parseLocale(data.template?.content, key)
+		});
+	}
+	return {
+		themeId,
+		sha: null,
+		files
+	};
+}
+/** One locale file from a read, or null when the theme has none. */
+function localeOf(locales, iso) {
+	return locales.files.get(iso.toLowerCase())?.doc ?? null;
+}
+function parseLocale(content, key) {
+	if (content === null || content === void 0 || content === "") return {};
+	if (typeof content === "object" && !Array.isArray(content)) return content;
+	if (typeof content === "string") try {
+		const parsed = JSON.parse(content);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	throw new LocalizationError(`${key} isn't a JSON object; fix it before translating.`);
+}
+/** Leaf strings keyed by dotted path: `{ cart: { title: "Cart" } }` → `cart.title`. */
+function flattenLocale(doc, prefix = "") {
+	const out = {};
+	for (const [key, value] of Object.entries(doc)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (typeof value === "string") out[path] = value;
+		else if (value && typeof value === "object" && !Array.isArray(value)) Object.assign(out, flattenLocale(value, path));
+	}
+	return out;
+}
+/** Keys the source locale has that the target lacks or leaves blank. */
+function missingKeys(source, target) {
+	const have = flattenLocale(target ?? {});
+	const missing = {};
+	for (const [key, value] of Object.entries(flattenLocale(source))) {
+		if (value.trim().length === 0) continue;
+		if ((have[key] ?? "").trim().length === 0) missing[key] = value;
+	}
+	return missing;
+}
+/**
+* Keys whose target value is still the source text word for word. Some are
+* right as they are (a brand name, "OK", a SKU); the rest were copied and
+* never translated. They aren't counted as missing, so they're listed for
+* review instead.
+*/
+function sameAsSourceKeys(source, target) {
+	const have = flattenLocale(target ?? {});
+	return Object.entries(flattenLocale(source)).filter(([key, value]) => /\p{L}/u.test(value) && have[key] === value).map(([key]) => key);
+}
+/** A copy of `doc` with each dotted key set to its value. */
+function mergeLocale(doc, updates) {
+	const out = structuredClone(doc);
+	for (const [path, value] of Object.entries(updates)) {
+		const parts = keyPath(path);
+		let node = out;
+		for (const part of parts.slice(0, -1)) {
+			const next = Object.hasOwn(node, part) ? node[part] : void 0;
+			if (typeof next === "string") throw new LocalizationError(`"${path}" would replace the string at "${part}" with an object.`);
+			if (!next || typeof next !== "object" || Array.isArray(next)) node[part] = {};
+			node = node[part];
+		}
+		const leaf = parts[parts.length - 1];
+		if (Object.hasOwn(node, leaf) && node[leaf] && typeof node[leaf] === "object") throw new LocalizationError(`"${path}" is a group of keys, not a string.`);
+		node[leaf] = value;
+	}
+	return out;
+}
+/**
+* Save `locales/<iso>.json` through the theme resources API, creating the
+* file if the theme has none. `base_sha` is the version the file was read
+* at, so the server refuses the write (409) if the theme changed since,
+* rather than overwriting someone else's edit. A read with no version
+* (the fallback for an invalid member configuration) can't be saved. The
+* write publishes immediately.
+*/
+async function writeLocale(client, locales, iso, doc) {
+	if (!locales.sha) throw new LocalizationError(`Theme ${locales.themeId}'s files can't be listed (its member configuration is invalid), so the CLI can read its locale files but can't save them safely. Fix the theme's member configuration, or edit the locale file in the theme editor.`);
+	const key = `locales/${locales.files.get(iso.toLowerCase())?.iso ?? iso}.json`;
+	try {
+		await client.put(`/api/application_themes/${locales.themeId}/resources`, {
+			application_theme_resource: {
+				key,
+				content: JSON.stringify(doc, null, 2)
+			},
+			base_sha: locales.sha
+		});
+	} catch (error) {
+		if (statusOf(error) === 409) throw Object.assign(new LocalizationError(`Theme ${locales.themeId} changed after it was read, so ${key} wasn't saved. Run the command again to merge onto the latest version.`), { status: 409 });
+		throw error;
+	}
+	return {
+		key,
+		saved: true
+	};
+}
+//#endregion
+//#region src/translations/sections.ts
+/**
+* Template kinds that never render as a page of their own, so their
+* `translations` aren't read: shared sections, blocks and components, the
+* locale files themselves, layouts, and configuration.
+*/
+const NOT_PAGES = new Set([
+	"sections",
+	"blocks",
+	"components",
+	"locales",
+	"layouts",
+	"config"
+]);
+function asTranslations(value) {
+	if (typeof value === "string") try {
+		return asTranslations(JSON.parse(value));
+	} catch {
+		return {};
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out = {};
+	for (const [locale, doc] of Object.entries(value)) if (doc && typeof doc === "object" && !Array.isArray(doc)) out[locale] = doc;
+	return out;
+}
+/** One locale's strings from a template's translations, matching the code's casing. */
+function localeIn(translations, iso) {
+	const key = Object.keys(translations).find((k) => k.toLowerCase() === iso.toLowerCase());
+	return key ? translations[key] ?? null : null;
+}
+async function readTemplateTranslations(client, themeId, templateId) {
+	const data = await client.get(`/api/v202604/themes/${themeId}/templates/${templateId}`);
+	return {
+		templateId,
+		name: data.template?.name ?? null,
+		translations: asTranslations(data.template?.translations)
+	};
+}
+/**
+* Every page template of the theme that has translations. The template list
+* carries no translations, so each page template is read on its own.
+*/
+async function listTemplateTranslations(client, themeId) {
+	const list = await client.get(`/api/v202604/themes/${themeId}/templates`);
+	const out = [];
+	for (const summary of list.templates ?? []) {
+		if (NOT_PAGES.has(summary.themeable_type ?? "")) continue;
+		const template = await readTemplateTranslations(client, themeId, summary.id);
+		if (Object.keys(template.translations).length > 0) out.push(template);
+	}
+	return out;
+}
+/** The keys a template's source locale has and the target lacks, as `<template>/<key>` ids. */
+function missingSectionKeys(templates, sourceIso, iso) {
+	let total = 0;
+	const missing = [];
+	for (const template of templates) {
+		const source = localeIn(template.translations, sourceIso);
+		if (!source) continue;
+		total += Object.keys(missingKeys(source, null)).length;
+		for (const [key, value] of Object.entries(missingKeys(source, localeIn(template.translations, iso)))) missing.push({
+			id: `${template.templateId}/${key}`,
+			templateId: template.templateId,
+			key,
+			source: value
+		});
+	}
+	return {
+		total,
+		missing
+	};
+}
+/** Parse a `<template id>/<key.path>` reference. */
+function parseSectionRef(ref) {
+	const match = /^([1-9]\d*)\/(.+)$/.exec(ref.trim());
+	if (!match) throw new LocalizationError(`"${ref}" isn't a theme section string. Use <template id>/<key>, as \`fluid translations missing\` prints it, e.g. 412/hero.title.`);
+	return {
+		templateId: Number(match[1]),
+		key: match[2]
+	};
+}
+/** A section string's source and translated text. */
+function sectionText(template, key, sourceIso, iso) {
+	const source = flattenLocale(localeIn(template.translations, sourceIso) ?? {})[key] ?? null;
+	const translation = flattenLocale(localeIn(template.translations, iso) ?? {})[key] ?? null;
+	return {
+		source,
+		translation: translation && translation.trim().length > 0 ? translation : null
+	};
+}
+/**
+* Save strings into one template's translations for `iso`. The template is
+* read again just before the write and the strings merged into what it holds
+* then, because the API replaces the whole translations object.
+*/
+async function writeSectionStrings(client, themeId, templateId, iso, updates) {
+	const fresh = await readTemplateTranslations(client, themeId, templateId);
+	const key = Object.keys(fresh.translations).find((k) => k.toLowerCase() === iso.toLowerCase()) ?? iso;
+	const merged = mergeLocale(fresh.translations[key] ?? {}, updates);
+	await client.patch(`/api/application_theme_templates/${templateId}`, { application_theme_template: { translations: {
+		...fresh.translations,
+		[key]: merged
+	} } });
+	return {
+		templateId,
+		keys: Object.keys(updates)
+	};
+}
+//#endregion
+//#region src/translations/report.ts
+/**
+* What still needs translating into `iso`, per type. Storefront rows count as
+* translated once `languages` lists the locale; menu items once their title
+* has a value in the locale; theme keys once `locales/<iso>.json` has a
+* non-blank string for every key the source locale file has; theme page
+* strings the same way within each template's translations; agreements once
+* a read in the locale is served in it; labels once their title in the
+* locale differs from the default.
+*/
+async function missingReport(client, iso, types, options) {
+	const reports = [];
+	for (const type of types) if (type.kind === "storefront") reports.push(await storefrontReport(client, type, iso, options));
+	else if (type.kind === "menu-items") reports.push(await menuReport(client, iso));
+	else if (type.kind === "theme") reports.push(await unlessNoTheme(type, () => themeReport(client, iso, options)));
+	else if (type.kind === "theme-sections") reports.push(await unlessNoTheme(type, () => sectionsReport(client, iso, options)));
+	else if (type.kind === "agreements") reports.push(await agreementsReport(client, iso, options));
+	else reports.push(await labelsReport(client, iso));
+	return {
+		done: reports.every((r) => r.missingCount === 0 && !r.skipped),
+		types: reports
+	};
+}
+/** A theme type on a company with no theme to read is reported as skipped, not as a failure. */
+async function unlessNoTheme(type, report) {
+	try {
+		return await report();
+	} catch (error) {
+		if (!(error instanceof LocalizationError) || !/no active theme/.test(error.message)) throw error;
+		return {
+			type: type.type,
+			label: type.label,
+			total: 0,
+			missingCount: 0,
+			missing: [],
+			skipped: error.message
+		};
+	}
+}
+/** Whether shoppers can see a row: published (when it has a status) and not switched off. */
+function shopperVisible(row) {
+	const status = row["status"];
+	if (typeof status === "string" && status !== "published") return false;
+	return row["active"] !== false;
+}
+async function storefrontReport(client, type, iso, options) {
+	const rows = (await listAll(client, type)).filter((row) => !options.publishedOnly || shopperVisible(row));
+	const missing = rows.filter((row) => !isTranslated(row, iso)).map((row) => ({
+		id: row.id,
+		source: rowTitle(row),
+		status: typeof row["status"] === "string" ? row["status"] : null
+	}));
+	return {
+		type: type.type,
+		label: type.label,
+		total: rows.length,
+		missingCount: missing.length,
+		missing
+	};
+}
+/** Menu items with a default title, and those with no title in `iso`. */
+async function missingMenuItems(client, iso) {
+	const [source, translated] = await Promise.all([listMenuItems(client), listMenuItems(client, iso)]);
+	const have = new Map(translated.map((item) => [item.id, item.title]));
+	const titled = source.filter((item) => item.title !== null);
+	return {
+		titled,
+		missing: titled.filter((item) => !have.get(item.id))
+	};
+}
+async function menuReport(client, iso) {
+	const { titled, missing } = await missingMenuItems(client, iso);
+	return {
+		type: "menu-items",
+		label: "Navigation menu items",
+		total: titled.length,
+		missingCount: missing.length,
+		missing: missing.map((item) => ({
+			id: item.id,
+			source: item.title,
+			menu: item.menu
+		}))
+	};
+}
+/** Theme keys the source locale has and `iso` lacks, with the source strings. */
+async function missingThemeKeys(client, iso, options) {
+	const themeId = await resolveThemeId(client, options.themeId);
+	const locales = await readThemeLocales(client, themeId);
+	const source = localeOf(locales, options.sourceIso);
+	if (!source) return {
+		themeId,
+		locales,
+		total: 0,
+		missing: {},
+		sameAsSource: [],
+		skipped: `The theme has no locales/${options.sourceIso}.json to translate from. Pass --from with the theme's source locale.`
+	};
+	const target = localeOf(locales, iso);
+	const missing = missingKeys(source, target);
+	return {
+		themeId,
+		locales,
+		total: Object.keys(missingKeys(source, null)).length,
+		missing,
+		sameAsSource: sameAsSourceKeys(source, target)
+	};
+}
+async function themeReport(client, iso, options) {
+	const result = await missingThemeKeys(client, iso, options);
+	return {
+		type: "theme",
+		label: `Theme ${result.themeId} strings (locales/${iso}.json)`,
+		total: result.total,
+		missingCount: Object.keys(result.missing).length,
+		missing: Object.entries(result.missing).map(([key, value]) => ({
+			id: key,
+			source: value
+		})),
+		...result.sameAsSource.length > 0 ? { sameAsSource: {
+			count: result.sameAsSource.length,
+			sample: result.sameAsSource.slice(0, 20)
+		} } : {},
+		...result.skipped ? { skipped: result.skipped } : {}
+	};
+}
+/** Theme page strings each template's source locale has and `iso` lacks. */
+async function missingSections(client, iso, options) {
+	const themeId = await resolveThemeId(client, options.themeId);
+	return {
+		themeId,
+		...missingSectionKeys(await listTemplateTranslations(client, themeId), options.sourceIso, iso)
+	};
+}
+async function sectionsReport(client, iso, options) {
+	const result = await missingSections(client, iso, options);
+	return {
+		type: "theme-sections",
+		label: `Theme ${result.themeId} page strings (template translations)`,
+		total: result.total,
+		missingCount: result.missing.length,
+		missing: result.missing.map((m) => ({
+			id: m.id,
+			source: m.source
+		}))
+	};
+}
+/** Agreements with no translation in `iso`; with `publishedOnly`, active ones only. */
+async function missingAgreements(client, iso, publishedOnly) {
+	const checked = (await listAgreements(client)).filter((agreement) => !publishedOnly || agreement.active !== false);
+	const missing = [];
+	for (const agreement of checked) if (!await agreementTranslated(client, agreement.id, iso)) missing.push(agreement);
+	return {
+		checked,
+		missing
+	};
+}
+async function agreementsReport(client, iso, options) {
+	const { checked, missing } = await missingAgreements(client, iso, options.publishedOnly);
+	return {
+		type: "agreements",
+		label: "Agreements",
+		total: checked.length,
+		missingCount: missing.length,
+		missing: missing.map((a) => ({
+			id: a.id,
+			source: a.title ?? null,
+			status: a.active === false ? "inactive" : "active"
+		}))
+	};
+}
+/** Labels whose title in `iso` still reads as the default title. */
+async function missingLabels(client, iso) {
+	const checked = (await listLabels(client)).filter((label) => label.title.trim().length > 0);
+	const missing = [];
+	for (const label of checked) if (!labelTranslated(label.title, await getLabelTitle(client, label.id, iso))) missing.push(label);
+	return {
+		checked,
+		missing
+	};
+}
+async function labelsReport(client, iso) {
+	const { checked, missing } = await missingLabels(client, iso);
+	return {
+		type: "labels",
+		label: "Product labels",
+		total: checked.length,
+		missingCount: missing.length,
+		missing: missing.map((l) => ({
+			id: l.id,
+			source: l.title
+		}))
+	};
+}
+//#endregion
+//#region src/translations/autotranslate.ts
+/** Run one save; a refusal is recorded against the item instead of ending the run. */
+async function save(failed, id, write) {
+	try {
+		await write();
+		return true;
+	} catch (error) {
+		failed.push({
+			id,
+			...failureOf(error)
+		});
+		return false;
+	}
+}
+/**
+* Machine-translate what's missing in `iso` and, with `write`, save it.
+* Storefront rows translate their text fields from the default locale
+* (URL fields are left for a person); menu items translate their title;
+* theme keys translate from the source locale file and save in one write.
+*/
+async function autoTranslate(client, types, options) {
+	const usage = {
+		inputTokens: 0,
+		outputTokens: 0
+	};
+	const results = [];
+	const call = async (sourceName, fields) => {
+		const out = await machineTranslate(client, sourceName, options.targetName, fields, options.model);
+		usage.inputTokens += out.usage.inputTokens;
+		usage.outputTokens += out.usage.outputTokens;
+		return out.translations;
+	};
+	const translator = (sourceName) => async (fields) => {
+		const first = await call(sourceName, fields);
+		const omitted = Object.fromEntries(Object.entries(fields).filter(([id, v]) => v.trim().length > 0 && first[id] === void 0));
+		if (Object.keys(omitted).length === 0) return first;
+		return {
+			...first,
+			...await call(sourceName, omitted)
+		};
+	};
+	const skipped = new Set(options.skip ?? []);
+	for (const type of types) if (type.kind === "storefront") results.push(await autoStorefront(client, type, options, skipped, translator(options.storeName)));
+	else if (type.kind === "menu-items") results.push(await autoMenus(client, options, skipped, translator(options.storeName)));
+	else if (type.kind === "theme") results.push(await autoTheme(client, options, skipped, translator(options.sourceName)));
+	else if (type.kind === "theme-sections") results.push(await autoSections(client, options, skipped, translator(options.sourceName)));
+	else if (type.kind === "agreements") results.push(await autoAgreements(client, options, skipped, translator(options.storeName)));
+	else results.push(await autoLabels(client, options, skipped, translator(options.storeName)));
+	return {
+		written: options.write,
+		types: results,
+		usage
+	};
+}
+async function autoStorefront(client, type, options, skipped, translate) {
+	const rows = (await listAll(client, type)).filter((row) => !skipped.has(`${type.type}:${row.id}`) && !isTranslated(row, options.iso) && (!options.publishedOnly || shopperVisible(row)));
+	const picked = rows.slice(0, options.limit);
+	const source = {};
+	const fieldsOf = /* @__PURE__ */ new Map();
+	for (const summary of picked) {
+		const row = await getRow(client, type, summary.id);
+		for (const [field, value] of Object.entries(pickFields(row, type.textFields))) {
+			if (value === null || value.trim().length === 0) continue;
+			source[`${summary.id}:${field}`] = value;
+			fieldsOf.set(summary.id, [...fieldsOf.get(summary.id) ?? [], field]);
+		}
+	}
+	const translations = await translate(source);
+	const entries = [];
+	const incomplete = [];
+	const failed = [];
+	for (const summary of picked) {
+		const wanted = fieldsOf.get(summary.id) ?? [];
+		if (wanted.length === 0) continue;
+		const fields = {};
+		for (const field of wanted) {
+			const value = translations[`${summary.id}:${field}`];
+			if (value !== void 0) fields[field] = value;
+		}
+		if (Object.keys(fields).length < wanted.length) {
+			incomplete.push(summary.id);
+			continue;
+		}
+		if (options.write && !await save(failed, summary.id, () => writeTranslation(client, type, summary.id, options.iso, fields))) continue;
+		entries.push({
+			id: summary.id,
+			fields,
+			source: Object.fromEntries(wanted.map((f) => [f, source[`${summary.id}:${f}`] ?? ""])),
+			saved: options.write
+		});
+	}
+	return {
+		type: type.type,
+		translated: entries,
+		incomplete,
+		failed,
+		remaining: rows.length - picked.length + incomplete.length + failed.length
+	};
+}
+async function autoMenus(client, options, skipped, translate) {
+	return autoTitles("menu-items", (await missingMenuItems(client, options.iso)).missing.filter((item) => !skipped.has(`menu-items:${item.id}`)).map((item) => ({
+		id: item.id,
+		title: item.title ?? ""
+	})), options, translate, (id, title) => writeMenuItemTitle(client, String(id), options.iso, title));
+}
+async function autoLabels(client, options, skipped, translate) {
+	const { missing } = await missingLabels(client, options.iso);
+	const pending = missing.filter((label) => !skipped.has(`labels:${label.id}`));
+	const sources = [];
+	for (const label of pending.slice(0, options.limit)) {
+		const title = await getLabelTitle(client, label.id, options.storeIso);
+		sources.push({
+			id: label.id,
+			title: title || label.title
+		});
+	}
+	const result = await autoTitles("labels", sources, options, translate, (id, title) => writeLabelTitle(client, Number(id), options.iso, title));
+	return {
+		...result,
+		remaining: result.remaining + pending.length - sources.length
+	};
+}
+/** Translate and save a title per item: menu items and labels. */
+async function autoTitles(type, items, options, translate, write) {
+	const picked = items.slice(0, options.limit);
+	const translations = await translate(Object.fromEntries(picked.map((item) => [String(item.id), item.title])));
+	const entries = [];
+	const incomplete = [];
+	const failed = [];
+	for (const item of picked) {
+		if (item.title.trim().length === 0) continue;
+		const title = translations[String(item.id)];
+		if (title === void 0) {
+			incomplete.push(item.id);
+			continue;
+		}
+		if (options.write && !await save(failed, item.id, () => write(item.id, title))) continue;
+		entries.push({
+			id: item.id,
+			fields: { title },
+			source: { title: item.title },
+			saved: options.write
+		});
+	}
+	return {
+		type,
+		translated: entries,
+		incomplete,
+		failed,
+		remaining: items.length - picked.length + incomplete.length + failed.length
+	};
+}
+async function autoAgreements(client, options, skipped, translate) {
+	const { missing } = await missingAgreements(client, options.iso, options.publishedOnly);
+	const pending = missing.filter((a) => !skipped.has(`agreements:${a.id}`));
+	const picked = pending.slice(0, options.limit);
+	const source = {};
+	for (const agreement of picked) {
+		const text = await readAgreement(client, agreement.id, options.storeIso);
+		if (text.title.trim()) source[`${agreement.id}:title`] = text.title;
+		if (text.description.trim()) source[`${agreement.id}:description`] = text.description;
+	}
+	const translations = await translate(source);
+	const entries = [];
+	const incomplete = [];
+	const failed = [];
+	for (const agreement of picked) {
+		const title = translations[`${agreement.id}:title`];
+		const description = translations[`${agreement.id}:description`];
+		if (title === void 0 || description === void 0) {
+			incomplete.push(agreement.id);
+			continue;
+		}
+		if (options.write && !await save(failed, agreement.id, () => writeAgreementTranslation(client, agreement.id, options.iso, {
+			title,
+			description
+		}))) continue;
+		entries.push({
+			id: agreement.id,
+			fields: {
+				title,
+				description
+			},
+			source: {
+				title: source[`${agreement.id}:title`] ?? "",
+				description: source[`${agreement.id}:description`] ?? ""
+			},
+			saved: options.write
+		});
+	}
+	return {
+		type: "agreements",
+		translated: entries,
+		incomplete,
+		failed,
+		remaining: pending.length - picked.length + incomplete.length + failed.length
+	};
+}
+async function autoTheme(client, options, skipped, translate) {
+	const found = await missingThemeKeys(client, options.iso, options);
+	if (found.skipped) return {
+		type: "theme",
+		translated: [],
+		incomplete: [],
+		failed: [],
+		remaining: 0,
+		skipped: found.skipped
+	};
+	const keys = Object.keys(found.missing).filter((key) => !skipped.has(`theme:${key}`));
+	const picked = keys.slice(0, options.limit);
+	const translations = await translate(Object.fromEntries(picked.map((key) => [key, found.missing[key] ?? ""])));
+	const updates = Object.fromEntries(picked.filter((key) => translations[key] !== void 0).map((key) => [key, translations[key]]));
+	const failed = [];
+	let saved = false;
+	if (options.write && Object.keys(updates).length > 0) {
+		const current = localeOf(found.locales, options.iso) ?? {};
+		const attempt = [];
+		saved = await save(attempt, "theme", () => writeLocale(client, found.locales, options.iso, mergeLocale(current, updates)));
+		if (!saved) for (const key of Object.keys(updates)) failed.push({
+			...attempt[0],
+			id: key
+		});
+	}
+	const incomplete = picked.filter((key) => translations[key] === void 0);
+	return {
+		type: "theme",
+		translated: saved || !options.write ? Object.entries(updates).map(([key, value]) => ({
+			id: key,
+			fields: { value },
+			source: { value: found.missing[key] ?? "" },
+			saved
+		})) : [],
+		incomplete,
+		failed,
+		remaining: keys.length - picked.length + incomplete.length + failed.length
+	};
+}
+/** Theme page strings: translated per key, saved one template at a time. */
+async function autoSections(client, options, skipped, translate) {
+	const found = await missingSections(client, options.iso, options);
+	const pending = found.missing.filter((m) => !skipped.has(`theme-sections:${m.id}`));
+	const picked = pending.slice(0, options.limit);
+	const translations = await translate(Object.fromEntries(picked.map((m) => [m.id, m.source])));
+	const byTemplate = /* @__PURE__ */ new Map();
+	const incomplete = [];
+	for (const m of picked) {
+		const value = translations[m.id];
+		if (value === void 0) {
+			incomplete.push(m.id);
+			continue;
+		}
+		byTemplate.set(m.templateId, {
+			...byTemplate.get(m.templateId),
+			[m.key]: value
+		});
+	}
+	const entries = [];
+	const failed = [];
+	for (const [templateId, updates] of byTemplate) {
+		const ok = !options.write || await save(failed, templateId, () => writeSectionStrings(client, found.themeId, templateId, options.iso, updates));
+		const keys = Object.entries(updates);
+		if (!ok) {
+			const last = failed[failed.length - 1];
+			failed.splice(failed.length - 1, 1, ...keys.map(([key]) => ({
+				...last,
+				id: `${templateId}/${key}`
+			})));
+			continue;
+		}
+		for (const [key, value] of keys) {
+			const id = `${templateId}/${key}`;
+			entries.push({
+				id,
+				fields: { value },
+				source: { value: picked.find((m) => m.id === id)?.source ?? "" },
+				saved: options.write
+			});
+		}
+	}
+	return {
+		type: "theme-sections",
+		translated: entries,
+		incomplete,
+		failed,
+		remaining: pending.length - picked.length + incomplete.length + failed.length
+	};
+}
+//#endregion
+//#region src/translations/save.ts
+/**
+* One item's translated fields: a row's fields, a title, or a theme
+* string's `value`. Theme strings are read again just before the write, so
+* the theme's latest version is the one guarded.
+*/
+async function saveTranslation(api, type, id, iso, fields, themeId) {
+	switch (type.kind) {
+		case "storefront":
+			await writeTranslation(api, type, Number(id), iso, fields);
+			return;
+		case "menu-items":
+			await writeMenuItemTitle(api, String(id), iso, fields["title"] ?? "");
+			return;
+		case "labels":
+			await writeLabelTitle(api, Number(id), iso, fields["title"] ?? "");
+			return;
+		case "agreements":
+			await writeAgreementTranslation(api, Number(id), iso, {
+				title: fields["title"] ?? "",
+				description: fields["description"] ?? ""
+			});
+			return;
+		case "theme": {
+			const locales = await readThemeLocales(api, await resolveThemeId(api, themeId));
+			await writeLocale(api, locales, iso, mergeLocale(localeOf(locales, iso) ?? {}, { [String(id)]: fields["value"] ?? "" }));
+			return;
+		}
+		case "theme-sections": {
+			const { templateId, key } = parseSectionRef(String(id));
+			await writeSectionStrings(api, await resolveThemeId(api, themeId), templateId, iso, { [key]: fields["value"] ?? "" });
+			return;
+		}
+	}
+}
+//#endregion
+//#region src/translations/walk.ts
+var Stop = class extends Error {};
+const FIELD_LABELS = { value: "Text" };
+async function walkTranslations(deps, options = {}) {
+	const { api, prompter } = deps;
+	const from = options.from ?? "en";
+	const batch = options.batch ?? 10;
+	const result = {
+		saved: [],
+		edited: [],
+		skipped: [],
+		failed: [],
+		stopped: false
+	};
+	prompter.note(NAV_HELP);
+	try {
+		const language = await pickLanguage(deps, options.iso);
+		if (!language) {
+			result.stopped = true;
+			return result;
+		}
+		result.language = language.iso;
+		const report = await missingReport(api, language.iso, RESOURCE_TYPES, {
+			publishedOnly: false,
+			sourceIso: from,
+			themeId: options.themeId
+		});
+		prompter.note([`What isn't in ${language.name} yet:`, ...report.types.map((t) => `  ${t.label}: ${t.skipped ? `not checked (${t.skipped})` : `${t.missingCount} of ${t.total} missing`}`)].join("\n"));
+		const pending = report.types.filter((t) => t.missingCount > 0 && !t.skipped);
+		if (pending.length === 0) {
+			prompter.note(`Everything is translated into ${language.name}.`);
+			return result;
+		}
+		const languages = await resolveLanguages(deps, pending.map((t) => RESOURCE_TYPES.find((r) => r.type === t.type)), language.iso, from);
+		if (!languages) {
+			result.stopped = true;
+			return result;
+		}
+		const skip = /* @__PURE__ */ new Set();
+		for (const entry of pending) {
+			const type = RESOURCE_TYPES.find((r) => r.type === entry.type);
+			const start = await prompter.menu(`${entry.label}: ${entry.missingCount} missing.`, [
+				{
+					title: "Translate with Fluid AI and review each",
+					value: "go"
+				},
+				{
+					title: "Skip this type",
+					value: "skip"
+				},
+				{
+					title: "Stop",
+					value: "stop"
+				}
+			]);
+			if (start === null || start === "stop") throw new Stop();
+			if (start === "skip") continue;
+			await reviewType(deps, type, languages, {
+				...options,
+				from,
+				batch
+			}, skip, result);
+		}
+		prompter.note(`Saved ${result.saved.length} (${result.edited.length} edited), skipped ${result.skipped.length}, ${result.failed.length} refused. Check with: fluid translations missing ${language.iso}`);
+	} catch (error) {
+		if (!(error instanceof Stop)) throw error;
+		result.stopped = true;
+		prompter.note("Stopped. Everything accepted so far is saved.");
+	}
+	return result;
+}
+async function pickLanguage(deps, iso) {
+	const { api, prompter } = deps;
+	const all = await listLanguages(api);
+	let language = iso ? all.find((l) => sameIso(l.iso, iso)) : void 0;
+	if (!language) {
+		if (iso) prompter.note(`"${iso}" isn't a language Fluid supports.`);
+		const reply = await prompter.ask({
+			section: "Language",
+			message: "Which language are you translating into?",
+			kind: "search",
+			hint: "type to filter",
+			choices: [...all].sort((a, b) => Number(b.active) - Number(a.active)).map((l) => ({
+				title: `${l.name} (${l.iso})${l.active ? "" : " — off"}`,
+				value: l.iso
+			})),
+			canGoBack: false
+		});
+		if ("nav" in reply) return null;
+		language = all.find((l) => sameIso(l.iso, reply.value));
+		if (!language) return null;
+	}
+	if (language.active) return language;
+	if (await prompter.menu(`${language.name} isn't on for this company, so translations can't be saved to it.`, [{
+		title: `Turn on ${language.name}`,
+		value: "enable"
+	}, {
+		title: "Stop",
+		value: "stop"
+	}]) !== "enable") return null;
+	return enableLanguage(api, language);
+}
+/** The languages to translate between; asks for the store's language when the rows can't say. */
+async function resolveLanguages(deps, types, iso, from) {
+	let storeLanguage;
+	for (;;) try {
+		return await autoLanguages(deps.api, types, {
+			iso,
+			from,
+			storeLanguage,
+			write: true
+		});
+	} catch (error) {
+		if (storeLanguage !== void 0 || !/store's default language from its storefront rows/.test(String(error.message))) {
+			deps.prompter.note(failureOf(error).error);
+			return null;
+		}
+		const reply = await deps.prompter.ask({
+			section: "Language",
+			message: "Which language is your store's own content written in?",
+			kind: "text",
+			hint: "a code such as en",
+			canGoBack: false
+		});
+		if ("nav" in reply) return null;
+		storeLanguage = reply.value.trim();
+	}
+}
+/** Translate a type batch by batch, reviewing each proposal. */
+async function reviewType(deps, type, languages, options, skip, result) {
+	const { api, prompter } = deps;
+	for (;;) {
+		const outcome = (await autoTranslate(api, [type], {
+			iso: languages.target.iso,
+			storeName: languages.store.name,
+			sourceName: languages.source.name,
+			targetName: languages.target.name,
+			sourceIso: languages.source.iso,
+			storeIso: languages.store.iso,
+			limit: options.batch,
+			write: false,
+			publishedOnly: false,
+			themeId: options.themeId,
+			skip: [...skip]
+		})).types[0];
+		for (const id of outcome.incomplete) {
+			skip.add(`${type.type}:${id}`);
+			prompter.note(`Fluid AI left part of ${type.label.toLowerCase()} ${id} untranslated; set it with \`fluid translations set\`.`);
+		}
+		if (outcome.translated.length === 0) return;
+		if (await reviewBatch(deps, type, outcome.translated, languages, options, skip, result) === "next-type") return;
+		const left = outcome.remaining - outcome.incomplete.length;
+		if (left <= 0) return;
+		const more = await prompter.menu(`${type.label}: ${left} more to translate.`, [
+			{
+				title: "Translate the next batch",
+				value: "more"
+			},
+			{
+				title: "Next type",
+				value: "next"
+			},
+			{
+				title: "Stop",
+				value: "stop"
+			}
+		]);
+		if (more === null || more === "stop") throw new Stop();
+		if (more === "next") return;
+	}
+}
+async function reviewBatch(deps, type, entries, languages, options, skip, result) {
+	const { api, prompter } = deps;
+	const savedFields = /* @__PURE__ */ new Map();
+	let i = 0;
+	while (i < entries.length) {
+		const proposal = entries[i];
+		const entry = {
+			...proposal,
+			fields: savedFields.get(i) ?? proposal.fields
+		};
+		const key = `${type.type}:${entry.id}`;
+		prompter.note([`${type.label} ${entry.id} (${i + 1} of ${entries.length}):`, ...Object.entries(entry.fields).map(([field, value]) => `  ${FIELD_LABELS[field] ?? field}: ${clip(entry.source?.[field] ?? "")}\n  → ${clip(value)}`)].join("\n"));
+		const reply = await prompter.ask({
+			section: `${type.label} → ${languages.target.name}`,
+			message: "Save this translation?",
+			kind: "select",
+			choices: [
+				{
+					title: "Accept",
+					value: "accept"
+				},
+				{
+					title: "Edit",
+					value: "edit"
+				},
+				{
+					title: "Skip",
+					value: "skip"
+				}
+			],
+			canGoBack: i > 0
+		});
+		if ("nav" in reply) {
+			if (reply.nav === "quit") throw new Stop();
+			if (reply.nav === "back") {
+				i = Math.max(0, i - 1);
+				continue;
+			}
+			if (reply.nav === "skip") {
+				skipItem(key, skip, result);
+				i += 1;
+				continue;
+			}
+			const choice = await prompter.menu("What next?", [
+				{
+					title: "Continue",
+					value: "continue"
+				},
+				{
+					title: `Skip the rest of ${type.label.toLowerCase()}`,
+					value: "next-type"
+				},
+				{
+					title: "Stop",
+					value: "stop"
+				}
+			]);
+			if (choice === null || choice === "stop") throw new Stop();
+			if (choice === "next-type") return "next-type";
+			continue;
+		}
+		if (reply.value === "skip") {
+			skipItem(key, skip, result);
+			i += 1;
+			continue;
+		}
+		let fields = entry.fields;
+		if (reply.value === "edit") {
+			const edited = {};
+			for (const [field, value] of Object.entries(entry.fields)) {
+				const answer = await prompter.ask({
+					section: `${type.label} ${entry.id}`,
+					message: FIELD_LABELS[field] ?? field,
+					kind: "text",
+					current: value,
+					canGoBack: false
+				});
+				if ("nav" in answer) {
+					if (answer.nav === "quit") throw new Stop();
+					edited[field] = value;
+				} else edited[field] = answer.value.trim() === "" ? value : answer.value;
+			}
+			fields = edited;
+		}
+		try {
+			await saveTranslation(api, type, entry.id, languages.target.iso, fields, options.themeId);
+			savedFields.set(i, fields);
+			if (!result.saved.includes(key)) result.saved.push(key);
+			if (reply.value === "edit" && !result.edited.includes(key)) result.edited.push(key);
+			const skippedAt = result.skipped.indexOf(key);
+			if (skippedAt >= 0) result.skipped.splice(skippedAt, 1);
+			result.failed = result.failed.filter((f) => f.id !== key);
+			skip.delete(key);
+		} catch (error) {
+			const { error: message } = failureOf(error);
+			result.failed.push({
+				id: key,
+				error: message
+			});
+			skip.add(key);
+			prompter.note(`Not saved: ${message}`);
+		}
+		i += 1;
+	}
+	return "done";
+}
+function skipItem(key, skip, result) {
+	skip.add(key);
+	if (!result.skipped.includes(key)) result.skipped.push(key);
+}
+/** One line of a long value, for the review. */
+function clip(text, max = 200) {
+	const flat = text.replace(/\s+/g, " ").trim();
+	return flat.length > max ? `${flat.slice(0, max)}…` : flat;
+}
+//#endregion
+//#region src/countries/commands.ts
+async function client$1(ctx) {
+	return await ctx.getClient();
+}
+/** The company_country attributes `plan` shows and `open` sends. */
+async function seededAttributes(api, iso, opts) {
+	const mode = parseMode(opts.mode);
+	const { countryCode, atlas } = await requireAtlas(api, iso);
+	const country = await catalogCountry(api, countryCode);
+	return {
+		countryCode,
+		atlas,
+		country,
+		mode,
+		attributes: applyOverrides(companyCountryFromAtlas(atlas, {
+			countryId: country.id,
+			mode,
+			...opts.warehouseId ? { warehouseId: positiveInt(opts.warehouseId, "--warehouse-id") } : {},
+			...opts.businessId ? { businessId: opts.businessId } : {},
+			...opts.entityRegistered !== void 0 ? { entityRegistered: opts.entityRegistered } : {},
+			...opts.settlementCurrency ? { settlementCurrency: opts.settlementCurrency } : {}
+		}), parseSettingAssignments(opts.set))
+	};
+}
+function withOpenOptions(command) {
+	return command.requiredOption("--mode <mode>", "How you will operate: nfr, otg, or usd").option("--warehouse-id <id>", "The warehouse that fulfills orders for the country (NFR and OTG)").option("--business-id <id>", "Your local tax or business registration number (OTG), e.g. a VAT ID").option("--entity-registered", "You already have a legally registered local entity (OTG)").option("--settlement-currency <code>", "Settle in another currency than the one you charge in, e.g. USD").option("--set <key=value>", "Override a seeded value, e.g. tax_inclusive_pricing=false or legal_settings.cooling_off_period_days=30 (repeatable)", collect, []);
+}
+/** Check each agreement on the country for the atlas translations it lacks. */
+async function withTranslationGaps(api, atlas, states) {
+	return Promise.all(states.map(async (state) => state.status === "linked" && state.agreementId !== null ? {
+		...state,
+		missingTranslations: await missingTranslations(api, state.agreementId, atlasAgreement(atlas, state.localId))
+	} : state));
+}
+/** Price coverage of the active products in a country, bundles listed apart. */
+async function countryPriceCoverage(api, iso) {
+	return priceCoverage(await listProductsWithVariants(api, ["active"]), iso);
+}
+function registerCountriesCommands(parent, ctx) {
+	parent.command("atlas <iso>").description("Show Fluid's Country Atlas for a market: modes, tax, legal, address, payments, languages, agreements").option("--agreement <localId>", "Print one atlas agreement's full text in every language instead").action((iso, opts) => run(async () => {
+		const result = await fetchAtlas(await client$1(ctx), iso);
+		if (!result.covered || !result.atlas) {
+			ctx.output({
+				country: result.countryCode,
+				covered: false,
+				note: "Fluid publishes no Country Atlas for this market yet. Set it up by hand and don't assume tax, legal, or agreement defaults."
+			});
+			return;
+		}
+		if (opts.agreement) {
+			ctx.output({
+				country: result.countryCode,
+				covered: true,
+				agreement: atlasAgreement(result.atlas, opts.agreement)
+			});
+			return;
+		}
+		ctx.output({
+			country: result.countryCode,
+			covered: true,
+			...summarizeAtlas(result.atlas)
+		});
+	}));
+	parent.command("compliance <iso>").description("Show the compliance view of the atlas: disclosure pages, cookie rule, tax display, unit pricing").action((iso) => run(async () => {
+		const { countryCode, atlas } = await requireAtlas(await client$1(ctx), iso);
+		ctx.output(complianceView(countryCode, atlas));
+	}));
+	parent.command("list").description("List the countries this company sells in").action(() => run(async () => {
+		const countries = await listCompanyCountries(await client$1(ctx));
+		ctx.output(countries.map((cc) => ({
+			companyCountryId: cc.id,
+			iso: cc.country?.iso ?? null,
+			name: cc.country?.name ?? null,
+			mode: cc.mode ?? null,
+			currency: cc.currency ?? null,
+			taxName: cc.tax_name ?? null,
+			taxInclusivePricing: cc.tax_inclusive_pricing ?? null,
+			requires3ds: cc.requires_3ds ?? null,
+			testMode: cc.test_mode ?? null,
+			warehouse: cc.warehouse ? {
+				id: cc.warehouse.id,
+				name: cc.warehouse.name ?? null
+			} : null
+		})));
+	}));
+	withOpenOptions(parent.command("plan <iso>").description("Preview a country setup without changing anything: the seeded settings, languages, agreements, and checklist")).action((iso, opts) => run(async () => {
+		const api = await client$1(ctx);
+		const { countryCode, atlas, mode, attributes } = await seededAttributes(api, iso, opts);
+		const [existing, languages, agreements, warehouses] = await Promise.all([
+			findCompanyCountry(api, countryCode),
+			listLanguages(api),
+			listAgreements(api),
+			listWarehouses(api)
+		]);
+		ctx.output({
+			country: countryCode,
+			mode,
+			alreadyOpen: existing ? {
+				companyCountryId: existing.id,
+				mode: existing.mode ?? null
+			} : false,
+			companyCountry: attributes,
+			languages: languageStates(atlas, languages),
+			agreements: agreementStates(atlas, agreements, existing?.id ?? null),
+			warehouses: warehouses.map((w) => ({
+				id: w.id,
+				name: w.name,
+				country: w.country?.iso ?? null,
+				active: w.active ?? null
+			})),
+			launchChecklist: launchChecklist(atlas, mode)
+		});
+	}));
+	withOpenOptions(parent.command("open <iso>").description("Add the country to the company, seeded from the atlas: currency, mode, tax, 3-D Secure, legal, address layout, payment order (changes live config)").option("--legacy-defaults", "Also let Fluid add its generic country agreements and forms", false).option("--reseed", "If the country is already open, write the atlas values over its current settings", false).option("--yes", "Confirm without a prompt", false)).action((iso, opts) => run(async () => {
+		const api = await client$1(ctx);
+		const { countryCode, attributes } = await seededAttributes(api, iso, opts);
+		const existing = await findCompanyCountry(api, countryCode);
+		if (existing && !opts.reseed) {
+			ctx.output({
+				country: countryCode,
+				alreadyOpen: true,
+				companyCountryId: existing.id,
+				note: "Nothing changed. Pass --reseed to write the atlas values over the current settings."
+			});
+			return;
+		}
+		if (existing) {
+			await confirmChange(`Overwrite ${countryCode}'s settings with the atlas values? Changes an admin made are replaced.`, opts.yes);
+			const updated = await updateCompanyCountry(api, existing.id, attributes, existing.revision);
+			ctx.output({
+				country: countryCode,
+				reseeded: true,
+				companyCountry: updated
+			});
+			return;
+		}
+		await confirmChange(`Open ${countryCode} for this company in ${String(attributes["mode"])} mode?`, opts.yes);
+		const created = await createCompanyCountry(api, attributes, opts.legacyDefaults);
+		ctx.output({
+			country: countryCode,
+			opened: true,
+			companyCountry: created
+		});
+	}));
+	parent.command("languages <iso>").description("Compare the market's major languages with the company's; `fluid translations enable` turns the missing ones on").action((iso) => run(async () => {
+		const api = await client$1(ctx);
+		const { countryCode, atlas } = await requireAtlas(api, iso);
+		const states = languageStates(atlas, await listLanguages(api));
+		const off = states.filter((s) => !s.enabled && s.languageId !== null);
+		ctx.output({
+			country: countryCode,
+			done: states.every((s) => s.enabled),
+			languages: states,
+			...off.length > 0 ? { next: `fluid translations enable ${off.map((s) => s.iso).join(" ")} --yes` } : {}
+		});
+	}));
+	parent.command("agreements <iso>").description("Match the atlas agreements to the company's; --create adds the missing ones to the country in every atlas language, --translate rewrites the atlas translations onto ones already on it (changes live config)").option("--create", "Create each missing atlas agreement on the country", false).option("--translate", "Write the atlas translations onto the agreements already on the country, e.g. after enabling a language", false).option("--only <localId>", "With --create or --translate, just this atlas agreement, e.g. agreement_2 (repeatable)", collect, []).option("--yes", "Confirm without a prompt", false).action((iso, opts) => run(async () => {
+		const api = await client$1(ctx);
+		const { countryCode, atlas } = await requireAtlas(api, iso);
+		const cc = await requireCompanyCountry(api, countryCode);
+		const states = agreementStates(atlas, await listAgreements(api), cc.id);
+		if (opts.create && opts.translate) throw new LocalizationError("Use --create or --translate, not both.");
+		if (opts.only.length > 0 && !opts.create && !opts.translate) throw new LocalizationError("--only goes with --create or --translate.");
+		for (const id of opts.only) atlasAgreement(atlas, id);
+		const picked = (s) => opts.only.length === 0 || opts.only.includes(s.localId);
+		if (opts.translate) {
+			const withTranslations = states.filter((s) => (s.status === "linked" || s.status === "inactive") && s.agreementId !== null && picked(s)).filter((s) => atlasAgreement(atlas, s.localId).translations.some((t) => t.language_iso !== "en"));
+			if (withTranslations.length === 0) {
+				ctx.output({
+					country: countryCode,
+					translated: [],
+					agreements: states
+				});
+				return;
+			}
+			await confirmChange(`Write the atlas translations onto ${withTranslations.length} agreement(s)? Translations an admin edited are replaced.`, opts.yes);
+			const translated = [];
+			for (const state of withTranslations) {
+				const result = await writeTranslations(api, state.agreementId, atlasAgreement(atlas, state.localId));
+				translated.push({
+					localId: state.localId,
+					id: state.agreementId,
+					...result
+				});
+			}
+			ctx.output({
+				country: countryCode,
+				translated
+			});
+			if (translated.some((t) => t.failedTranslations.length > 0)) process.exitCode = 1;
+			return;
+		}
+		if (!opts.create) {
+			ctx.output({
+				country: countryCode,
+				done: states.every((s) => s.status === "linked"),
+				agreements: states
+			});
+			return;
+		}
+		const toCreate = states.filter((s) => s.status === "missing" && picked(s));
+		if (toCreate.length === 0) {
+			ctx.output({
+				country: countryCode,
+				created: [],
+				agreements: states
+			});
+			return;
+		}
+		await confirmChange(`Create ${toCreate.length} agreement(s) on ${countryCode}: ${toCreate.map((s) => `"${s.title}"`).join(", ")}?`, opts.yes);
+		const created = [];
+		const failed = [];
+		for (const state of toCreate) try {
+			created.push(await createAgreementFromAtlas(api, atlasAgreement(atlas, state.localId), cc.id));
+		} catch (error) {
+			failed.push({
+				localId: state.localId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+		ctx.output({
+			country: countryCode,
+			created,
+			failed,
+			agreements: agreementStates(atlas, await listAgreements(api), cc.id)
+		});
+		if (failed.length > 0 || created.some((c) => c.failedTranslations.length > 0)) process.exitCode = 1;
+	}));
+	parent.command("prices <iso>").description("Convert every variant's price from another country into this one's currency at an exchange rate. A dry run unless --write (changes live prices)").option("--from-country <iso>", "The country whose prices are converted", "US").option("--rate <rate>", "Units of the new currency per unit of the source currency, e.g. 0.92; --write needs it").option("--fields <list>", `Price fields to convert, comma-separated, from ${PRICE_FIELDS.join(", ")}`, DEFAULT_PRICE_FIELDS.join(",")).option("--status <status>", "Product status to include (repeatable)", collect, []).option("--overwrite", "Also replace prices the country already has", false).option("--activate", "Put each converted variant on sale in the country", false).option("--sample <n>", "How many before→after examples to print", "10").option("--write", "Save the converted prices; without it nothing is written", false).option("--yes", "Confirm --write without a prompt", false).action((iso, opts) => run(async () => {
+		const api = await client$1(ctx);
+		const targetIso = countryCodeOf(iso);
+		const sourceIso = countryCodeOf(opts.fromCountry);
+		if (targetIso === sourceIso) throw new LocalizationError("--from-country is the country being priced.");
+		const fields = parsePriceFields(opts.fields);
+		const sample = positiveInt(opts.sample, "--sample");
+		const statuses = opts.status.length > 0 ? opts.status : ["active"];
+		const countries = await listCompanyCountries(api);
+		const target = companyCountryIn(countries, targetIso);
+		if (!target?.country) throw new LocalizationError(`${targetIso} isn't open for this company yet. Run \`fluid countries open ${targetIso} --mode <nfr|otg|usd>\` first.`);
+		const source = companyCountryIn(countries, sourceIso);
+		if (!source) throw new LocalizationError(`${sourceIso} isn't one of this company's countries, so it has no prices to convert.`);
+		const targetCurrency = (target.currency ?? "").toUpperCase();
+		const sourceCurrency = (source.currency ?? "").toUpperCase();
+		if (!targetCurrency || !sourceCurrency) throw new LocalizationError("Both countries need a currency. Check them with `fluid countries list`.");
+		let rate;
+		if (opts.rate !== void 0) rate = {
+			value: parseRate(opts.rate),
+			source: "--rate"
+		};
+		else if (sourceCurrency === targetCurrency) rate = {
+			value: 1,
+			source: "same currency"
+		};
+		else {
+			const reference = await referenceRate(sourceCurrency, targetCurrency);
+			if (opts.write) throw new LocalizationError(`--write needs the rate you reviewed: pass --rate.${reference ? ` The ${reference.date} reference rate is ${reference.rate} ${targetCurrency} per ${sourceCurrency}.` : ""}`);
+			if (!reference) throw new LocalizationError(`Couldn't look up a ${sourceCurrency} to ${targetCurrency} reference rate. Pass --rate.`);
+			rate = {
+				value: reference.rate,
+				source: reference.source,
+				date: reference.date
+			};
+		}
+		const priceEditor = await priceEditorOwnsPrices(api);
+		if (priceEditor === null && opts.overwrite) throw new LocalizationError("Your token can't read the company profile, so it can't tell whether the price editor manages your prices. --overwrite needs to know; run it with a token that can view the company.");
+		if (priceEditor && opts.overwrite) throw new LocalizationError("This company's prices are managed in the price editor, so --overwrite could replace prices set there. Change existing prices in the price editor; without --overwrite this command fills only prices the country doesn't have.");
+		const planOptions = {
+			sourceIso,
+			targetIso,
+			targetCountryId: target.country.id,
+			targetCurrency,
+			rate: rate.value,
+			fields,
+			overwrite: opts.overwrite,
+			activate: opts.activate
+		};
+		const plans = planConversion(await listProductsWithVariants(api, statuses), planOptions);
+		const summary = summarizePlans(plans, sample);
+		const header = {
+			country: targetIso,
+			from: {
+				country: sourceIso,
+				currency: sourceCurrency
+			},
+			to: {
+				country: targetIso,
+				currency: targetCurrency
+			},
+			rate,
+			rounding: {
+				decimals: currencyDecimals(targetCurrency),
+				mode: "half up"
+			},
+			fields,
+			statuses,
+			priceEditor
+		};
+		if (!opts.write || summary.toConvert === 0) {
+			ctx.output({
+				...header,
+				written: false,
+				...summary,
+				...summary.toConvert > 0 ? { next: `fluid countries prices ${targetIso} --from-country ${sourceIso} --rate ${rate.value} --fields ${fields.join(",")} --write --yes` } : {}
+			});
+			return;
+		}
+		await confirmChange(`Write ${summary.toConvert} converted price(s) into ${targetIso} (${targetCurrency}) at ${rate.value} ${targetCurrency} per ${sourceCurrency}?`, opts.yes);
+		const result = await writeConversion(api, plans, planOptions);
+		ctx.output({
+			...header,
+			written: true,
+			...summary,
+			converted: result.written.length,
+			changedSincePreview: result.changedSincePreview,
+			failed: result.failed,
+			refusedByPriceEditor: result.failed.filter((f) => f.refusedByPriceEditor).length
+		});
+		if (result.failed.length > 0) process.exitCode = 1;
+	}));
+	parent.command("walk [iso]").description("Open a country by answering questions: the atlas, mode, languages, agreements and defaults, then prices and translations (changes live config)").action((iso) => run(async () => {
+		assertInteractive("`plan`, `open`, `prices`, `agreements` and `fluid translations enable`");
+		const api = await client$1(ctx);
+		const prompter = terminalPrompter();
+		const result = await walkCountry({
+			api,
+			prompter,
+			translate: (language) => walkTranslations({
+				api,
+				prompter
+			}, { iso: language })
+		}, iso ? { iso } : {});
+		ctx.output(result);
+		if (result.failures.length > 0) process.exitCode = 1;
+	}));
+	parent.command("status <iso>").description("Check a country's setup against the atlas, including whether your active products have prices in it, and list what's left, ending with the launch checklist").action((iso) => run(async () => {
+		const api = await client$1(ctx);
+		const { countryCode, atlas } = await requireAtlas(api, iso);
+		const cc = await findCompanyCountry(api, countryCode);
+		const [languages, agreements] = cc ? await Promise.all([listLanguages(api), listAgreements(api)]) : [[], []];
+		ctx.output(statusReport({
+			countryCode,
+			atlas,
+			companyCountry: cc,
+			languages: languageStates(atlas, languages),
+			agreements: await withTranslationGaps(api, atlas, agreementStates(atlas, agreements, cc?.id ?? null)),
+			...cc ? { prices: await countryPriceCoverage(api, countryCode) } : {}
+		}));
+	}));
+}
+//#endregion
+//#region src/translations/commands.ts
+async function client(ctx) {
+	return await ctx.getClient();
+}
+function rowId(raw, type) {
+	const value = Number(raw);
+	if (raw === void 0 || !Number.isInteger(value) || value <= 0) throw new LocalizationError(`Pass the ${type} row id, as \`fluid translations missing\` prints it.`);
+	return value;
+}
+/** `--skip` items must match a report id exactly: `products:42`, `menu-items:12/340`, `theme:cart.title`. */
+function validSkip(item) {
+	const at = item.indexOf(":");
+	if (at <= 0) return false;
+	const type = item.slice(0, at);
+	const id = item.slice(at + 1);
+	if (!TYPE_NAMES.includes(type)) return false;
+	if (type === "theme") return id.length > 0;
+	if (type === "menu-items") return /^[1-9]\d*\/[1-9]\d*$/.test(id);
+	if (type === "theme-sections") return /^[1-9]\d*\/.+$/.test(id);
+	return /^[1-9]\d*$/.test(id);
+}
+function requireLang(lang) {
+	if (!lang) throw new LocalizationError("Pass the language with --lang <iso>, e.g. --lang fr.");
+	return lang;
+}
+function registerTranslationsCommands(parent, ctx) {
+	parent.command("languages").description("List every language Fluid supports and whether it's on for this company").option("--active", "Only the languages that are on", false).action((opts) => run(async () => ctx.output(await listLanguages(await client(ctx), opts.active))));
+	parent.command("enable <iso...>").description("Turn one or more languages on so shoppers can choose them and translations can be saved (changes live config)").option("--yes", "Confirm without a prompt", false).action((isos, opts) => run(async () => {
+		const api = await client(ctx);
+		const all = await listLanguages(api);
+		const wanted = [];
+		for (const iso of isos) {
+			const language = all.find((l) => l.iso.toLowerCase() === iso.trim().toLowerCase());
+			wanted.push(language ?? await findLanguage(api, iso));
+		}
+		const off = wanted.filter((l, i) => !l.active && wanted.indexOf(l) === i);
+		const alreadyActive = wanted.filter((l) => l.active).map((l) => l.iso);
+		if (off.length === 0) {
+			ctx.output({
+				enabled: [],
+				alreadyActive,
+				failed: []
+			});
+			return;
+		}
+		await confirmChange(`Turn on ${off.map((l) => `${l.name} (${l.iso})`).join(", ")} for this company?`, opts.yes);
+		const enabled = [];
+		const failed = [];
+		for (const language of off) try {
+			enabled.push((await enableLanguage(api, language)).iso);
+		} catch (error) {
+			failed.push({
+				iso: language.iso,
+				...failureOf(error)
+			});
+		}
+		ctx.output({
+			enabled,
+			alreadyActive,
+			failed
+		});
+		if (failed.length > 0) process.exitCode = 1;
+	}));
+	parent.command("disable <iso>").description("Turn a language off; its saved translations are kept (changes live config)").option("--yes", "Confirm without a prompt", false).action((iso, opts) => run(async () => {
+		const api = await client(ctx);
+		const language = await findLanguage(api, iso);
+		if (!language.active) {
+			ctx.output({
+				...language,
+				alreadyInactive: true
+			});
+			return;
+		}
+		await confirmChange(`Turn off ${language.name} (${language.iso}) for this company?`, opts.yes);
+		ctx.output(await disableLanguage(api, language));
+	}));
+	parent.command("types").description("List the translatable types and the fields each one translates").action(() => run(async () => ctx.output(RESOURCE_TYPES.map((t) => ({
+		type: t.type,
+		label: t.label,
+		fields: t.fields,
+		machineTranslated: t.textFields
+	})))));
+	parent.command("missing <iso>").description("Report what isn't translated into a language yet, per type, so you can fill only the gaps").option("--type <type>", `Limit to a type: ${TYPE_NAMES.join(", ")} (repeatable)`, collect, []).option("--published-only", "Skip drafts, scheduled, and archived rows", false).option("--from <iso>", "The theme's source locale file", "en").option("--theme <id>", "Check this theme instead of the active one").action((iso, opts) => run(async () => {
+		const api = await client(ctx);
+		const language = await findLanguage(api, iso);
+		const report = await missingReport(api, language.iso, selectTypes(opts.type), {
+			publishedOnly: opts.publishedOnly,
+			sourceIso: opts.from,
+			themeId: opts.theme
+		});
+		ctx.output({
+			language: {
+				iso: language.iso,
+				name: language.name,
+				active: language.active
+			},
+			done: report.done,
+			types: report.types
+		});
+	}));
+	parent.command("show <type> <id>").description("Show one item's default text beside its translation (null when untranslated); for theme, <id> is the key, for theme-sections <template id>/<key>").option("--lang <iso>", "The translation to show, e.g. fr").option("--from <iso>", "theme and theme-sections: the source locale", "en").option("--theme <id>", "theme and theme-sections: a theme other than the active one").action((typeName, id, opts) => run(async () => {
+		const api = await client(ctx);
+		const type = resourceType(typeName);
+		const language = await findLanguage(api, requireLang(opts.lang));
+		if (type.kind === "storefront") {
+			const rid = rowId(id, type.type);
+			const source = await getRow(api, type, rid);
+			const translated = isTranslated(source, language.iso);
+			const target = translated ? await getRow(api, type, rid, language.iso) : null;
+			ctx.output({
+				type: type.type,
+				id: rid,
+				lang: language.iso,
+				translated,
+				source: pickFields(source, type.fields),
+				translation: target ? pickFields(target, type.fields) : null
+			});
+		} else if (type.kind === "menu-items") {
+			const item = await getMenuItem(api, id, language.iso);
+			ctx.output({
+				type: type.type,
+				id,
+				lang: language.iso,
+				translated: item.translated !== null,
+				source: { title: item.source },
+				translation: item.translated === null ? null : { title: item.translated }
+			});
+		} else if (type.kind === "agreements") {
+			const aid = rowId(id, type.type);
+			const source = await readAgreement(api, aid);
+			const target = await readAgreement(api, aid, language.iso);
+			const translated = (target.languageIso ?? "").toLowerCase() === language.iso.toLowerCase();
+			ctx.output({
+				type: type.type,
+				id: aid,
+				lang: language.iso,
+				translated,
+				source: {
+					title: source.title,
+					description: source.description
+				},
+				translation: translated ? {
+					title: target.title,
+					description: target.description
+				} : null
+			});
+		} else if (type.kind === "labels") {
+			const lid = rowId(id, type.type);
+			const source = await getLabelTitle(api, lid);
+			const target = await getLabelTitle(api, lid, language.iso);
+			const translated = labelTranslated(source, target);
+			ctx.output({
+				type: type.type,
+				id: lid,
+				lang: language.iso,
+				translated,
+				source: { title: source },
+				translation: translated ? { title: target } : null
+			});
+		} else if (type.kind === "theme-sections") {
+			const { templateId, key } = parseSectionRef(id);
+			const themeId = await resolveThemeId(api, opts.theme);
+			const template = await readTemplateTranslations(api, themeId, templateId);
+			const text = sectionText(template, key, opts.from, language.iso);
+			ctx.output({
+				type: type.type,
+				themeId,
+				id: `${templateId}/${key}`,
+				template: template.name,
+				lang: language.iso,
+				translated: text.translation !== null,
+				...text
+			});
+		} else {
+			const themeId = await resolveThemeId(api, opts.theme);
+			const locales = await readThemeLocales(api, themeId);
+			const source = flattenLocale(localeOf(locales, opts.from) ?? {});
+			const target = flattenLocale(localeOf(locales, language.iso) ?? {});
+			ctx.output({
+				type: "theme",
+				themeId,
+				key: id,
+				lang: language.iso,
+				translated: (target[id] ?? "").trim().length > 0,
+				source: source[id] ?? null,
+				translation: target[id] ?? null
+			});
+		}
+	}));
+	parent.command("set <type> [id]").description("Save a translation: --set field=value for a row, menu item, agreement or label; --set key.path=value for theme strings, or for theme-sections with the template id (changes live content)").option("--lang <iso>", "The language to write, e.g. fr").option("--set <field=value>", "A translated field or theme key (repeatable)", collect, []).option("--file <path>", "A JSON object of field (or theme key) to text, for long or HTML values").option("--theme <id>", "theme and theme-sections: a theme other than the active one").option("--yes", "Confirm without a prompt", false).action((typeName, id, opts) => run(async () => {
+		const api = await client(ctx);
+		const type = resourceType(typeName);
+		const values = collectValues(opts.set, opts.file);
+		const language = await requireActiveLanguage(api, requireLang(opts.lang));
+		if (type.kind === "storefront") {
+			const rid = rowId(id, type.type);
+			checkFields(type, values);
+			const fields = Object.fromEntries(Object.entries(values).map(([field, value]) => [field, field.endsWith("_url") && (value === "" || value === "null") ? null : value]));
+			await confirmChange(`Save the ${language.name} translation of ${type.label.toLowerCase()} ${rid}?`, opts.yes);
+			const row = await writeTranslation(api, type, rid, language.iso, fields);
+			ctx.output({
+				type: type.type,
+				id: rid,
+				lang: language.iso,
+				saved: Object.keys(fields),
+				languages: Array.isArray(row["languages"]) ? row["languages"] : void 0
+			});
+		} else if (type.kind === "menu-items") {
+			if (!id) throw new LocalizationError("Pass the menu item id as <menu id>/<item id>.");
+			checkFields(type, values);
+			const title = values["title"];
+			if (!title) throw new LocalizationError("Pass --set title=... for a menu item.");
+			await confirmChange(`Save the ${language.name} title of menu item ${id}?`, opts.yes);
+			ctx.output({
+				...await writeMenuItemTitle(api, id, language.iso, title),
+				lang: language.iso
+			});
+		} else if (type.kind === "agreements") {
+			const aid = rowId(id, type.type);
+			checkFields(type, values);
+			const current = await readAgreement(api, aid, language.iso);
+			const translated = (current.languageIso ?? "").toLowerCase() === language.iso.toLowerCase();
+			const title = values["title"] ?? (translated ? current.title : void 0);
+			const description = values["description"] ?? (translated ? current.description : void 0);
+			if (!title || !description) throw new LocalizationError(`Agreement ${aid} has no ${language.name} translation yet, so pass both --set title=... and --set description=... (or --file).`);
+			await confirmChange(`Save the ${language.name} translation of agreement ${aid}?`, opts.yes);
+			await writeAgreementTranslation(api, aid, language.iso, {
+				title,
+				description
+			});
+			ctx.output({
+				type: type.type,
+				id: aid,
+				lang: language.iso,
+				saved: Object.keys(values)
+			});
+		} else if (type.kind === "labels") {
+			const lid = rowId(id, type.type);
+			checkFields(type, values);
+			const title = values["title"];
+			if (!title) throw new LocalizationError("Pass --set title=... for a label.");
+			await confirmChange(`Save the ${language.name} title of label ${lid}?`, opts.yes);
+			await writeLabelTitle(api, lid, language.iso, title);
+			ctx.output({
+				type: type.type,
+				id: lid,
+				lang: language.iso,
+				saved: ["title"]
+			});
+		} else if (type.kind === "theme-sections") {
+			const templateId = rowId(id, "template");
+			if (Object.keys(values).length === 0) throw new LocalizationError("Pass the page's keys with --set key.path=value or --file.");
+			const themeId = await resolveThemeId(api, opts.theme);
+			await confirmChange(`Save ${Object.keys(values).length} key(s) to template ${templateId}'s ${language.name} translations? They show on the storefront at once.`, opts.yes);
+			const saved = await writeSectionStrings(api, themeId, templateId, language.iso, values);
+			ctx.output({
+				type: type.type,
+				themeId,
+				...saved,
+				lang: language.iso
+			});
+		} else {
+			if (id) throw new LocalizationError("Theme strings take no id; pass keys with --set key.path=value.");
+			if (Object.keys(values).length === 0) throw new LocalizationError("Pass theme keys with --set key.path=value or --file.");
+			const themeId = await resolveThemeId(api, opts.theme);
+			const locales = await readThemeLocales(api, themeId);
+			const merged = mergeLocale(localeOf(locales, language.iso) ?? {}, values);
+			await confirmChange(`Save ${Object.keys(values).length} key(s) to locales/${language.iso}.json on theme ${themeId}? Theme changes publish immediately.`, opts.yes);
+			const saved = await writeLocale(api, locales, language.iso, merged);
+			ctx.output({
+				...saved,
+				themeId,
+				lang: language.iso,
+				keys: Object.keys(values)
+			});
+		}
+	}));
+	parent.command("auto <iso>").description("Machine-translate what's missing with Fluid AI and print it; --write saves it (changes live content)").option("--type <type>", `Limit to a type: ${TYPE_NAMES.join(", ")} (repeatable)`, collect, []).option("--limit <n>", "Most items to translate per type in this run", "25").option("--write", "Save the translations; without it nothing is written", false).option("--published-only", "Skip drafts, scheduled, and archived rows", false).option("--from <iso>", "The theme's source locale file; storefront rows and menus translate from the store's default language", "en").option("--theme <id>", "Translate this theme's strings instead of the active theme's").option("--model <provider/name>", "A translation model other than Fluid's default").option("--skip <type:id>", "Leave out one item, e.g. products:42, menu-items:12/340, or theme:cart.title (repeatable)", collect, []).option("--store-language <iso>", "The store's default language, used only when it can't be read from the storefront rows").option("--yes", "Confirm --write without a prompt", false).action((iso, opts) => run(async () => {
+		const api = await client(ctx);
+		const limit = positiveInt(opts.limit, "--limit");
+		for (const item of opts.skip) if (!validSkip(item)) throw new LocalizationError(`--skip takes <type>:<id>, e.g. products:42 or menu-items:12/340, not "${item}".`);
+		const types = selectTypes(opts.type);
+		const { target, source, store } = await autoLanguages(api, types, {
+			iso,
+			from: opts.from,
+			storeLanguage: opts.storeLanguage,
+			write: opts.write
+		});
+		if (opts.write) await confirmChange(`Machine-translate and save up to ${limit} item(s) per type into ${target.name}? Theme changes publish immediately.`, opts.yes);
+		const result = await autoTranslate(api, types, {
+			iso: target.iso,
+			storeName: store.name,
+			sourceName: source.name,
+			targetName: target.name,
+			sourceIso: source.iso,
+			storeIso: store.iso,
+			limit,
+			write: opts.write,
+			publishedOnly: opts.publishedOnly,
+			themeId: opts.theme,
+			model: opts.model,
+			skip: opts.skip
+		});
+		ctx.output({
+			language: {
+				iso: target.iso,
+				name: target.name
+			},
+			...result
+		});
+		if (result.types.some((t) => t.failed.length > 0)) process.exitCode = 1;
+	}));
+	parent.command("walk [iso]").description("Translate a language by answering questions: what's missing, Fluid AI proposals, and accept, edit or skip each one (changes live content)").option("--from <iso>", "The theme's source locale", "en").option("--theme <id>", "Translate this theme's strings instead of the active theme's").option("--batch <n>", "Proposals per Fluid AI call", "10").action((iso, opts) => run(async () => {
+		assertInteractive("`missing`, `auto` and `set`");
+		const result = await walkTranslations({
+			api: await client(ctx),
+			prompter: terminalPrompter()
+		}, {
+			...iso ? { iso } : {},
+			from: opts.from,
+			...opts.theme ? { themeId: opts.theme } : {},
+			batch: positiveInt(opts.batch, "--batch")
+		});
+		ctx.output(result);
+		if (result.failed.length > 0) process.exitCode = 1;
+	}));
+}
+//#endregion
+//#region src/index.ts
+/**
+* One plugin, two command groups: `fluid countries` opens a market and
+* `fluid translations` translates what its shoppers see. The country flow
+* hands language and translation work to `fluid translations`, so each step
+* has one implementation.
+*/
+const plugin = {
+	name: "@fluid-app/fluid-cli-localization",
+	version: "0.1.0",
+	register(ctx) {
+		ctx.program.addCommand(createDomainCommand("countries", "Open a country from Fluid's Country Atlas: settings, prices in its currency, agreements, and a status check", registerCountriesCommands));
+		ctx.program.addCommand(createDomainCommand("translations", "Add a language and translate what shoppers see: storefront, navigation, theme, agreements, and more", registerTranslationsCommands));
+	}
+};
+//#endregion
+export { plugin as default, registerCountriesCommands, registerTranslationsCommands };
+
+//# sourceMappingURL=index.mjs.map