@the-i18n-kit/cli 5.0.0 → 7.0.0

package/dist/descriptors-10sgyqEs.js

@@ -0,0 +1,1225 @@
+import { h as resolveReferenceLocale, s as findLocaleImpl, t as BASE_URL_ENV } from "./providers-BbVPelvp.js";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/core/codequality.ts
+/**
+* GitLab Code Quality (CodeClimate) mapping — pure result-shape → issue-array
+* transforms, no I/O.
+*
+* Format contract (https://docs.gitlab.com/ci/testing/code_quality/):
+* every issue needs description, check_name, fingerprint, severity, and
+* location.path + location.lines.begin, where path is project-root-relative
+* (no leading `./`) and lines.begin is an integer ≥ 1.
+*
+* Fingerprints deliberately exclude line numbers so unrelated edits that
+* shift a usage do not churn findings as new/resolved in the MR widget.
+*/
+const UNDEFINED_KEY_CHECK = "i18n.undefined-key";
+const ORPHAN_KEY_CHECK = "i18n.orphan-key";
+const MISSING_TRANSLATION_CHECK = "i18n.missing-translation";
+const INCOMPLETE_LOCALE_CHECK = "i18n.incomplete-locale";
+const UNCONSUMED_LAYER_CHECK = "i18n.unconsumed-layer";
+const DUPLICATE_KEY_CHECK = "i18n.duplicate-key";
+/** NUL-joined so no part can bleed into its neighbor (keys/paths never contain NUL). */
+function fingerprintOf(...parts) {
+	return createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+/** Normalize to the report's path shape: forward slashes, no leading `./`. */
+function toReportPath(path) {
+	const normalized = path.replaceAll("\\", "/");
+	return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+/** GitLab rejects non-positive or fractional line numbers. */
+function toLineBegin(line) {
+	return Math.max(1, Math.trunc(line));
+}
+/**
+* `check` findings → one issue per usage location. Uncertain findings are
+* not mapped: the widget has no "maybe" state, and a hard-looking finding
+* for an unverifiable key would train consumers to ignore the report.
+*/
+function undefinedKeysToCodeQuality(undefinedKeys) {
+	const issues = [];
+	for (const finding of undefinedKeys) for (const usage of finding.usages) {
+		const path = toReportPath(usage.file);
+		issues.push({
+			description: `i18n key "${finding.key}" is referenced here but defined in no locale file of the consuming app's layers — it renders as the raw key at runtime.`,
+			check_name: UNDEFINED_KEY_CHECK,
+			fingerprint: fingerprintOf(UNDEFINED_KEY_CHECK, finding.key, path),
+			severity: "major",
+			location: {
+				path,
+				lines: { begin: toLineBegin(usage.line) }
+			}
+		});
+	}
+	return issues;
+}
+/**
+* Orphan findings → one issue per key, anchored at the layer's
+* reference-locale file (line 1): orphans live in locale files, not code.
+* The fingerprint is anchor-independent (layer + key), so locale-file
+* renames or layout changes do not churn findings. Uncertain,
+* dynamic-matched, and misplaced keys are not part of `orphansByLayer`
+* and therefore never mapped.
+*/
+function orphanKeysToCodeQuality(orphansByLayer, anchorFileByLayer) {
+	const issues = [];
+	for (const [layer, keys] of Object.entries(orphansByLayer)) {
+		const path = toReportPath(anchorFileByLayer[layer] ?? layer);
+		for (const key of keys) issues.push({
+			description: `Orphan i18n key "${key}" in layer "${layer}" has no source-code reference — it may be consumed dynamically; verify before deleting.`,
+			check_name: ORPHAN_KEY_CHECK,
+			fingerprint: fingerprintOf(ORPHAN_KEY_CHECK, layer, key),
+			severity: "minor",
+			location: {
+				path,
+				lines: { begin: 1 }
+			}
+		});
+	}
+	return issues;
+}
+/**
+* The orphan findings of a result — whatever the run was asked to do with
+* them — mapped and anchored in one call.
+*
+* Takes the result rather than the scan internals, which is what lets the
+* mapping run where the result is handed over instead of inside the operation.
+* A removal run reports what it deleted; either way the keys are the same set
+* the scan found, and nothing else in the result is a finding.
+*/
+function orphanResultToCodeQuality(result, ctx) {
+	const orphansByLayer = result.orphanKeys ?? result.removed ?? {};
+	const { localeDef } = resolveReferenceLocale(ctx.config, ctx.locale);
+	return orphanKeysToCodeQuality(orphansByLayer, referenceLocaleAnchorPaths(ctx.config, Object.keys(orphansByLayer), localeDef, ctx.projectDir));
+}
+/**
+* The locale file of one layer, or the layer name when the config has no path
+* for it. Every issue below anchors at a locale file rather than a call site:
+* these findings are about what a file holds, so there is no line to point at
+* and `lines.begin` is 1 throughout.
+*/
+function anchorPathOf(ctx, layer, localeRef) {
+	const locale = findLocaleImpl(ctx.config, localeRef);
+	return toReportPath((locale === void 0 ? {} : referenceLocaleAnchorPaths(ctx.config, [layer], locale, ctx.projectDir))[layer] ?? layer);
+}
+/**
+* `missing` findings → one issue per key per locale, anchored at the locale file
+* of the layer that is short of it.
+*
+* Minor rather than major: a missing key falls back to another locale and
+* renders text, where an undefined key renders its own name at the user.
+*/
+function missingTranslationsToCodeQuality(result, ctx) {
+	const issues = [];
+	for (const [localeCode, byLayer] of Object.entries(result.missing)) {
+		const locale = findLocaleImpl(ctx.config, localeCode);
+		const anchors = locale === void 0 ? {} : referenceLocaleAnchorPaths(ctx.config, Object.keys(byLayer), locale, ctx.projectDir);
+		for (const [layer, keys] of Object.entries(byLayer)) {
+			const path = toReportPath(anchors[layer] ?? layer);
+			for (const key of keys) issues.push({
+				description: `Missing translation for "${key}" in ${localeCode} — the reference locale defines it, layer "${layer}" does not carry it in this locale.`,
+				check_name: MISSING_TRANSLATION_CHECK,
+				fingerprint: fingerprintOf(MISSING_TRANSLATION_CHECK, layer, localeCode, key),
+				severity: "minor",
+				location: {
+					path,
+					lines: { begin: 1 }
+				}
+			});
+		}
+	}
+	return issues;
+}
+/**
+* `status` findings → one issue per locale under the bar, plus one per layer no
+* app consumes.
+*
+* The bar is `failUnder` when the caller named one and 100% otherwise, so the
+* report says what the gate says. A locale is `info`: coverage is a figure that
+* moves with every merge request and is not a defect. An unconsumed layer is
+* `minor` — keys nothing can render, which is a fact about the project rather
+* than about today's translation work.
+*
+* Protected locales are skipped. Their gaps are deliberate and already excluded
+* from the overall figure; reporting them would be reporting a decision.
+*/
+function statusToCodeQuality(result, ctx) {
+	const threshold = ctx.failUnder ?? 100;
+	const primaryLayer = result.summary.layersScanned[0] ?? "";
+	const issues = [];
+	for (const locale of result.locales) {
+		if (locale.protected === true || locale.completion >= threshold) continue;
+		issues.push({
+			description: `Locale "${locale.code}" is ${locale.completion}% translated, below the ${threshold}% expected — ${locale.missing} key(s) missing, ${locale.empty} empty.`,
+			check_name: INCOMPLETE_LOCALE_CHECK,
+			fingerprint: fingerprintOf(INCOMPLETE_LOCALE_CHECK, locale.code),
+			severity: "info",
+			location: {
+				path: anchorPathOf(ctx, primaryLayer, locale.code) || locale.code,
+				lines: { begin: 1 }
+			}
+		});
+	}
+	const referenceCode = result.summary.referenceLocale.code;
+	for (const layer of result.summary.unconsumedLayers) issues.push({
+		description: `Layer "${layer}" is consumed by no app — the keys it defines cannot render anywhere. Fold it into a consumed layer or declare the app that uses it.`,
+		check_name: UNCONSUMED_LAYER_CHECK,
+		fingerprint: fingerprintOf(UNCONSUMED_LAYER_CHECK, layer),
+		severity: "minor",
+		location: {
+			path: anchorPathOf(ctx, layer, referenceCode),
+			lines: { begin: 1 }
+		}
+	});
+	return issues;
+}
+/**
+* `find-duplicates` collisions → one issue per key defined in both a shared and
+* a consuming layer, anchored at the shadowing layer's file: that is the copy
+* whose value wins at runtime and the one a reader has to look at.
+*
+* Value duplicates (`byValue`) are not mapped. Two keys carrying the same text
+* are a consolidation opportunity, not a defect in the file, and the group has
+* no single key or layer to anchor a stable fingerprint on.
+*/
+function duplicateKeysToCodeQuality(result, ctx) {
+	const { localeDef } = resolveReferenceLocale(ctx.config, ctx.locale);
+	const anchors = referenceLocaleAnchorPaths(ctx.config, [...new Set(result.collisions.map((collision) => collision.childLayer))], localeDef, ctx.projectDir);
+	return result.collisions.map((collision) => ({
+		description: `i18n key "${collision.key}" is defined in both "${collision.sharedLayer}" and "${collision.childLayer}"` + (collision.divergent ? ", with different values — the shared value never shows. Delete one side; never move the key." : ", with the same value — the shared definition never shows. Delete one side; never move the key."),
+		check_name: DUPLICATE_KEY_CHECK,
+		fingerprint: fingerprintOf(DUPLICATE_KEY_CHECK, collision.sharedLayer, collision.childLayer, collision.key),
+		severity: "minor",
+		location: {
+			path: toReportPath(anchors[collision.childLayer] ?? collision.childLayer),
+			lines: { begin: 1 }
+		}
+	}));
+}
+/**
+* Project-root-relative reference-locale file path per layer, the anchor for
+* orphan issues. Aliases resolve to their target layer's directory. Flat
+* layouts anchor at the locale file; namespaced layouts (per-locale
+* directories) have no single file and anchor at the locale's directory.
+*/
+function referenceLocaleAnchorPaths(config, layers, locale, projectDir) {
+	const anchors = {};
+	for (const layer of layers) {
+		const localeDir = config.localeDirs.find((d) => d.layer === layer);
+		const resolved = localeDir?.aliasOf ? config.localeDirs.find((d) => d.layer === localeDir.aliasOf) ?? localeDir : localeDir;
+		if (!resolved) continue;
+		anchors[layer] = toReportPath(relative(projectDir, locale.file ? join(resolved.path, locale.file) : join(resolved.path, locale.code)));
+	}
+	return anchors;
+}
+//#endregion
+//#region src/surface/report.ts
+/** The parameters a `report` declaration adds, in the order they are offered. */
+const REPORT_PARAM_NAMES = ["outputFile", "codequalityOutput"];
+/**
+* The parameters that request a diversion, built from what the operation
+* declared about its report. One description per concept, filled in with the
+* operation's own example, rather than one hand-written variation per command.
+*/
+function reportParams(spec) {
+	return {
+		outputFile: {
+			type: "string",
+			description: `Absolute path to write the full JSON output to. Only a compact summary is returned to the caller, which is what you want for a result too large to read in one piece. Example: "${spec.outputFile.example}"`,
+			...spec.outputFile.cli === void 0 ? {} : { cli: spec.outputFile.cli },
+			...spec.outputFile.mcp === void 0 ? {} : { mcp: spec.outputFile.mcp }
+		},
+		...spec.codequality === void 0 ? {} : { codequalityOutput: {
+			type: "string",
+			description: `Also write the ${spec.codequality.findings} as a GitLab Code Quality (CodeClimate) JSON report to this file path.`,
+			mcp: { hidden: true }
+		} }
+	};
+}
+/**
+* An operation's parameters with the report parameters merged in.
+*
+* They sit after what the operation takes and before the flags that only
+* decide an exit code, which is where they were written by hand and where
+* `--help` and the generated reference still show them.
+*/
+function withReportParams(params, gates, spec) {
+	const gateFlags = flagsOf(gates);
+	const declared = Object.entries(params);
+	return Object.fromEntries([
+		...declared.filter(([name]) => !gateFlags.has(name)),
+		...Object.entries(reportParams(spec)),
+		...declared.filter(([name]) => gateFlags.has(name))
+	]);
+}
+/**
+* Write the result where the caller asked for it, and hand back the compact
+* stand-in — or hand back the result untouched when nothing asked for a file.
+*
+* Called with the arguments the operation ran with, which is what lets an
+* operation answering several questions write each under its own report name.
+*/
+async function divertToReport(result, descriptor, args) {
+	const spec = descriptor.report;
+	if (spec === void 0 || result === null || typeof result !== "object") return result;
+	const projectDir = typeof args.projectDir === "string" ? args.projectDir : process.cwd();
+	const [{ detectI18nConfig }, { resolveOutputFile, resolveReportFilePath, validateReportPath }, { writeCodequalityFile, writeReportFile }] = await Promise.all([
+		import("./detector-BJTkyhQ0.js"),
+		import("./report-CHZgH9Wy.js"),
+		import("./json-writer-D0b6vEax.js")
+	]);
+	const config = await detectI18nConfig(projectDir);
+	const codequalityOutput = pathArg(args.codequalityOutput);
+	if (spec.codequality !== void 0 && codequalityOutput !== void 0) {
+		const issues = spec.codequality.issues(result, {
+			projectDir,
+			config,
+			args
+		});
+		if (issues !== void 0) {
+			validateReportPath(projectDir, codequalityOutput);
+			await writeCodequalityFile(codequalityOutput, issues);
+		}
+	}
+	const name = typeof spec.name === "function" ? spec.name(args) : spec.name;
+	const reportFile = resolveOutputFile(projectDir, pathArg(args.outputFile)) ?? resolveReportFilePath(config, projectDir, name);
+	if (reportFile === void 0) return result;
+	await writeReportFile(reportFile, result, {
+		tool: name,
+		args: requestedArgs(descriptor, args)
+	});
+	return {
+		reportFile,
+		summary: spec.summary(result)
+	};
+}
+/**
+* What the report records as the request behind it: what the caller actually
+* asked for. Arguments left at their default say nothing a reader of the file
+* does not already know, the report parameters are how the file was asked for
+* rather than part of the question, and a gate flag decides an exit code and
+* nothing about the result.
+*/
+function requestedArgs(descriptor, args) {
+	const excluded = new Set([...REPORT_PARAM_NAMES, ...flagsOf(descriptor.gates)]);
+	const requested = {};
+	for (const [name, spec] of Object.entries(descriptor.params)) {
+		const value = args[name];
+		if (excluded.has(name) || value === void 0 || value === spec.default) continue;
+		requested[name] = value;
+	}
+	return requested;
+}
+function flagsOf(gates) {
+	const flags = /* @__PURE__ */ new Set();
+	for (const gate of gates ?? []) if (gate.flag !== void 0) flags.add(gate.flag);
+	return flags;
+}
+/** A path parameter as the surfaces deliver it; anything else is not a path. */
+function pathArg(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+//#endregion
+//#region src/surface/types.ts
+/**
+* Declare one operation. The `const` type parameter is what keeps `required:
+* true` and `enum: [...]` literal, so `run` receives `layer: string` rather
+* than `string | undefined` for a parameter the surface guarantees.
+*
+* An operation that declares a `report` gains the parameters that request one
+* here, so the two cannot drift apart.
+*/
+function defineOperation(descriptor) {
+	const erased = descriptor;
+	if (erased.report === void 0) return erased;
+	return {
+		...erased,
+		params: withReportParams(erased.params, erased.gates, erased.report)
+	};
+}
+//#endregion
+//#region src/surface/guidance.ts
+const NO_PROVIDER_CLI = "No provider configured — nothing was translated. Pass --provider and --model (API key via --apiKey or the OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY env vars) to translate automatically.";
+const AGENT_MODE_MCP = "Agent mode — no provider configured on the server. Use the fallbackContexts to translate inline, then call write_translations (mode: \"upsert\") to write the results. To enable provider mode, set I18N_PROVIDER, I18N_MODEL, and the provider API key env on the server process.";
+const AGENT_MODE_KEY_MCP = "Agent mode — no provider configured on the server. Use the fallbackContext to translate inline, then call write_translations (mode: \"upsert\") to write the results. To enable provider mode, set I18N_PROVIDER, I18N_MODEL, and the provider API key env on the server process.";
+/**
+* Locales that lost at least one key, sorted for a stable message.
+* A bare `totalFailed: 141` says nothing about which languages shipped
+* incomplete — this is what makes the count actionable in a CI log.
+* Reads the full and the compact shapes, since either may reach here.
+*/
+function localesWithFailures(result) {
+	const perLayer = "layers" in result ? Object.values(result.layers) : [result];
+	const locales = /* @__PURE__ */ new Set();
+	for (const layer of perLayer) {
+		for (const [locale, entry] of Object.entries(layer.results ?? {})) if (entry.failed.length > 0) locales.add(locale);
+		for (const entry of layer.summary.byLocale ?? []) if (entry.failed > 0) locales.add(entry.locale);
+	}
+	return [...locales].sort();
+}
+/** True when any layer of the outcome carries fallback contexts to translate by hand. */
+function hasFallbackContexts(result) {
+	return "layers" in result ? Object.values(result.layers).some((layer) => layer.fallbackContexts) : Boolean(result.fallbackContexts);
+}
+function applyTranslateMissingGuidance(result, surface) {
+	if (surface === "mcp") {
+		if (hasFallbackContexts(result) && result.summary) result.summary.message = AGENT_MODE_MCP;
+		return;
+	}
+	if (result.summary.mode === "agent") {
+		result.summary.message = NO_PROVIDER_CLI;
+		return;
+	}
+	if (result.summary.totalFailed > 0) {
+		const affected = localesWithFailures(result);
+		result.summary.message = `${result.summary.totalFailed} key(s) failed to translate` + (affected.length > 0 ? ` (locales: ${affected.join(", ")})` : "") + ". Those keys remain missing — re-run to retry them. Pass --fail-on-failed to make this exit 2 in CI.";
+	}
+}
+function applyTranslateKeyGuidance(result, surface) {
+	if (surface === "mcp") {
+		if (result.fallbackContext) result.message = AGENT_MODE_KEY_MCP;
+		return;
+	}
+	if (result.mode === "agent" && result.skipped.some((skip) => skip.reason === "no-provider")) result.message = NO_PROVIDER_CLI;
+}
+//#endregion
+//#region src/surface/descriptors.ts
+/**
+* Every operation the kit exposes, declared once.
+*
+* The CLI builds its fifteen commands from this table and the MCP server builds
+* its fifteen tools from it. Read `./types.ts` first for what a descriptor is
+* allowed to say; this file is the table itself.
+*
+* The core operations are imported per run rather than at module load. This
+* table is read by `--help`, by the tool registrar and by the reference
+* generator, none of which run anything, while the core barrel pulls in the
+* scanner, the parsers and the file writers — a quarter of a megabyte nobody
+* asking for usage text should pay for.
+*/
+const core = () => import("./operations-D7IMu_xY.js");
+const layerFilter = {
+	type: "string",
+	description: "Layer name to scope this to (e.g., \"root\", \"app-admin\"). If omitted, every layer is included. Call discover to list the layers."
+};
+const layerRequired = {
+	type: "string",
+	required: true,
+	description: "Layer name from discover (e.g., \"root\", \"app-admin\")."
+};
+const referenceLocale = {
+	type: "string",
+	description: "Locale code used as the source of truth (e.g., \"en\", \"en-US\"). Defaults to the project default locale.",
+	cli: { alias: "ref" }
+};
+const readLocale = {
+	type: "string",
+	description: "Locale code to read from (e.g., \"en\", \"en-US\"). Defaults to the project default locale. Keys are the same across locales, so one is enough."
+};
+const dryRun = (description) => ({
+	type: "boolean",
+	default: false,
+	description
+});
+const scanDirs = {
+	type: "string[]",
+	description: "Absolute paths of the directories to scan for source usage. Overrides scope-aware scanning: every layer is then checked against these directories alone. Example: [\"/home/user/my-app/apps/admin\"].",
+	cli: { hidden: true }
+};
+const excludeDirs = {
+	type: "string[]",
+	description: "Directory names to skip when scanning source files. Example: [\"storybook\", \"__tests__\", \"node_modules\"].",
+	cli: { hidden: true }
+};
+/**
+* Provider selection, shared by the two translating operations.
+*
+* CLI only: the server resolves one backend at startup from I18N_PROVIDER,
+* I18N_MODEL and the provider's API key env, so a request cannot pick another
+* one — and an API key does not belong in a tool call an agent composes.
+*/
+const providerParams = {
+	provider: {
+		type: "string",
+		enum: [
+			"openai",
+			"anthropic",
+			"google"
+		],
+		description: "LLM provider to translate through. Without one nothing is translated automatically — the result carries the contexts to translate by hand instead.",
+		mcp: { hidden: true }
+	},
+	model: {
+		type: "string",
+		description: "Model name. Required whenever a provider is set.",
+		mcp: { hidden: true }
+	},
+	apiKey: {
+		type: "string",
+		description: "API key. Falls back to the OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY environment variables.",
+		mcp: { hidden: true }
+	},
+	baseUrl: {
+		type: "string",
+		description: `Provider base URL for gateways, self-hosted models and proxies speaking the provider's protocol. Falls back to ${BASE_URL_ENV}, then to providerBaseUrl in .i18n-mcp.json.`,
+		mcp: { hidden: true }
+	}
+};
+/**
+* Registry order: it is the order `the-i18n-cli --help` lists commands in and
+* the order both generated reference overviews are written in.
+*/
+const descriptors = [
+	defineOperation({
+		id: "init",
+		cli: { name: "init" },
+		mcp: null,
+		description: "Create a schema-valid .i18n-mcp.json from framework detection. Non-interactive; refuses to overwrite without force.",
+		params: {
+			force: {
+				type: "boolean",
+				default: false,
+				description: "Overwrite an existing .i18n-mcp.json."
+			},
+			dryRun: dryRun("Report the config that would be written without touching disk. Default: false.")
+		},
+		async run(args) {
+			const { initProjectConfig } = await core();
+			return initProjectConfig({
+				projectDir: args.projectDir,
+				force: args.force,
+				dryRun: args.dryRun
+			});
+		}
+	}),
+	defineOperation({
+		id: "discover",
+		cli: { name: "discover" },
+		mcp: {
+			name: "discover",
+			title: "Discover i18n Setup"
+		},
+		description: "Describe the project: detected config, locale directories per layer with file counts and top-level namespaces, the layer graph, and the hand-maintained locales.",
+		longDescription: "Call this first to understand the project before reading or writing translations. The result also names the active translation mode (\"provider\" when the server has an env-configured LLM provider, \"agent\" otherwise). layerGraph answers where a new key belongs: a key used by more than one app belongs in a layer those apps share, and layerGraph.shared names those layers.",
+		params: {},
+		async run(args) {
+			const { describeProject } = await core();
+			return describeProject({ projectDir: args.projectDir });
+		}
+	}),
+	defineOperation({
+		id: "list-namespaces",
+		cli: null,
+		mcp: {
+			name: "list_namespaces",
+			title: "List Namespaces"
+		},
+		description: "List the translation key tree grouped by namespace prefix, with a count per namespace node.",
+		longDescription: "Use this to explore the available keys without guessing path prefixes.",
+		params: {
+			layer: {
+				...layerFilter,
+				description: "Layer name to filter by (e.g., \"root\", \"app-admin\"). If omitted or \"*\", scans all layers. Call discover to list the layers."
+			},
+			locale: readLocale
+		},
+		async run(args) {
+			const { listNamespaces } = await core();
+			return listNamespaces({
+				layer: args.layer,
+				locale: args.locale,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "get",
+		cli: { name: "get" },
+		mcp: {
+			name: "get_translations",
+			title: "Get Translations"
+		},
+		description: "Get translation values for given key paths from a specific locale and layer. Use \"*\" as the locale to read from all locales.",
+		params: {
+			layer: layerRequired,
+			locale: {
+				type: "string",
+				required: true,
+				description: "Locale code, locale file name, or \"*\" to read all locales. Examples: \"en\", \"en-US\", \"en-US.json\", \"*\"."
+			},
+			keys: {
+				type: "string[]",
+				required: true,
+				description: "Dot-separated key paths to read. Example: [\"common.actions.save\", \"auth.login.title\"]."
+			},
+			compact: {
+				type: "boolean",
+				description: "When true and locale is \"*\", returns a summary grouped by key instead of per-locale detail. Default: false.",
+				cli: { hidden: true }
+			}
+		},
+		async run(args) {
+			const { getTranslations } = await core();
+			return getTranslations({
+				layer: args.layer,
+				locale: args.locale,
+				keys: args.keys,
+				compact: args.compact,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "write",
+		cli: { name: "write" },
+		mcp: {
+			name: "write_translations",
+			title: "Write Translations"
+		},
+		description: "Write translation key-value pairs to a layer. Keys are inserted in alphabetical order.",
+		longDescription: "Mode \"upsert\" adds new keys and updates existing ones (default, most common). Mode \"add\" only creates new keys, skipping existing ones. Mode \"update\" only modifies existing keys, skipping missing ones. Use dryRun to preview without writing.",
+		params: {
+			layer: layerRequired,
+			translations: {
+				type: "record",
+				required: true,
+				description: "Map of dot-path keys to locale-value pairs. IMPORTANT: values must be locale maps, NOT plain strings. Locale refs may be a code (\"en-us\"), a language (\"en-US\") or a file (\"en-US.json\"). Wrong: { \"auth.failed\": \"Login failed\" }. Correct: { \"auth.failed\": { \"en-US\": \"Login failed\", \"de-DE\": \"Anmeldung fehlgeschlagen\" } }"
+			},
+			mode: {
+				type: "string",
+				enum: [
+					"add",
+					"update",
+					"upsert"
+				],
+				default: "upsert",
+				description: "Write mode. \"upsert\": add-or-update (never fails). \"add\": only new keys. \"update\": only existing keys. Default: \"upsert\"."
+			},
+			dryRun: dryRun("Return a preview of what would be written without writing any files. Default: false.")
+		},
+		async run(args) {
+			const { writeTranslations } = await core();
+			return writeTranslations({
+				layer: args.layer,
+				translations: args.translations,
+				mode: args.mode,
+				dryRun: args.dryRun,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "missing",
+		cli: { name: "missing" },
+		mcp: {
+			name: "get_missing_translations",
+			title: "Get Missing Translations"
+		},
+		description: "Find translation keys that exist in the reference locale but are missing in other locales. Scans a specific layer or all layers.",
+		params: {
+			layer: layerFilter,
+			referenceLocale,
+			targetLocales: {
+				type: "string[]",
+				description: "Locale codes to check for missing keys (e.g., [\"de\", \"fr\", \"es\"]). Defaults to all locales except the reference.",
+				cli: { alias: "targets" }
+			},
+			failOnMissing: {
+				type: "boolean",
+				default: false,
+				description: "Exit 2 when any key is missing (CI gate).",
+				mcp: { hidden: true }
+			}
+		},
+		gates: [{
+			flag: "failOnMissing",
+			counter: "totalMissingKeys",
+			threshold: 0
+		}],
+		report: {
+			name: "get_missing_translations",
+			outputFile: { example: "/tmp/missing-translations.json" },
+			summary: (result) => result.summary,
+			codequality: {
+				findings: "missing translations",
+				issues: (result, ctx) => missingTranslationsToCodeQuality(result, {
+					config: ctx.config,
+					projectDir: ctx.projectDir
+				})
+			}
+		},
+		async run(args) {
+			const { getMissingTranslations } = await core();
+			return getMissingTranslations({
+				layer: args.layer,
+				referenceLocale: args.referenceLocale,
+				targetLocales: args.targetLocales,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "status",
+		cli: { name: "status" },
+		mcp: {
+			name: "get_translation_status",
+			title: "Get Translation Status"
+		},
+		description: "Translation coverage in one call: per-locale and per-layer counts of total, translated, missing and empty keys, plus an overall completion percentage.",
+		longDescription: "Use this instead of calling get_missing_translations per layer and counting keys yourself. Empty-string values count as untranslated; set listEmpty to get the keys behind that count — they exist in the locale file, so they are never reported as missing, and they render as nothing in the UI. Locales listed in protectedLocales are reported but excluded from the overall figure, since they are maintained by hand.",
+		params: {
+			layer: layerFilter,
+			referenceLocale,
+			listEmpty: {
+				type: "boolean",
+				default: false,
+				description: "Also list the keys behind summary.emptyKeys under \"empty\" (locale → layer → keys), and keys that are empty in the reference locale itself under \"emptyInReference\" — useful after a scaffold or an interrupted translation run. Default: false, which returns counts only."
+			},
+			failUnder: {
+				type: "number",
+				description: "Exit 2 when overall completion is below this percentage (CI gate).",
+				mcp: { hidden: true }
+			}
+		},
+		gates: [{
+			flag: "failUnder",
+			counter: "completionPercent",
+			direction: "below"
+		}],
+		report: {
+			name: "get_translation_status",
+			outputFile: { example: "/tmp/translation-status.json" },
+			summary: (result) => result.summary,
+			codequality: {
+				findings: "incomplete locales and unconsumed layers",
+				issues: (result, ctx) => statusToCodeQuality(result, {
+					config: ctx.config,
+					projectDir: ctx.projectDir,
+					failUnder: ctx.args.failUnder
+				})
+			}
+		},
+		async run(args) {
+			const { getTranslationStatus } = await core();
+			return getTranslationStatus({
+				layer: args.layer,
+				referenceLocale: args.referenceLocale,
+				listEmpty: args.listEmpty,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "search",
+		cli: { name: "search" },
+		mcp: {
+			name: "search_translations",
+			title: "Search Translations"
+		},
+		description: "Search translation files by key path or value. A case-insensitive substring match — not fuzzy, not a regular expression.",
+		longDescription: "Useful for finding an existing translation before adding a duplicate of it.",
+		params: {
+			query: {
+				type: "string",
+				required: true,
+				description: "Substring to search for, matched against keys and/or values. Case-insensitive. Example: \"save\" matches the key \"common.actions.save\" and the value \"Save changes\"."
+			},
+			searchIn: {
+				type: "string",
+				enum: [
+					"keys",
+					"values",
+					"both"
+				],
+				default: "both",
+				description: "Whether to search translation keys, values, or both. Default: \"both\".",
+				cli: { alias: "in" }
+			},
+			layer: {
+				...layerFilter,
+				description: "Layer name to search in (e.g., \"root\", \"app-admin\"), or \"*\" for all layers. If omitted, searches every layer."
+			},
+			locale: {
+				type: "string",
+				description: "Locale code to search in (e.g., \"en\", \"de\"). If omitted, searches every locale."
+			}
+		},
+		report: {
+			name: "search_translations",
+			outputFile: {
+				example: "/tmp/search-results.json",
+				cli: { hidden: true }
+			},
+			summary: (result) => ({ totalMatches: result.totalMatches })
+		},
+		async run(args) {
+			const { searchTranslations } = await core();
+			return searchTranslations({
+				query: args.query,
+				searchIn: args.searchIn,
+				layer: args.layer,
+				locale: args.locale,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "remove",
+		cli: { name: "remove" },
+		mcp: {
+			name: "remove_translations",
+			title: "Remove Translations"
+		},
+		description: "Remove one or more translation keys from ALL locale files in the given layer.",
+		longDescription: "Use dryRun to preview the changes before applying them.",
+		params: {
+			layer: {
+				...layerRequired,
+				description: "Layer name from discover (e.g., \"root\", \"app-admin\"). The keys are removed from ALL locale files in this layer."
+			},
+			keys: {
+				type: "string[]",
+				required: true,
+				description: "Dot-separated key paths to remove from every locale file in the layer. Example: [\"common.actions.delete\", \"auth.errors.expired\"]."
+			},
+			dryRun: dryRun("Return a preview of what would be removed without writing any files. Default: false.")
+		},
+		async run(args) {
+			const { removeTranslations } = await core();
+			return removeTranslations({
+				layer: args.layer,
+				keys: args.keys,
+				dryRun: args.dryRun,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "move",
+		cli: { name: "move" },
+		mcp: {
+			name: "move_translation_key",
+			title: "Move or Rename a Translation Key"
+		},
+		description: "Move a translation key to another layer, to another key path, or both, carrying every locale that defines it.",
+		longDescription: "Pass toLayer to promote an app-layer key to a shared layer once a second app needs it (or to demote a shared key that turned out to be app-specific); call discover first, layerGraph.shared names the layers more than one app consumes. Pass newKey alone to rename the key in place across every locale file of its layer. Writes nothing at all if the destination already holds the key with a different value in any locale; if it holds the same value, that locale is deduplicated instead. Use dryRun to preview the plan.",
+		params: {
+			layer: {
+				...layerRequired,
+				description: "Layer the key lives in today, from discover. Example: \"app-admin\"."
+			},
+			key: {
+				type: "string",
+				required: true,
+				description: "Dot-separated key path to move. Example: \"calendar.views.save\"."
+			},
+			toLayer: {
+				type: "string",
+				description: "Layer to move it to, from discover. Example: \"root\". Omit (or repeat layer) to rename the key within its current layer, which then requires newKey."
+			},
+			newKey: {
+				type: "string",
+				description: "Key path to give it. Example: \"common.actions.save\". Omit to keep the current path, which then requires toLayer."
+			},
+			dryRun: dryRun("Return the plan without writing any files. Default: false.")
+		},
+		async run(args) {
+			const { moveTranslationKey } = await core();
+			return moveTranslationKey({
+				layer: args.layer,
+				key: args.key,
+				toLayer: args.toLayer,
+				newKey: args.newKey,
+				dryRun: args.dryRun,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "translate",
+		cli: { name: "translate" },
+		mcp: {
+			name: "translate_missing",
+			title: "Translate Missing",
+			annotations: {
+				title: "Translate Missing Translations",
+				readOnlyHint: false
+			}
+		},
+		description: "Find the keys missing in the target locales and translate them. Without a translation backend nothing is written: the result carries per-locale fallback contexts to translate by hand instead.",
+		longDescription: "Two modes: in provider mode (the server env-configured with I18N_PROVIDER, I18N_MODEL and an API key) it calls the LLM provider directly and writes the results; in agent mode it returns those fallbackContexts — translate them inline and persist via write_translations. Check the discover output for the active mode. Uses the project config (glossary, translation prompt, locale notes, examples) where there is one. Translates all locales concurrently, so pass every target locale at once.",
+		params: {
+			layer: {
+				...layerFilter,
+				description: "Layer to translate (e.g., \"root\", \"app-admin\"). Omit to translate every locale-backed layer in one call — the recommended default for layered projects, which returns a result per layer plus an aggregated summary."
+			},
+			referenceLocale: {
+				...referenceLocale,
+				description: "Locale code used as the translation source (e.g., \"en\", \"en-US\"). Defaults to the project default locale."
+			},
+			targetLocales: {
+				type: "string[]",
+				description: "Locale codes to translate into (e.g., [\"de\", \"fr\", \"sv\"]). Defaults to all locales except the reference.",
+				cli: { alias: "targets" }
+			},
+			keys: {
+				type: "string[]",
+				description: "Dot-path keys to translate (e.g., [\"auth.login.title\", \"common.save\"]). If omitted, translates every missing key in the layer."
+			},
+			batchSize: {
+				type: "number",
+				integer: true,
+				min: 1,
+				description: "Maximum number of keys per provider request. Default: 50. A lower value reduces per-batch risk and increases round trips."
+			},
+			overwriteStale: {
+				type: "boolean",
+				default: false,
+				description: "Also re-translate keys whose target value was written from source text that has changed since. Requires translationMemory in the project config — without it nothing is known to be stale and this changes nothing. Default: false, which reports those keys under \"stale\" and leaves their values alone."
+			},
+			dryRun: dryRun("Return which keys would be translated without calling the provider or writing files. Default: false."),
+			compact: {
+				type: "boolean",
+				description: "Return a compact summary (totalTranslated, totalFailed, byLocale) instead of full per-locale results. Default: false.",
+				cli: { hidden: true }
+			},
+			...providerParams,
+			failOnFailed: {
+				type: "boolean",
+				default: false,
+				description: "Exit 2 when any key failed to translate (CI gate).",
+				mcp: { hidden: true }
+			}
+		},
+		gates: [{
+			flag: "failOnFailed",
+			counter: "totalFailed",
+			threshold: 0
+		}],
+		usesTranslateFn: true,
+		async run(args, ctx) {
+			const { translateMissing } = await core();
+			const result = await translateMissing({
+				layer: args.layer,
+				referenceLocale: args.referenceLocale,
+				targetLocales: args.targetLocales,
+				keys: args.keys,
+				batchSize: args.batchSize,
+				overwriteStale: args.overwriteStale,
+				dryRun: args.dryRun,
+				compact: args.compact,
+				projectDir: args.projectDir,
+				translateFn: ctx.translateFn,
+				progressFn: ctx.progressFn,
+				onProgressTotal: ctx.onProgressTotal
+			});
+			applyTranslateMissingGuidance(result, ctx.surface);
+			return result;
+		}
+	}),
+	defineOperation({
+		id: "translate-key",
+		cli: { name: "translate-key" },
+		mcp: {
+			name: "translate_key",
+			title: "Translate Key",
+			annotations: {
+				title: "Translate Single Key",
+				readOnlyHint: false
+			}
+		},
+		description: "Add or update one source translation key and translate it into the target locales.",
+		longDescription: "Unlike translate_missing, this can overwrite an existing but stale target translation. Same two modes as translate_missing: provider mode (the server env-configured) translates directly; agent mode returns a fallbackContext — translate it inline and persist via write_translations.",
+		params: {
+			layer: {
+				...layerRequired,
+				description: "Layer holding the key, from discover (e.g., \"root\", \"app-admin\")."
+			},
+			key: {
+				type: "string",
+				required: true,
+				description: "Dot-separated key path to translate. Example: \"bookingCreator.options.removeSubResource\"."
+			},
+			sourceLocale: {
+				type: "string",
+				required: true,
+				description: "Source locale ref. May be a code (\"en-us\"), a language (\"en-US\") or a file (\"en-US.json\")."
+			},
+			sourceValue: {
+				type: "string",
+				description: "Source value to write before translating. If omitted, the existing source value is read."
+			},
+			targetLocales: {
+				type: "string[]",
+				allowAll: true,
+				description: "Locales to translate into. Pass \"all\", or omit, for every locale except the source.",
+				cli: { alias: "targets" }
+			},
+			overwrite: {
+				type: "boolean",
+				default: true,
+				description: "Overwrite existing target translations. When false, only missing targets are filled. Default: true."
+			},
+			dryRun: dryRun("Report the source and target locales without writing files or calling the translation backend. Default: false."),
+			includePreview: {
+				type: "boolean",
+				default: false,
+				description: "Include the translated values in the result. Default: false, which keeps the response compact."
+			},
+			...providerParams
+		},
+		usesTranslateFn: true,
+		async run(args, ctx) {
+			const { translateKey } = await core();
+			const result = await translateKey({
+				layer: args.layer,
+				key: args.key,
+				sourceLocale: args.sourceLocale,
+				sourceValue: args.sourceValue,
+				targetLocales: args.targetLocales,
+				overwrite: args.overwrite,
+				dryRun: args.dryRun,
+				includePreview: args.includePreview,
+				projectDir: args.projectDir,
+				translateFn: ctx.translateFn
+			});
+			applyTranslateKeyGuidance(result, ctx.surface);
+			return result;
+		}
+	}),
+	defineOperation({
+		id: "check",
+		cli: { name: "check" },
+		mcp: {
+			name: "find_undefined_keys",
+			title: "Find Used-But-Undefined Translation Keys"
+		},
+		description: "Find keys referenced in source code but defined in NO locale layer the using app consumes — the direction that ships raw keys to production.",
+		longDescription: "The inverse of find_orphan_keys. Scope-aware: each scan unit (app) is checked against the layers it consumes (summary.searchedLayersByApp), so a key defined only in a layer the using app does not consume is still undefined for that app. Known limitation: extraction is line-based and static — dynamically built keys (template literals, concatenation) cannot be verified and are reported as uncertainKeys, never as hard findings. With write, the hard findings are also added to a locale file as empty translations, which is the first half of the fix; uncertain findings are never written.",
+		params: {
+			locale: {
+				...readLocale,
+				description: "Reference locale to resolve key definitions in (e.g., \"en\", \"en-US\"). Defaults to the project default locale."
+			},
+			write: {
+				type: "boolean",
+				default: false,
+				description: "Add every undefined key to a locale file, with an empty string as its value, in the project default locale only. Existing values are never touched, and uncertain findings are never written. The layer is the one the using code resolves against; when that is more than one layer, the run refuses and asks for a layer name. Default: false, which only reports."
+			},
+			layer: {
+				type: "string",
+				description: "Layer to write the undefined keys into (e.g., \"root\", \"app-admin\"). Only read together with write, and only needed when the using code resolves against more than one layer. Call discover to list the layers."
+			},
+			scanDirs,
+			excludeDirs
+		},
+		gates: [{
+			name: "undefined-keys",
+			counter: "undefinedCount",
+			threshold: 0
+		}],
+		report: {
+			name: "find_undefined_keys",
+			outputFile: { example: "/tmp/undefined-keys.json" },
+			summary: (result) => result.summary,
+			codequality: {
+				findings: "findings",
+				issues: (result) => undefinedKeysToCodeQuality(result.undefinedKeys)
+			}
+		},
+		async run(args) {
+			const { checkUndefinedKeys } = await core();
+			return checkUndefinedKeys({
+				locale: args.locale,
+				write: args.write,
+				layer: args.layer,
+				scanDirs: args.scanDirs,
+				excludeDirs: args.excludeDirs,
+				projectDir: args.projectDir
+			});
+		}
+	}),
+	defineOperation({
+		id: "orphans",
+		cli: { name: "orphans" },
+		mcp: {
+			name: "find_orphan_keys",
+			title: "Find Orphan Translation Keys"
+		},
+		description: "Report translation keys that no source code references. Nothing is deleted unless remove is set.",
+		longDescription: "Scans a specific layer or all layers, and also detects dynamic key patterns and uncertain matches. Scope-aware: each layer is checked only against the code of the apps that consume it (summary.scanScope shows each layer's effective scope), and keys referenced only from non-consuming apps are reported separately as misplacedUsages rather than as orphans. With remove the orphan keys are deleted from every locale file of their layer — uncertain keys and misplaced usages are never deleted, in any mode.",
+		params: {
+			layer: layerFilter,
+			locale: {
+				...readLocale,
+				description: "Locale code to read the translation keys from (e.g., \"en\", \"en-US\"). Defaults to the project default locale."
+			},
+			remove: {
+				type: "boolean",
+				default: false,
+				description: "Permanently delete the orphan keys from every locale file of their layer. Default: false, which only reports them — run without it first and read the findings. Uncertain keys and misplaced usages are never deleted."
+			},
+			usages: {
+				type: "boolean",
+				default: false,
+				description: "Report where keys are referenced in source (file paths and line numbers) instead of which keys are unreferenced.",
+				mcp: { hidden: true }
+			},
+			keys: {
+				type: "string[]",
+				description: "Keys to report usages for. Only read together with usages; without it, every key is considered.",
+				mcp: { hidden: true }
+			},
+			scanDirs,
+			excludeDirs,
+			failOnOrphans: {
+				type: "boolean",
+				default: false,
+				description: "Exit 2 when any orphan key is found (CI gate).",
+				mcp: { hidden: true }
+			}
+		},
+		gates: [{
+			flag: "failOnOrphans",
+			counter: "orphanCount",
+			threshold: 0
+		}],
+		report: {
+			name: (args) => args.usages === true ? "scan_code_usage" : args.remove === true ? "remove_orphan_keys" : "find_orphan_keys",
+			outputFile: { example: "/tmp/orphan-keys.json" },
+			summary: (result) => result.summary,
+			codequality: {
+				findings: "orphan findings",
+				issues: (result, ctx) => "usages" in result ? void 0 : orphanResultToCodeQuality(result, {
+					config: ctx.config,
+					projectDir: ctx.projectDir,
+					locale: ctx.args.locale
+				})
+			}
+		},
+		async run(args, ctx) {
+			const { findOrphanKeys, removeOrphanKeys, scanCodeUsage } = await core();
+			if (args.usages) {
+				if (args.remove) throw new Error("--usages reports where keys are used and never writes. Drop --remove, or drop --usages to delete orphans.");
+				return scanCodeUsage({
+					keys: args.keys,
+					scanDirs: args.scanDirs,
+					excludeDirs: args.excludeDirs,
+					projectDir: args.projectDir
+				});
+			}
+			if (args.remove) return removeOrphanKeys({
+				layer: args.layer,
+				locale: args.locale,
+				scanDirs: args.scanDirs,
+				excludeDirs: args.excludeDirs,
+				dryRun: false,
+				projectDir: args.projectDir,
+				progressFn: ctx.progressFn,
+				onProgressTotal: ctx.onProgressTotal
+			});
+			return findOrphanKeys({
+				layer: args.layer,
+				locale: args.locale,
+				scanDirs: args.scanDirs,
+				excludeDirs: args.excludeDirs,
+				projectDir: args.projectDir,
+				progressFn: ctx.progressFn,
+				onProgressTotal: ctx.onProgressTotal
+			});
+		}
+	}),
+	defineOperation({
+		id: "find-duplicates",
+		cli: { name: "find-duplicates" },
+		mcp: {
+			name: "find_duplicate_keys",
+			title: "Find Duplicate Translation Keys Across Layers"
+		},
+		description: "Find translation keys defined in BOTH a shared layer and an app layer that consumes it.",
+		longDescription: "For example the same key in a monorepo root layer and in app-shop. At runtime the app layer's value shadows the shared one, so a collision with divergent values is the dangerous case: the shared value silently never shows. Compares one reference locale and reports each collision with both values and a divergent flag. Fix by deleting one side, never by moving.",
+		params: {
+			locale: {
+				...readLocale,
+				description: "Locale code to compare values in (e.g., \"de\", \"en-US\"). Defaults to the project default locale."
+			},
+			byValue: {
+				type: "boolean",
+				default: false,
+				description: "Also group different keys carrying the same value — e.g. common.actions.save and calendar.views.save both \"Speichern\". Each group says what to do about it: \"reuse\" (a shared layer already has it — delete the app copies and repoint the call sites), \"promote\" (move one to a shared layer) or \"consolidate\" (duplication inside one layer). Default: false."
+			},
+			minValueLength: {
+				type: "number",
+				integer: true,
+				min: 1,
+				description: "Shortest value worth grouping when byValue is set. Default: 4 — below that, values like \"OK\" repeat across unrelated namespaces legitimately."
+			}
+		},
+		report: {
+			name: "find_duplicate_keys",
+			outputFile: { example: "/tmp/duplicate-keys.json" },
+			summary: (result) => result.summary,
+			codequality: {
+				findings: "duplicate keys",
+				issues: (result, ctx) => duplicateKeysToCodeQuality(result, {
+					config: ctx.config,
+					projectDir: ctx.projectDir,
+					locale: ctx.args.locale
+				})
+			}
+		},
+		async run(args) {
+			const { findDuplicateKeys } = await core();
+			return findDuplicateKeys({
+				locale: args.locale,
+				projectDir: args.projectDir,
+				byValue: args.byValue,
+				minValueLength: args.minValueLength
+			});
+		}
+	}),
+	defineOperation({
+		id: "scaffold",
+		cli: { name: "scaffold" },
+		mcp: {
+			name: "scaffold_locale",
+			title: "Scaffold Locale"
+		},
+		description: "Create empty locale files for new languages, copying the key structure of the default locale with every value set to an empty string.",
+		longDescription: "Supports both JSON (Nuxt) and PHP (Laravel) formats. Does NOT modify the framework configuration — add the locale there first, then call this.",
+		params: {
+			locales: {
+				type: "string[]",
+				description: "Locale codes to scaffold empty files for (e.g., [\"sv\", \"ja\", \"pt-BR\"]). If omitted, auto-detects the locales the config declares but has no files for."
+			},
+			layer: {
+				...layerFilter,
+				description: "Layer to scaffold in (e.g., \"root\", \"app-admin\"). If omitted, scaffolds across every layer."
+			},
+			dryRun: dryRun("Report the files that would be created without writing them. Default: false.")
+		},
+		async run(args) {
+			const { scaffoldLocaleFiles } = await core();
+			return scaffoldLocaleFiles({
+				locales: args.locales,
+				layer: args.layer,
+				dryRun: args.dryRun,
+				projectDir: args.projectDir
+			});
+		}
+	})
+];
+/** The descriptors a surface exposes, in registry order. */
+function descriptorsFor(surface) {
+	return descriptors.filter((descriptor) => descriptor[surface] !== null);
+}
+/** The parameter names a surface exposes for one operation, in declaration order. */
+function visibleParams(descriptor, surface) {
+	return Object.entries(descriptor.params).filter(([, spec]) => spec[surface]?.hidden !== true).map(([name]) => name);
+}
+//#endregion
+export { divertToReport as i, descriptorsFor as n, visibleParams as r, descriptors as t };
+
+//# sourceMappingURL=descriptors-10sgyqEs.js.map