@metabase/cli 0.3.2-alpha.fix-transform-test-ee-path.8ac2a7a → 0.4.0-alpha.release-65-integration-branch.31ca6bb

package/dist/{parse-enum-Dc0dMZ3P.mjs → parse-enum-CLIXMsd8.mjs}

@@ -1,4 +1,4 @@
-import { Q as ConfigError } from "./cli.mjs";
+import { at as ConfigError } from "./cli.mjs";
 //#region src/commands/parse-enum.ts
 function parseEnumFlag(value, schema, name) {
 	const result = schema.safeParse(value);

package/dist/parse-id-7ja3HUdB.mjs

@@ -0,0 +1,13 @@
+import { tt as parseInteger } from "./runtime-B8RtMb4B.mjs";
+//#region src/commands/parse-id.ts
+function parseId(value, name = "id") {
+	return parseInteger(value, {
+		name,
+		min: 1
+	});
+}
+function parseIdCsv(raw, name) {
+	return raw.split(",").map((part) => parseId(part, name));
+}
+//#endregion
+export { parseIdCsv as n, parseId as t };

package/dist/{parse-ref-DTDld_LJ.mjs → parse-ref-Cw5fa4FI.mjs}

@@ -1,4 +1,4 @@
-import { Q as ConfigError } from "./cli.mjs";
+import { at as ConfigError } from "./cli.mjs";
 //#region src/commands/collection/parse-ref.ts
 const SPECIAL_TOKENS = /* @__PURE__ */ new Set(["root", "trash"]);
 const POSITIVE_INTEGER_PATTERN = /^[1-9]\d*$/;

package/dist/parse-text-T0lTXzTZ.mjs

@@ -0,0 +1,11 @@
+import { S as isBlank, at as ConfigError } from "./cli.mjs";
+//#region src/commands/parse-text.ts
+function parseText(value, name) {
+	if (isBlank(value)) throw new ConfigError(`invalid ${name}: must not be blank`);
+	return value;
+}
+function parseOptionalText(value, name) {
+	return value === void 0 ? void 0 : parseText(value, name);
+}
+//#endregion
+export { parseText as n, parseOptionalText as t };

package/dist/{path-_GHFrTLx.mjs → path-DM4vyihl.mjs}

@@ -1,7 +1,7 @@
-import { B as listFlags, G as listEnvelopeSchema, H as outputFlags, d as renderList } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { n as windowList } from "./window-DSb1tqSe.mjs";
-import { i as loadVisibleSkills, n as findSkillByName, r as loadAllSkills } from "./skills-DE9ej5Rg.mjs";
+import { G as listFlags, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { n as windowList } from "./window-CI_QD04s.mjs";
+import { i as loadVisibleSkills, n as findSkillByName, r as loadAllSkills } from "./skills-4qDjKRSk.mjs";
 import { z } from "zod";
 //#region src/commands/skills/path.ts
 const SkillPath = z.object({

package/dist/{poll-KLl4Eq8Y.mjs → poll-Dz4tUm2f.mjs}

@@ -1,5 +1,5 @@
-import { it as TimeoutError } from "./cli.mjs";
-import { n as throwIfAborted, t as combineAborts } from "./signal-Csom0mt5.mjs";
+import { ut as TimeoutError } from "./cli.mjs";
+import { n as throwIfAborted, t as combineAborts } from "./signal-CxWeLszu.mjs";
 import { setTimeout } from "node:timers/promises";
 //#region ../client/src/poll.ts
 const DEFAULT_INTERVAL_MS = 2e3;

package/dist/{preflight-BpYtF0IU.mjs → preflight-DaZ2z2C1.mjs}

@@ -1,6 +1,6 @@
-import { Q as ConfigError, m as writeJson, tt as MetabaseError } from "./cli.mjs";
-import { R as chainRequestFailure } from "./runtime-Dtb93zKy.mjs";
-import "./validate-D6-Vg_kn.mjs";
+import { at as ConfigError, h as writeJson, st as MetabaseError } from "./cli.mjs";
+import { F as chainRequestFailure } from "./runtime-B8RtMb4B.mjs";
+import "./validate-D7e110oU.mjs";
 //#region src/commands/dashboard/preflight.ts
 async function preflightDashcardCardReferences(client, dashcards) {
 	const issues = await client.dashboard.checkCardReferences(dashcards);

package/dist/{process-CLtOWKBn.mjs → process-D0HdqZ3r.mjs}

@@ -1,4 +1,4 @@
-import { ct as isFileNotFoundError } from "./cli.mjs";
+import { ht as isFileNotFoundError } from "./cli.mjs";
 import { spawn } from "node:child_process";
 //#region src/runtime/process.ts
 var ProcessNotFoundError = class extends Error {

package/dist/{publish-D-7Zlmuk.mjs → publish-C0HCL04a.mjs}

@@ -1,7 +1,7 @@
-import { E as warn, H as outputFlags, U as profileFlag, p as renderSummary, st as errorMessage, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { a as CollectionCompact, r as Collection } from "./collection-BxdPxD38.mjs";
-import { n as tableSelectorFlags, t as parseTableSelectors } from "./selectors-C-vgMcGK.mjs";
+import { H as connectionFlags, J as profileFlag, k as warn, p as renderSummary, pt as errorMessage, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { a as CollectionCompact, r as Collection } from "./collection-D3KXhvnc.mjs";
+import { i as tableSelectorFlags, n as parseTableSelectors } from "./table-selector-flags-BVZvnhUa.mjs";
 import { z } from "zod";
 //#region src/commands/git-sync/sync-scope.ts
 function isOutsideSyncScope(collection) {

package/dist/{pulse-x0gFxWfG.mjs → pulse-D1uh8UIU.mjs}

@@ -1,4 +1,4 @@
-import { g as MALFORMED_CELL } from "./cli.mjs";
+import { _ as MALFORMED_CELL } from "./cli.mjs";
 import { n as PulseChannel, r as PulseCompact } from "./pulse-Dz0ocv0l.mjs";
 import { z } from "zod";
 //#region src/output/views/pulse.ts

package/dist/{query-B1CZztxs.mjs → query-BC-C6efK.mjs}

@@ -1,9 +1,9 @@
-import { H as outputFlags, Q as ConfigError, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { V as parseJson, it as parseOptionalInteger, t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
-import { a as CardQueryResult, u as ExportFormat } from "./card-voh1k4hl.mjs";
-import { t as cardQueryView } from "./card-CEkp1mcI.mjs";
-import { t as formatQueryResult } from "./query-result-E4Q-Gra6.mjs";
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { R as parseJson, nt as parseOptionalInteger, t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { a as CardQueryResult } from "./card-P5mBknsl.mjs";
+import { t as cardQueryView } from "./card-CQNUT9pm.mjs";
+import { i as formatQueryResult, n as exportFlags, r as readExportRequest, t as assertStreamedOutput } from "./export-flags-BETJHNcw.mjs";
 import { t as pipeToStdout } from "./stream-McixcoUl.mjs";
 import { z } from "zod";
 //#region src/commands/card/query.ts
@@ -23,27 +23,14 @@ var query_default = defineMetabaseCommand({
 			description: "Card id",
 			required: true
 		},
-		"export-format": {
-			type: "string",
-			description: `Bypass JSON envelope and stream raw export: ${ExportFormat.options.join(" | ")}`
-		},
+		...exportFlags,
 		parameters: {
 			type: "string",
 			description: "JSON array of Metabase parameter objects to pass with the query"
 		},
 		limit: {
 			type: "string",
-			description: "Cap rows kept in the JSON envelope (no effect on streamed exports)"
-		},
-		"format-rows": {
-			type: "boolean",
-			description: "Streamed exports only: apply visualization-settings formatting to values (default false)",
-			default: false
-		},
-		"pivot-results": {
-			type: "boolean",
-			description: "Streamed exports only: emit the pivoted output for pivot questions (default false)",
-			default: false
+			description: "Cap rows kept in the JSON envelope; refused with --export-format"
 		}
 	},
 	outputSchema: CardQueryResult,
@@ -56,17 +43,16 @@ var query_default = defineMetabaseCommand({
 	async run({ args, ctx, getClient }) {
 		const id = parseId(args.id);
 		const parameters = parseParameters(args.parameters);
-		const client = await getClient();
-		const exportFormatRaw = args["export-format"];
-		if (exportFormatRaw !== void 0 && exportFormatRaw !== "") {
-			await pipeToStdout(await client.card.exportQuery(id, parseExportFormat(exportFormatRaw), {
+		const exportRequest = readExportRequest(args);
+		if (exportRequest !== null) {
+			assertStreamedOutput(ctx);
+			await pipeToStdout(await (await getClient()).card.exportQuery(id, exportRequest.format, {
 				parameters,
-				format_rows: args["format-rows"],
-				pivot_results: args["pivot-results"]
+				...exportRequest.params
 			}));
 			return;
 		}
-		const limited = applyLimit(await client.card.query(id, { parameters }), parseOptionalInteger(args.limit, {
+		const limited = applyLimit(await (await getClient()).card.query(id, { parameters }), parseOptionalInteger(args.limit, {
 			name: "--limit",
 			min: 1
 		}));
@@ -77,11 +63,6 @@ function parseParameters(raw) {
 	if (raw === void 0 || raw === "") return [];
 	return parseJson(raw, QueryParameters, { source: "--parameters" });
 }
-function parseExportFormat(raw) {
-	const result = ExportFormat.safeParse(raw);
-	if (!result.success) throw new ConfigError(`invalid --export-format: "${raw}" (expected: ${ExportFormat.options.join(", ")})`);
-	return result.data;
-}
 function applyLimit(result, limit) {
 	if (limit === null || result.data === void 0 || result.data.rows.length <= limit) return result;
 	return {

package/dist/query-BKtMP5eH.mjs

@@ -0,0 +1,13 @@
+import { z } from "zod";
+//#region ../client/src/domain/query.ts
+const DatasetQuery = z.object({}).loose().refine((value) => "lib/type" in value || "type" in value, { message: "dataset_query must include \"lib/type\" (MBQL 5) or \"type\" (legacy MBQL/native); empty `{}` is rejected" }).describe("MBQL 5, legacy MBQL, or native query");
+const ExportFormat = z.enum([
+	"csv",
+	"json",
+	"xlsx"
+]);
+const PivotExportFormat = ExportFormat.exclude(["json"]);
+const VisualizationSettings = z.record(z.string(), z.unknown());
+const SortDirection = z.enum(["asc", "desc"]);
+//#endregion
+export { VisualizationSettings as a, SortDirection as i, ExportFormat as n, PivotExportFormat as r, DatasetQuery as t };

package/dist/query-CAFPlqfi.mjs

@@ -0,0 +1,329 @@
+import { H as connectionFlags, J as profileFlag, _ as MALFORMED_CELL, at as ConfigError, h as writeJson, m as serializeJson, p as renderSummary, q as outputFlags, u as renderItem } from "./cli.mjs";
+import { F as chainRequestFailure, P as HttpError, R as parseJson, t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as readBody } from "./body-CB2eDFFb.mjs";
+import { t as bodyInputFlags } from "./body-flags-AqKpN01Y.mjs";
+import { t as Field } from "./field-5nivEfd6.mjs";
+import { a as VisualizationSettings, t as DatasetQuery } from "./query-BKtMP5eH.mjs";
+import { a as CardQueryResult } from "./card-P5mBknsl.mjs";
+import { p as TableQueryMetadata } from "./table-Ci6bhZkb.mjs";
+import { t as Database } from "./database-BT7DVgSr.mjs";
+import { t as Snippet } from "./snippet-CyKAgIZl.mjs";
+import { a as VirtualTable, i as QueryMetadataCompact, n as CompiledQueryCompact, r as QueryMetadata, t as CompiledQuery } from "./dataset-BmvCxGoE.mjs";
+import { t as cardQueryView } from "./card-CQNUT9pm.mjs";
+import { a as validateQuery, i as isMbql5Query, n as assertNotLegacyEnvelopeWrappingMbql5, r as getQuerySchemaBundle, t as ValidationOutcome } from "./validate-D7e110oU.mjs";
+import { s as skipValidateFlag } from "./validate-query-BzbZmenf.mjs";
+import { i as formatQueryResult, n as exportFlags, r as readExportRequest, t as assertStreamedOutput } from "./export-flags-BETJHNcw.mjs";
+import { t as pipeToStdout } from "./stream-McixcoUl.mjs";
+import { z } from "zod";
+//#region src/output/views/dataset.ts
+const DatabaseNames = z.array(Database.pick({ name: true }));
+const TableNames = z.array(z.union([TableQueryMetadata.pick({ display_name: true }), VirtualTable.pick({ display_name: true })]));
+const FieldNames = z.array(Field.pick({ display_name: true }));
+const SnippetNames = z.array(Snippet.pick({ name: true }));
+function joinLabels(schema, label) {
+	return (value) => {
+		const parsed = schema.safeParse(value);
+		return parsed.success ? parsed.data.map(label).join(", ") : MALFORMED_CELL;
+	};
+}
+const compiledQueryView = {
+	compactPick: CompiledQueryCompact,
+	tableColumns: [
+		{
+			key: "query",
+			label: "Query"
+		},
+		{
+			key: "params",
+			label: "Params"
+		},
+		{
+			key: "collection",
+			label: "Collection"
+		}
+	]
+};
+const queryMetadataView = {
+	compactPick: QueryMetadataCompact,
+	tableColumns: [
+		{
+			key: "databases",
+			label: "Databases",
+			format: joinLabels(DatabaseNames, (database) => database.name)
+		},
+		{
+			key: "tables",
+			label: "Tables",
+			format: joinLabels(TableNames, (table) => table.display_name)
+		},
+		{
+			key: "fields",
+			label: "Fields",
+			format: joinLabels(FieldNames, (field) => field.display_name)
+		},
+		{
+			key: "snippets",
+			label: "Snippets",
+			format: joinLabels(SnippetNames, (snippet) => snippet.name)
+		}
+	]
+};
+//#endregion
+//#region src/commands/query-mode.ts
+const queryModeFlags = {
+	"dry-run": {
+		type: "boolean",
+		description: "Check the body and compile it on the server to native SQL without running it; prints {ok, errors, sql}"
+	},
+	compile: {
+		type: "boolean",
+		description: "Print the native query the server compiles the body to, instead of running it"
+	},
+	metadata: {
+		type: "boolean",
+		description: "Print the databases, tables, fields and snippets the body references, instead of running it"
+	},
+	pretty: {
+		type: "boolean",
+		description: "With --compile: format the native query for reading, as the server does by default; --no-pretty compiles to one line"
+	},
+	...exportFlags,
+	"visualization-settings": {
+		type: "string",
+		description: "With --export-format: JSON object of visualization settings; column settings shape --format-rows, pivot_table.column_split the --pivot-results layout"
+	},
+	"print-schema": {
+		type: "boolean",
+		description: "Emit the bundled MBQL 5 query JSON Schema and exit; no body required"
+	}
+};
+const COLUMN_SPLIT_KEY = "pivot_table.column_split";
+const PIVOT_NEEDS_SPLIT = `--pivot-results requires --visualization-settings with ${COLUMN_SPLIT_KEY}`;
+function resolveQueryMode(args) {
+	const exportRequest = readExportRequest(args);
+	const visualizationSettings = readVisualizationSettings(args, exportRequest);
+	const selected = [];
+	if (args["print-schema"] === true) selected.push({
+		flag: "--print-schema",
+		mode: { kind: "print-schema" }
+	});
+	if (args["dry-run"] === true) selected.push({
+		flag: "--dry-run",
+		mode: { kind: "dry-run" }
+	});
+	if (args.compile === true) selected.push({
+		flag: "--compile",
+		mode: {
+			kind: "compile",
+			pretty: args.pretty
+		}
+	});
+	if (args.metadata === true) selected.push({
+		flag: "--metadata",
+		mode: { kind: "metadata" }
+	});
+	if (exportRequest !== null) {
+		const params = {
+			...exportRequest.params,
+			visualization_settings: visualizationSettings
+		};
+		selected.push({
+			flag: "--export-format",
+			mode: {
+				kind: "export",
+				format: exportRequest.format,
+				params
+			}
+		});
+	}
+	const [first, ...rest] = selected;
+	if (first === void 0) {
+		assertPrettyLeftAlone(args, { kind: "run" });
+		return { kind: "run" };
+	}
+	if (rest.length > 0) {
+		const others = rest.map((entry) => entry.flag).join(", ");
+		throw new ConfigError(`${first.flag} cannot be combined with ${others}`);
+	}
+	assertPrettyLeftAlone(args, first.mode);
+	return first.mode;
+}
+function assertPrettyLeftAlone(args, mode) {
+	if (args.pretty === void 0 || mode.kind === "compile") return;
+	throw new ConfigError(`${args.pretty ? "--pretty" : "--no-pretty"} requires --compile`);
+}
+function readVisualizationSettings(args, exportRequest) {
+	const raw = args["visualization-settings"];
+	const given = raw !== void 0 && raw !== "";
+	if (exportRequest === null) {
+		if (given) throw new ConfigError("--visualization-settings requires --export-format");
+		return;
+	}
+	if (!given) {
+		if (exportRequest.params.pivot_results) throw new ConfigError(PIVOT_NEEDS_SPLIT);
+		return;
+	}
+	const settings = parseJson(raw, VisualizationSettings, { source: "--visualization-settings" });
+	if (exportRequest.params.pivot_results && !hasColumnSplit(settings)) throw new ConfigError(PIVOT_NEEDS_SPLIT);
+	return settings;
+}
+function hasColumnSplit(settings) {
+	const split = settings[COLUMN_SPLIT_KEY];
+	return typeof split === "object" && split !== null;
+}
+//#endregion
+//#region src/commands/query.ts
+const QueryBody = z.unknown().describe("The query body: {\"lib/type\": \"mbql/query\", database, stages}; full schema: mb query --print-schema");
+const QueryDryRunOutcome = ValidationOutcome.extend({ sql: z.string().nullable().describe("The compiled native query; null when it did not compile") });
+const QueryOutput = z.union([
+	CardQueryResult,
+	QueryDryRunOutcome,
+	CompiledQuery,
+	QueryMetadata
+]);
+const COMPILE_REJECTION_STATUSES = /* @__PURE__ */ new Set([400, 500]);
+const FORBIDDEN_STATUS = 403;
+const WHOLE_QUERY_POINTER = "";
+const VALIDATION_HINT = " — fix them, or pass --skip-validate to send anyway";
+var query_default = defineMetabaseCommand({
+	meta: {
+		name: "query",
+		description: "Run, compile, or inspect an ad-hoc MBQL or native query"
+	},
+	details: "Reads a JSON query body from --body, --file, or stdin and runs it. MBQL 5 is Metabase's structured query format, shaped {\"lib/type\": \"mbql/query\", \"database\": <database id>, \"stages\": [{\"lib/type\": \"mbql.stage/mbql\", \"source-table\": <table id>, \"aggregation\": [[\"count\", {}]]}]} with ids from `mb database list` and `mb table list`; it is checked against a bundled JSON Schema before sending, and --print-schema prints that schema. --dry-run checks the body without running it: the local schema check, then the server compiles it to native SQL without touching the warehouse. It prints {ok, errors:[{path, message}], sql} and exits 0 when the query compiled, 2 when either check rejected it. Legacy MBQL 4 and legacy native bodies skip the local check. --compile prints the native query the server compiles the body to, --metadata the databases, tables, fields and snippets the body touches, and --export-format streams the rows as csv, json or xlsx; the three are mutually exclusive with each other, with --dry-run and with --print-schema. An export takes its column formatting and pivot layout from --visualization-settings, since an ad-hoc query has no card to read them from: --pivot-results needs their pivot_table.column_split.",
+	skills: [{
+		skill: "mbql",
+		purpose: "body shape, clause rules, and the dry-run loop"
+	}],
+	requires: [
+		"dataset.exportQuery",
+		"dataset.native",
+		"dataset.query",
+		"dataset.queryMetadata"
+	],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		...queryModeFlags,
+		...skipValidateFlag
+	},
+	inputSchema: QueryBody,
+	outputSchema: QueryOutput,
+	examples: [
+		"mb query --print-schema",
+		"cat q.json | mb query --dry-run",
+		"mb query --file q.json",
+		"mb query --file q.json --compile",
+		"mb query --file q.json --metadata --json",
+		"mb query --file q.json --export-format csv > rows.csv",
+		"mb query --file q.json --skip-validate"
+	],
+	async run({ args, ctx, getClient }) {
+		const mode = resolveQueryMode(args);
+		if (mode.kind === "print-schema") {
+			writeJson(getQuerySchemaBundle());
+			return;
+		}
+		const skip = args["skip-validate"] === true;
+		if (mode.kind === "dry-run" && skip) throw new ConfigError("--skip-validate cannot be combined with --dry-run");
+		if (mode.kind === "export") assertStreamedOutput(ctx);
+		const sources = {
+			flag: args.body,
+			file: args.file
+		};
+		if (mode.kind === "dry-run") {
+			const query = await readQuery(sources, {
+				skip: false,
+				dryRun: true
+			});
+			const outcome = await (await getClient()).dataset.native(query).then(compiledOutcome, rejectedOutcome);
+			writeJson(outcome);
+			if (!outcome.ok) throw new ConfigError(`server validation failed: ${outcome.errors.length} error(s)`);
+			return;
+		}
+		const datasetQuery = await readQuery(sources, {
+			skip,
+			dryRun: false
+		});
+		const client = await getClient();
+		if (mode.kind === "run") {
+			const queryResult = await client.dataset.query(datasetQuery);
+			renderSummary(queryResult, cardQueryView, () => formatQueryResult(queryResult), ctx);
+			return;
+		}
+		switch (mode.kind) {
+			case "compile": {
+				const compiled = await client.dataset.native(datasetQuery, { pretty: mode.pretty }).catch(refusedCompile);
+				renderSummary(compiled, compiledQueryView, () => formatCompiledQuery(compiled), ctx);
+				return;
+			}
+			case "metadata":
+				renderItem(await client.dataset.queryMetadata(datasetQuery), queryMetadataView, ctx);
+				return;
+			case "export":
+				await pipeToStdout(await client.dataset.exportQuery(mode.format, {
+					query: datasetQuery,
+					...mode.params
+				}));
+				return;
+		}
+	}
+});
+function notCompiled(local) {
+	return {
+		...local,
+		sql: null
+	};
+}
+function compiledOutcome(compiled) {
+	return {
+		ok: true,
+		errors: [],
+		sql: formatCompiledQuery(compiled)
+	};
+}
+function rejectedOutcome(error) {
+	if (!(error instanceof HttpError)) throw error;
+	if (error.status === FORBIDDEN_STATUS) throw compilePermissionFailure(error);
+	if (!COMPILE_REJECTION_STATUSES.has(error.status)) throw error;
+	return {
+		ok: false,
+		errors: [{
+			path: WHOLE_QUERY_POINTER,
+			message: error.message
+		}],
+		sql: null
+	};
+}
+function refusedCompile(error) {
+	if (error instanceof HttpError && error.status === FORBIDDEN_STATUS) throw compilePermissionFailure(error);
+	throw error;
+}
+function compilePermissionFailure(error) {
+	return chainRequestFailure(error, `the server refused to compile the query; compiling needs native query permission on its database and access to every table and card it reads: ${error.message}`);
+}
+async function readQuery(sources, options) {
+	const body = await readBody(sources, QueryBody);
+	preflightQuery(body, options);
+	return DatasetQuery.parse(body);
+}
+function preflightQuery(body, options) {
+	if (options.skip) return;
+	assertNotLegacyEnvelopeWrappingMbql5(body, {
+		contextLabel: "query",
+		bodyNoun: "the body"
+	});
+	if (!isMbql5Query(body)) return;
+	const outcome = validateQuery(body);
+	if (outcome.ok) return;
+	writeJson(options.dryRun ? notCompiled(outcome) : outcome);
+	const hint = options.dryRun ? "" : VALIDATION_HINT;
+	throw new ConfigError(`validation failed: ${outcome.errors.length} error(s)${hint}`);
+}
+function formatCompiledQuery(compiled) {
+	return typeof compiled.query === "string" ? compiled.query : serializeJson(compiled.query, false);
+}
+//#endregion
+export { query_default as default };

package/dist/remapping-CgA6UJGU.mjs

@@ -0,0 +1,53 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags, v as formatScalar } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { n as parseText } from "./parse-text-T0lTXzTZ.mjs";
+import { i as fieldRemappingMissView, r as fieldRemappingMatchView, t as FieldRemappingResult, u as toValueLabel } from "./field-wmN6raOG.mjs";
+//#region src/commands/field/remapping.ts
+var remapping_default = defineMetabaseCommand({
+	meta: {
+		name: "remapping",
+		description: "Look up another field's value on the row where a field equals a value"
+	},
+	details: "Answers `{ found: true, value, label }` with `label` the value of `<remapped-id>` on the one row where `<id>` equals `<value>`, or `{ found: false }` when no row does. A FK `<id>` is followed to the key it points at, and `<remapped-id>` must be on that key's table: the server answers a pair that is not, and any failure of the warehouse query, as `{ found: false }` rather than an error. When `<id>` is numeric the server reads the leading number of `<value>` and ignores any text after it (`20abc` looks up 20), failing only a value with no leading number; a value starting with `-` goes after `--` (`mb field remapping 100 101 -- -5`). In text mode the label prints bare so the result composes in a shell; an empty line means either no row matched or the matched label is empty, which `--json` tells apart.",
+	requires: ["field.remapping"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Field id the value belongs to",
+			required: true
+		},
+		"remapped-id": {
+			type: "positional",
+			description: "Field id whose value on that row is answered",
+			required: true
+		},
+		value: {
+			type: "positional",
+			description: "Value of <id> to look up",
+			required: true
+		}
+	},
+	outputSchema: FieldRemappingResult,
+	examples: ["mb field remapping 100 101 20", "mb field remapping 100 101 20 --json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const remappedId = parseId(args["remapped-id"], "remapped-id");
+		const value = parseText(args.value, "value");
+		const pair = await (await getClient()).field.remapping(id, remappedId, { value });
+		if (pair === null) {
+			renderSummary({ found: false }, fieldRemappingMissView, "", ctx);
+			return;
+		}
+		const match = {
+			found: true,
+			...toValueLabel(pair)
+		};
+		renderSummary(match, fieldRemappingMatchView, formatScalar(match.label), ctx);
+	}
+});
+//#endregion
+export { remapping_default as default };

package/dist/{remove-collection-C4saCFxz.mjs → remove-collection-DoctJa9g.mjs}

@@ -1,8 +1,8 @@
-import { H as outputFlags, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
-import { c as SyncSettingsUpdateResult } from "./git-sync-BwBRmEhE.mjs";
-import { o as syncSettingsUpdateView } from "./git-sync-TjX1r_wF.mjs";
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { l as SyncSettingsUpdateResult } from "./git-sync-COokpYgc.mjs";
+import { c as syncSettingsUpdateView } from "./git-sync-DspFahwV.mjs";
 //#region src/commands/git-sync/remove-collection.ts
 var remove_collection_default = defineMetabaseCommand({
 	meta: {

package/dist/{render-6O_eF-P1.mjs → render-Bvm9mta6.mjs}

@@ -1,5 +1,5 @@
-import { lt as KNOWN_RANGE } from "./cli.mjs";
-import { Q as Skew } from "./runtime-Dtb93zKy.mjs";
+import { gt as KNOWN_RANGE } from "./cli.mjs";
+import { Y as Skew } from "./runtime-B8RtMb4B.mjs";
 //#region src/commands/auth/render.ts
 const SKEW_LABEL = Object.freeze({
 	supported: "supported",

package/dist/{replace-BuR4f2Ai.mjs → replace-CaFJd9fO.mjs}

@@ -1,8 +1,8 @@
-import { H as outputFlags, U as profileFlag, p as renderSummary, z as connectionFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dtb93zKy.mjs";
-import { t as parseId } from "./parse-id-DtM6q9HU.mjs";
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
 import { n as UploadUpdateResult } from "./upload-DAtxBBms.mjs";
-import { n as requireUploadFilePath, t as readCsvFile } from "./upload-DOO94rCQ.mjs";
+import { n as requireUploadFilePath, t as readCsvFile } from "./upload-C2fhpKkP.mjs";
 import { n as uploadUpdateResultView } from "./upload-C3z5ZaXA.mjs";
 //#region src/commands/upload/replace.ts
 var replace_default = defineMetabaseCommand({

package/dist/rescan-values-7VOGCLMe.mjs

@@ -0,0 +1,32 @@
+import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-B8RtMb4B.mjs";
+import { t as parseId } from "./parse-id-7ja3HUdB.mjs";
+import { l as TableFieldValuesResult } from "./table-Ci6bhZkb.mjs";
+import { i as tableFieldValuesResultView } from "./table-CxvaDiIZ.mjs";
+//#region src/commands/table/rescan-values.ts
+var rescan_values_default = defineMetabaseCommand({
+	meta: {
+		name: "rescan-values",
+		description: "Trigger a rescan of cached field values for one table"
+	},
+	details: "Queues an async rescan of the distinct values behind this table's filter dropdowns and returns immediately with the server's `success` acknowledgement. Only the sets already cached and read in the last 14 days are refreshed; a set never read, discarded, or unread for longer is skipped until a read rebuilds or revives it. To rescan a set of tables use `mb table bulk-rescan-values`.",
+	requires: ["table.rescanValues"],
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Table id",
+			required: true
+		}
+	},
+	outputSchema: TableFieldValuesResult,
+	examples: ["mb table rescan-values 42", "mb table rescan-values 42 --json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		renderSummary(await (await getClient()).table.rescanValues(id), tableFieldValuesResultView, `Field-values rescan queued for table ${id}.`, ctx);
+	}
+});
+//#endregion
+export { rescan_values_default as default };