@metabase/cli 0.5.8 → 0.5.9

package/dist/{run-C_IZfmQ7.mjs → run-Ch9KAm3W.mjs}

@@ -1,9 +1,9 @@
 import { c as InternalError, f as ResponseShapeError, h as ValidationError, i as AbortError, o as ConfigError, p as TimeoutError, r as isPlainObject, s as FailedResultError, u as NetworkError } from "./predicates-0C0TsWcJ.mjs";
-import { I as CapabilityError, Y as isHttpNotFound, f as serializeJson, ft as profileFlag, o as jsonLineWriter, ot as connectionFlags, q as HttpError, t as interruptSignal } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-Dd2uBKqN.mjs";
-import { o as isTransformTestCode } from "./transform-test-D6QIyu8C.mjs";
+import { R as CapabilityError, Y as HttpError, Z as isHttpNotFound, a as exitCodeFor, c as lineWriter, ct as connectionFlags, lt as formatFlags, m as serializeJson, mt as profileFlag, s as jsonLineWriter, t as interruptSignal, vt as parseInteger } from "./cli.mjs";
+import { i as NotAuthenticatedError, t as defineMetabaseCommand } from "./runtime-fJ-A3m-R.mjs";
+import { i as TransformTestRunResult, o as isTransformTestCode } from "./transform-test-D6QIyu8C.mjs";
 import { a as runProcess, n as ProcessNotFoundError, o as runProcessBinary, r as ProcessTimeoutError, t as ProcessInterruptedError } from "./process-ByKCTa6A.mjs";
-import { t as parseMetabaseYaml } from "./yaml-BthVUNj3.mjs";
+import { t as parseMetabaseYaml } from "./yaml-Ctv1l2-P.mjs";
 import { z } from "zod";
 import { rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
@@ -15,33 +15,53 @@ function byName(a, b) {
 	return a.name.localeCompare(b.name);
 }
 function assessCoverage(inputs) {
+	const untested = (entityId, name, change) => {
+		return {
+			entityId,
+			name,
+			change,
+			tests: inputs.testedWithoutExpectationsAtHead.has(entityId) ? "no-expectations" : "none"
+		};
+	};
 	const logicAtBase = /* @__PURE__ */ new Map();
 	for (const { base } of inputs.changes) if (base?.kind === "transform") logicAtBase.set(base.entityId, base.logic);
 	const changed = /* @__PURE__ */ new Map();
 	for (const { head } of inputs.changes) {
 		if (head?.kind !== "transform" || inputs.testedAtHead.has(head.entityId)) continue;
 		const before = logicAtBase.get(head.entityId);
-		if (before === void 0) changed.set(head.entityId, {
-			entityId: head.entityId,
-			name: head.name,
-			change: "new"
-		});
-		else if (!isDeepStrictEqual(before, head.logic)) changed.set(head.entityId, {
-			entityId: head.entityId,
-			name: head.name,
-			change: "edited"
-		});
+		if (before === void 0) changed.set(head.entityId, untested(head.entityId, head.name, "new"));
+		else if (!isDeepStrictEqual(before, head.logic)) changed.set(head.entityId, untested(head.entityId, head.name, "edited"));
+	}
+	for (const { base } of inputs.changes) {
+		if (base?.kind !== "transform-test" || !base.hasExpectations || inputs.testedAtHead.has(base.transformId)) continue;
+		const name = inputs.transformsAtHead.get(base.transformId);
+		if (name !== void 0) changed.set(base.transformId, untested(base.transformId, name, "lost-test"));
 	}
+	const untestedChanges = [];
+	const untestableChanges = [];
+	for (const transform of changed.values()) if (inputs.untestableAtHead.has(transform.entityId)) untestableChanges.push({
+		entityId: transform.entityId,
+		name: transform.name
+	});
+	else untestedChanges.push(transform);
 	const untouchedUntested = [];
 	for (const [entityId, name] of inputs.transformsAtHead) if (!inputs.testedAtHead.has(entityId) && !changed.has(entityId)) untouchedUntested.push({
 		entityId,
 		name
 	});
 	return {
-		untestedChanges: [...changed.values()].toSorted(byName),
+		untestedChanges: untestedChanges.toSorted(byName),
+		untestableChanges: untestableChanges.toSorted(byName),
 		untouchedUntested: untouchedUntested.toSorted(byName)
 	};
 }
+function untestedTransforms(assessment) {
+	return new Set([
+		...assessment.untestedChanges,
+		...assessment.untestableChanges,
+		...assessment.untouchedUntested
+	].map((transform) => transform.entityId));
+}
 const UNTOUCHED_CHECK_ID = "untouched";
 function untouchedWarnings(untouched) {
 	if (untouched.length === 0) return [];
@@ -50,6 +70,22 @@ function untouchedWarnings(untouched) {
 		message: `${untouched.length === 1 ? "1 transform whose logic this change did not touch has" : `${untouched.length} transforms whose logic this change did not touch have`} no tests: ${untouched.map((transform) => transform.name).join(", ")}`
 	}];
 }
+const UNTESTABLE_CHECK_ID = "untestable";
+function untestableWarning(untestable) {
+	return {
+		code: "untestable-transform",
+		message: `${untestable.map((transform) => transform.name).join(", ")} cannot have transform tests (Python transforms), so coverage does not require one`
+	};
+}
+function untestedMessage(transform) {
+	const withoutExpectations = transform.tests === "no-expectations";
+	if (transform.change === "lost-test") {
+		const lost = withoutExpectations ? "transform test with expectations" : "transform test";
+		return `${transform.name} lost its last ${lost} in this change`;
+	}
+	const gap = withoutExpectations ? "none of its transform tests has expectations" : "has no transform tests";
+	return `${transform.name} is ${transform.change} in this change and ${gap}`;
+}
 function coverageStage(assessment) {
 	return {
 		name: "lint",
@@ -65,9 +101,24 @@ function coverageStage(assessment) {
 				ms: 0,
 				detail: {
 					change: transform.change,
-					message: `${transform.name} is ${transform.change} in this change and has no transform tests`
+					message: untestedMessage(transform)
 				}
 			});
+			const untestable = assessment.untestableChanges;
+			if (untestable.length > 0) report({
+				check: {
+					kind: "coverage",
+					id: UNTESTABLE_CHECK_ID,
+					label: "Transforms that cannot have transform tests"
+				},
+				verdict: "passed",
+				warnings: [untestableWarning(untestable)],
+				ms: 0,
+				detail: { untestable: untestable.map((transform) => ({
+					entity_id: transform.entityId,
+					name: transform.name
+				})) }
+			});
 			const untouched = assessment.untouchedUntested;
 			report({
 				check: {
@@ -94,13 +145,11 @@ const Verdict = z.enum([
 	"error",
 	"refused"
 ]);
-const StageStatus = z.enum([
+const JobState = z.enum([
 	"passed",
 	"failed",
-	"errored",
-	"skipped"
+	"errored"
 ]);
-const JobState = StageStatus.exclude(["skipped"]);
 const CiWarning = z.object({
 	code: z.string(),
 	message: z.string()
@@ -156,7 +205,7 @@ const CheckResult = EventEnvelope.extend({
 const StageEnd = EventEnvelope.extend({
 	type: z.literal("stage.end"),
 	stage: StageName,
-	status: StageStatus,
+	status: JobState,
 	stopped: StageStop.nullable()
 });
 const JobEnd = EventEnvelope.extend({
@@ -194,20 +243,15 @@ function stageStatus(verdicts, stopped) {
 	if (stopped !== null || verdicts.includes("refused") || verdicts.includes("error")) return "errored";
 	return "passed";
 }
+function jobState(statuses) {
+	if (statuses.includes("failed")) return "failed";
+	return statuses.includes("errored") ? "errored" : "passed";
+}
 async function runStages(stages, emit) {
-	let state = "passed";
+	const statuses = [];
 	let checks = 0;
 	let warnings = 0;
 	for (const stage of stages) {
-		if (state !== "passed") {
-			emit({
-				type: "stage.end",
-				stage: stage.name,
-				status: "skipped",
-				stopped: null
-			});
-			continue;
-		}
 		emit({
 			type: "stage.start",
 			stage: stage.name
@@ -223,21 +267,158 @@ async function runStages(stages, emit) {
 				...check
 			});
 		});
-		state = stageStatus(verdicts, stopped);
+		const status = stageStatus(verdicts, stopped);
+		statuses.push(status);
 		emit({
 			type: "stage.end",
 			stage: stage.name,
-			status: state,
+			status,
 			stopped
 		});
 	}
 	return {
-		state,
+		state: jobState(statuses),
 		checks,
 		warnings
 	};
 }
 //#endregion
+//#region src/output/ci-run.ts
+const SHORT_SHA_LENGTH = 7;
+const MS_PER_SECOND = 1e3;
+const PASSED_EXIT_CODE = 0;
+const CHECK_INDENT = "  ";
+const DETAIL_INDENT = "      ";
+const ROW_INDENT = "          ";
+const VERDICT_MARK = {
+	passed: "✓",
+	failed: "✗",
+	error: "!",
+	refused: "!"
+};
+const NO_FAILED_CHECKS = "none";
+const FAILED_TEXT = {
+	none: "FAILED  fix the transform",
+	transform: "FAILED  fix the transform",
+	tests: "FAILED  add or restore transform tests",
+	both: "FAILED  fix the transform and add the missing tests"
+};
+const ERRORED_TEXT = "ERRORED  fix the test or the setup";
+const CheckMessage = z.object({ message: z.string() });
+const HttpFailureMessage = CheckMessage.extend({ status: z.number().int() });
+function failedChecksAfter(failed, event) {
+	if (event.type !== "check.result" || event.verdict !== "failed") return failed;
+	const kind = event.check.kind === "coverage" ? "tests" : "transform";
+	if (failed === "none" || failed === kind) return kind;
+	return "both";
+}
+function ciEventLines(event, maxRows, failed) {
+	switch (event.type) {
+		case "job.start": {
+			const count = event.checked.length;
+			const noun = count === 1 ? "transform" : "transforms";
+			return [`mb ci run  base ${shortSha(event.snapshot.base)}  head ${shortSha(event.snapshot.head)}  ${count} ${noun} checked`, ...event.warnings.map((warning) => `⚠ ${warning.message}`)];
+		}
+		case "stage.start": return [event.stage];
+		case "check.result": return checkLines(event, maxRows);
+		case "stage.end": return stageEndLines(event);
+		case "job.end": return [`${jobEndText(event.state, failed)} (exit ${jobExitCode(event.state)})`];
+		default: throw new InternalError(`ci event of no known type: ${JSON.stringify(event)}`);
+	}
+}
+function stageEndLines(event) {
+	if (event.stopped !== null) return [`${event.stage}  stopped: ${event.stopped.message} (${event.stopped.code})`];
+	return [];
+}
+function shortSha(sha) {
+	return sha.slice(0, SHORT_SHA_LENGTH);
+}
+function jobEndText(state, failed) {
+	if (state === "passed") return "PASSED";
+	return state === "failed" ? FAILED_TEXT[failed] : ERRORED_TEXT;
+}
+function jobExitCode(state) {
+	return state === "passed" ? PASSED_EXIT_CODE : exitCodeFor("failed");
+}
+function checkLines(event, maxRows) {
+	const parts = [`${CHECK_INDENT}${VERDICT_MARK[event.verdict]} ${event.check.label}`];
+	if (event.verdict === "error" || event.verdict === "refused") parts.push(event.verdict);
+	if (event.ms > 0) parts.push(duration(event.ms));
+	const warnings = event.warnings.map((warning) => `${DETAIL_INDENT}⚠ ${warning.message}`);
+	const detail = event.verdict === "passed" ? [] : detailLines(event, maxRows);
+	return [
+		parts.join("  "),
+		...warnings,
+		...detail
+	];
+}
+function duration(ms) {
+	if (ms < MS_PER_SECOND) return `${Math.round(ms)}ms`;
+	return `${(ms / MS_PER_SECOND).toFixed(1)}s`;
+}
+function detailLines(event, maxRows) {
+	const result = TransformTestRunResult.safeParse(event.detail);
+	if (result.success) return result.data.expectations.flatMap((expectation) => expectationLines(expectation, maxRows));
+	const httpFailure = HttpFailureMessage.safeParse(event.detail);
+	if (httpFailure.success) return [`${DETAIL_INDENT}${httpFailure.data.message} (HTTP ${httpFailure.data.status})`];
+	const message = CheckMessage.safeParse(event.detail);
+	if (!message.success) throw new InternalError(`ci check "${event.check.label}" has a detail of no known shape: ${message.error.message}`);
+	return [`${DETAIL_INDENT}${message.data.message}`];
+}
+function expectationLines(result, maxRows) {
+	const line = `${DETAIL_INDENT}${VERDICT_MARK[result.status]} ${result.name}`;
+	if (result.status === "passed") return [line];
+	if (result.status === "error") return [`${line}  error: ${result.error.message}`];
+	if (result.type === "empty") {
+		const rows = result.sample.length + result.truncated;
+		const sample = result.sample.map((row) => `row  ${cellsText(row, columnNames(result.columns))}`);
+		return [`${line}  ${rows} ${rowNoun(rows)}, expected none`, ...capped(sample, result.truncated, maxRows)];
+	}
+	const counts = result["row-counts"];
+	const rowLines = rowDiffLines(result["missing-rows"], result["extra-rows"], columnNames(result.columns));
+	const mismatches = result["cell-mismatches"].map((mismatch) => `${mismatch.column}: expected ${cellText(mismatch.expected)}, got ${cellText(mismatch.actual)}`);
+	return [`${line}  ${counts.actual} ${rowNoun(counts.actual)}, expected ${counts.expected}`, ...capped([...rowLines, ...mismatches], result.truncated, maxRows)];
+}
+function rowNoun(count) {
+	return count === 1 ? "row" : "rows";
+}
+function columnNames(columns) {
+	return columns.map((column) => column.name);
+}
+function capped(lines, truncated, maxRows) {
+	const shown = lines.slice(0, maxRows).map((line) => `${ROW_INDENT}${line}`);
+	const hidden = Math.max(lines.length - maxRows, 0) + truncated;
+	if (hidden === 0) return shown;
+	return [...shown, `${ROW_INDENT}+${hidden} more`];
+}
+function rowDiffLines(missing, extra, columns) {
+	const [key, ...rest] = columns;
+	if (key === void 0) return [...missing.map((row) => `missing  ${cellsText(row, Object.keys(row))}`), ...extra.map((row) => `extra    ${cellsText(row, Object.keys(row))}`)];
+	const unpaired = [...extra];
+	const lines = [];
+	for (const row of missing) {
+		const index = unpaired.findIndex((candidate) => candidate[key] === row[key]);
+		const partner = unpaired[index];
+		if (partner === void 0) {
+			lines.push(`missing  ${cellsText(row, columns)}`);
+			continue;
+		}
+		unpaired.splice(index, 1);
+		const differing = rest.filter((column) => row[column] !== partner[column]);
+		lines.push(`missing  ${cellsText(row, [key, ...differing])}`);
+		lines.push(`extra    ${cellsText(partner, [key, ...differing])}`);
+	}
+	for (const row of unpaired) lines.push(`extra    ${cellsText(row, columns)}`);
+	return lines;
+}
+function cellsText(row, columns) {
+	return columns.map((column) => `${column}=${cellText(row[column])}`).join("  ");
+}
+function cellText(value) {
+	if (value === void 0) return "(absent)";
+	return value === null ? "null" : String(value);
+}
+//#endregion
 //#region src/core/ci-affected.ts
 const SINGLE_PATH_STATUSES = /* @__PURE__ */ new Map([
 	["A", "added"],
@@ -326,7 +507,22 @@ const TransformDocument = z.object({
 	source: z.unknown(),
 	target: z.unknown()
 }).loose();
-const TransformTestDocument = z.object({ transform_id: z.string().min(1) }).loose();
+const TransformLogicDocument = TransformDocument.pick({
+	source: true,
+	target: true
+});
+const QUERY_SOURCE_TYPE = "query";
+function isTestableSource(source) {
+	if (!isPlainObject(source)) return true;
+	const type = source["type"];
+	return typeof type !== "string" || type === QUERY_SOURCE_TYPE;
+}
+const TRANSFORM_RULE = "a Transform must have an entity_id, a name, a source and a target";
+const TRANSFORM_TEST_RULE = "a TransformTest must name its transform_id, and its expectations must be a list";
+const TransformTestDocument = z.object({
+	transform_id: z.string().min(1),
+	expectations: z.array(z.unknown()).nullish()
+}).loose();
 const SerdesMeta = z.array(z.object({ model: z.string() }).loose()).min(1);
 function parseOrRefuse(path, schema, value, rule) {
 	const parsed = schema.safeParse(value);
@@ -336,26 +532,41 @@ function parseOrRefuse(path, schema, value, rule) {
 	});
 	return parsed.data;
 }
-function classifyContentFile(path, document) {
+function classifyContentFile(path, yaml) {
+	const document = yaml.yaml12;
 	if (!isPlainObject(document) || !(SERDES_META_KEY in document)) return { kind: "other" };
 	const last = parseOrRefuse(path, SerdesMeta, document[SERDES_META_KEY], `${SERDES_META_KEY} must be a non-empty list of entries with a model`).at(-1);
 	if (last === void 0) throw new InternalError(`${path}: ${SERDES_META_KEY} passed a non-empty check but has no entries`);
 	if (last.model === "Transform") {
-		const transform = parseOrRefuse(path, TransformDocument, document, "a Transform must have an entity_id, a name, a source and a target");
+		const transform = parseOrRefuse(path, TransformDocument, document, TRANSFORM_RULE);
+		const asYaml11 = parseOrRefuse(path, TransformLogicDocument, yaml.yaml11, TRANSFORM_RULE);
 		return {
 			kind: "transform",
 			entityId: transform.entity_id,
 			name: transform.name,
 			logic: {
-				source: transform.source,
-				target: transform.target
-			}
+				yaml12: {
+					source: transform.source,
+					target: transform.target
+				},
+				yaml11: {
+					source: asYaml11.source,
+					target: asYaml11.target
+				}
+			},
+			testable: isTestableSource(transform.source)
+		};
+	}
+	if (last.model === "TransformTest") {
+		const test = parseOrRefuse(path, TransformTestDocument, document, TRANSFORM_TEST_RULE);
+		const expectations = test.expectations;
+		const hasExpectations = expectations !== void 0 && expectations !== null && expectations.length > 0;
+		return {
+			kind: "transform-test",
+			transformId: test.transform_id,
+			hasExpectations
 		};
 	}
-	if (last.model === "TransformTest") return {
-		kind: "transform-test",
-		transformId: parseOrRefuse(path, TransformTestDocument, document, "a TransformTest must name its transform_id").transform_id
-	};
 	return { kind: "other" };
 }
 function transformEntityId(file) {
@@ -381,14 +592,19 @@ function affectedTransforms(changes) {
 	}
 	return [...touched].filter((entityId) => atHead.has(entityId) || !atBase.has(entityId));
 }
-const TRANSFORM_MODEL_PATTERN = `model["']?:[[:space:]]*["']?Transform`;
+const TRANSFORM_MODEL_PATTERN = "Transform";
 function headTransforms(files) {
 	const atHead = {
 		names: /* @__PURE__ */ new Map(),
-		tested: /* @__PURE__ */ new Set()
+		tested: /* @__PURE__ */ new Set(),
+		testedWithoutExpectations: /* @__PURE__ */ new Set(),
+		untestable: /* @__PURE__ */ new Set()
 	};
-	for (const file of files) if (file?.kind === "transform") atHead.names.set(file.entityId, file.name);
-	else if (file?.kind === "transform-test") atHead.tested.add(file.transformId);
+	for (const file of files) if (file?.kind === "transform") {
+		atHead.names.set(file.entityId, file.name);
+		if (!file.testable) atHead.untestable.add(file.entityId);
+	} else if (file?.kind === "transform-test") (file.hasExpectations ? atHead.tested : atHead.testedWithoutExpectations).add(file.transformId);
+	for (const entityId of atHead.tested) atHead.testedWithoutExpectations.delete(entityId);
 	return atHead;
 }
 const CONTENT_TOP_LEVEL_FOLDERS = [
@@ -422,7 +638,7 @@ function noContentChangesWarning(entries) {
 	if (entries.some((entry) => isContentPath(entry.path) || entry.status === "renamed" && isContentPath(entry.oldPath))) return null;
 	return {
 		code: "no-content-changes",
-		message: "the change touches no Metabase content files, so CI checked nothing"
+		message: "the change touches no Metabase content files, so no transform test ran"
 	};
 }
 function uncommittedContentWarning(paths) {
@@ -433,6 +649,13 @@ function uncommittedContentWarning(paths) {
 		message: `${content.length === 1 ? "1 content file has uncommitted changes" : `${content.length} content files have uncommitted changes`}, which CI does not see; it checks the committed version: ${content.join(", ")}`
 	};
 }
+function unreadContentWarning(reasons) {
+	if (reasons.length === 0) return null;
+	return {
+		code: "unread-content",
+		message: `${reasons.length === 1 ? "1 content file this change did not touch could not be read, so the coverage check skipped it" : `${reasons.length} content files this change did not touch could not be read, so the coverage check skipped them`}: ${reasons.join("; ")}`
+	};
+}
 //#endregion
 //#region src/runtime/git.ts
 const GIT = "git";
@@ -598,21 +821,46 @@ async function readFilesAt(repo, commit, paths, signal) {
 //#region src/commands/ci/job-plan.ts
 const CONTENT_PATHSPECS = CONTENT_TOP_LEVEL_FOLDERS.map((folder) => `${folder}/*.yaml`);
 const FILE_MODES = /* @__PURE__ */ new Set(["100644", "100755"]);
-async function classifyAt(repo, commit, paths, signal) {
+function unread(commit, path, message) {
+	return {
+		kind: "unread",
+		error: new ValidationError(message, {
+			source: `${commit}:${path}`,
+			zodIssues: []
+		})
+	};
+}
+async function readAt(repo, commit, paths, signal) {
 	const content = paths.filter(isContentPath);
-	if (content.length === 0) return /* @__PURE__ */ new Map();
+	const readings = /* @__PURE__ */ new Map();
+	if (content.length === 0) return readings;
 	const modes = await fileModesAt(repo, commit, signal);
+	const readable = [];
 	for (const path of content) {
 		const mode = modes.get(path);
 		if (mode === void 0) throw new InternalError(`git listed ${path} at ${commit}, but its tree does not hold it`);
-		if (!FILE_MODES.has(mode)) throw new ValidationError(`${commit}:${path} is not a regular file (git mode ${mode}): Metabase would import what it points to, which this check cannot read; commit the file itself`, {
-			source: `${commit}:${path}`,
-			zodIssues: []
+		if (!FILE_MODES.has(mode)) {
+			const reason = `${commit}:${path} is not a regular file (git mode ${mode}): Metabase would import what it points to, which this check cannot read; commit the file itself`;
+			readings.set(path, unread(commit, path, reason));
+		} else if (path.includes("\n")) {
+			const reason = `${commit}:${JSON.stringify(path)}: a path with a newline cannot be read; rename the file`;
+			readings.set(path, unread(commit, path, reason));
+		} else readable.push(path);
+	}
+	for (const [path, text] of await readFilesAt(repo, commit, readable, signal)) try {
+		const file = classifyContentFile(path, parseMetabaseYaml(text, `${commit}:${path}`));
+		readings.set(path, {
+			kind: "read",
+			file
+		});
+	} catch (error) {
+		if (!(error instanceof ValidationError)) throw error;
+		readings.set(path, {
+			kind: "unread",
+			error
 		});
 	}
-	const classified = /* @__PURE__ */ new Map();
-	for (const [path, text] of await readFilesAt(repo, commit, content, signal)) classified.set(path, classifyContentFile(path, parseMetabaseYaml(text, `${commit}:${path}`)));
-	return classified;
+	return readings;
 }
 function basePath(entry) {
 	if (entry.status === "added") return null;
@@ -624,23 +872,40 @@ function headPath(entry) {
 function present(paths) {
 	return paths.filter((path) => path !== null);
 }
-function sideOf(files, path) {
+function readingOf(readings, path) {
 	if (path === null || !isContentPath(path)) return null;
-	const file = files.get(path);
-	if (file === void 0) throw new InternalError(`${path} was not read, though the diff names it`);
-	return file;
+	const reading = readings.get(path);
+	if (reading === void 0) throw new InternalError(`${path} was not read, though git names it`);
+	return reading;
+}
+function headSide(reading) {
+	if (reading?.kind === "unread") throw reading.error;
+	return reading === null ? null : reading.file;
+}
+function baseSide(reading) {
+	return reading?.kind === "read" ? reading.file : null;
 }
 async function classifyChanges(repo, forkPoint, head, entries, signal) {
-	const [baseFiles, headFiles] = await Promise.all([classifyAt(repo, forkPoint, present(entries.map(basePath)), signal), classifyAt(repo, head, present(entries.map(headPath)), signal)]);
-	return entries.map((entry) => ({
+	const changedPaths = new Set(entries.map((entry) => entry.path));
+	const unchanged = (await filesMatching(repo, head, TRANSFORM_MODEL_PATTERN, CONTENT_PATHSPECS, signal)).filter((path) => !changedPaths.has(path));
+	const [baseReadings, headReadings] = await Promise.all([readAt(repo, forkPoint, present(entries.map(basePath)), signal), readAt(repo, head, [...present(entries.map(headPath)), ...unchanged], signal)]);
+	const changes = entries.map((entry) => ({
 		path: entry.path,
-		base: sideOf(baseFiles, basePath(entry)),
-		head: sideOf(headFiles, headPath(entry))
+		base: baseSide(readingOf(baseReadings, basePath(entry))),
+		head: headSide(readingOf(headReadings, headPath(entry)))
 	}));
-}
-async function scanHead(repo, head, changes, changedPaths, signal) {
-	const unchangedFiles = (await classifyAt(repo, head, (await filesMatching(repo, head, TRANSFORM_MODEL_PATTERN, CONTENT_PATHSPECS, signal)).filter((path) => !changedPaths.has(path)), signal)).values();
-	return headTransforms([...changes.map((change) => change.head), ...unchangedFiles]);
+	const unchangedAtHead = [];
+	const unreadUnchanged = [];
+	for (const path of unchanged) {
+		const reading = readingOf(headReadings, path);
+		if (reading?.kind === "read") unchangedAtHead.push(reading.file);
+		else if (reading?.kind === "unread") unreadUnchanged.push(reading.error);
+	}
+	return {
+		changes,
+		unchangedAtHead,
+		unreadUnchanged
+	};
 }
 async function planJob(repoPath, baseRef, headRef, signal) {
 	const repo = await repositoryRoot(repoPath, signal);
@@ -651,12 +916,11 @@ async function planJob(repoPath, baseRef, headRef, signal) {
 	]);
 	const forkPoint = await mergeBase(repo, base, head, signal);
 	const entries = parseNameStatus(await diffNameStatus(repo, forkPoint, head, signal));
-	const changes = await classifyChanges(repo, forkPoint, head, entries, signal);
-	const atHead = await scanHead(repo, head, changes, new Set(entries.map((entry) => entry.path)), signal);
+	const { changes, unchangedAtHead, unreadUnchanged } = await classifyChanges(repo, forkPoint, head, entries, signal);
+	const atHead = headTransforms([...changes.map((change) => change.head), ...unchangedAtHead]);
 	const checked = [];
 	const warnings = [];
-	const noContent = noContentChangesWarning(entries);
-	if (noContent !== null) warnings.push(noContent);
+	for (const warning of [noContentChangesWarning(entries), unreadContentWarning(unreadUnchanged.map((error) => error.message))]) if (warning !== null) warnings.push(warning);
 	for (const entityId of affectedTransforms(changes)) {
 		const name = atHead.names.get(entityId);
 		if (name === void 0) {
@@ -674,7 +938,9 @@ async function planJob(repoPath, baseRef, headRef, signal) {
 	const coverage = assessCoverage({
 		changes,
 		transformsAtHead: atHead.names,
-		testedAtHead: atHead.tested
+		testedAtHead: atHead.tested,
+		testedWithoutExpectationsAtHead: atHead.testedWithoutExpectations,
+		untestableAtHead: atHead.untestable
 	});
 	if (head === checkout) {
 		const uncommitted = uncommittedContentWarning(parseStatusPorcelain(await statusPorcelain(repo, signal)));
@@ -765,6 +1031,10 @@ const INVALID_ENTITY_ID = {
 	error_code: "ci.invalid-entity-id",
 	message: "the transform's entity_id in the branch is not a valid entity id"
 };
+const NO_TESTS_ON_INSTANCE = {
+	error_code: "ci.no-tests-on-instance",
+	message: "the branch has a test for this transform, but the Metabase instance lists none, so no test ran; load the branch into it first"
+};
 const TRANSFORM_UNREADABLE = {
 	error_code: "ci.transform-unreadable",
 	message: "the CI identity cannot read this transform, so Metabase hides its tests: reading it needs query permission on every table it reads"
@@ -816,6 +1086,13 @@ function lookupStop(error) {
 		message: failure.message
 	};
 }
+function connectStop(error) {
+	if (!(error instanceof NotAuthenticatedError)) return null;
+	return {
+		code: "ci.no-credential",
+		message: `no Metabase credential, so the transform tests did not run: ${error.message}`
+	};
+}
 const REFUSAL_FOR_FORBIDDEN = {
 	read: TRANSFORM_UNREADABLE,
 	list: null,
@@ -921,7 +1198,7 @@ function reportFailure(failure, check, ms, report) {
 	});
 	return null;
 }
-async function checkTransform(transform, transformId, port, report) {
+async function checkTransform(transform, transformId, untestedInBranch, port, report) {
 	const transformCheck = {
 		kind: "transform-test",
 		id: transform.entity_id,
@@ -932,6 +1209,16 @@ async function checkTransform(transform, transformId, port, report) {
 	if (read.kind !== "settled") return reportFailure(read, transformCheck, port.nowMs() - started, report);
 	const tests = await attempt("list", () => port.listTests(transformId));
 	if (tests.kind !== "settled") return reportFailure(tests, transformCheck, port.nowMs() - started, report);
+	if (tests.value.length === 0 && !untestedInBranch) {
+		report({
+			check: transformCheck,
+			verdict: "refused",
+			warnings: [],
+			ms: port.nowMs() - started,
+			detail: NO_TESTS_ON_INSTANCE
+		});
+		return null;
+	}
 	for (const test of tests.value.toSorted((a, b) => a.id - b.id)) {
 		const check = {
 			kind: "transform-test",
@@ -956,11 +1243,18 @@ async function checkTransform(transform, transformId, port, report) {
 	}
 	return null;
 }
-function unitStage(checked, connect) {
+function unitStage(checked, untestedInBranch, connect) {
 	return {
 		name: "unit",
 		run: async (report) => {
-			const port = await connect();
+			let port;
+			try {
+				port = await connect();
+			} catch (error) {
+				const stop = connectStop(error);
+				if (stop === null) throw error;
+				return stop;
+			}
 			let lookups;
 			try {
 				lookups = await port.lookUpTransforms(checked.map((transform) => transform.entity_id));
@@ -986,7 +1280,8 @@ function unitStage(checked, connect) {
 					});
 					continue;
 				}
-				const stop = await checkTransform(transform, lookup.id, port, report);
+				const untested = untestedInBranch.has(transform.entity_id);
+				const stop = await checkTransform(transform, lookup.id, untested, port, report);
 				if (stop !== null) return stop;
 			}
 			return null;
@@ -998,9 +1293,14 @@ function unitStage(checked, connect) {
 var run_default = defineMetabaseCommand({
 	meta: {
 		name: "run",
-		description: "Check the transforms a branch changed, writing one JSON event per line"
+		description: "Check the transforms a branch changed, reporting each check as it finishes"
 	},
-	details: "Compares --head with its merge base with --base and finds the transforms whose files or tests changed. Two stages check them: `lint` fails each transform the branch adds or whose logic (source or target) it edits that has no transform test, and warns about untested transforms the branch did not touch; `unit` runs the changed transforms' tests on the Metabase instance that --url, MB_URL or --profile names, in that order, which must already hold the branch's content, and is skipped when no transform changed. Content files are the `.yaml` files Metabase's import reads: not dotfiles, under a top-level serialization folder such as `transforms/` or `collections/`. Only committed content is checked: when --head is the checked-out commit, a content file with uncommitted changes is listed in an `uncommitted-content` warning, and its committed version is checked. Writes one JSON event per line (`job.start`, then each stage and check, then `job.end`); `job.start.checked` lists the transforms the job covered, and a `no-content-changes` warning says when the change touches no content file, so nothing was checked; each transform test's result is passed through as the check's `detail`. Exits 0 when the job passes. Exits 1 after `job.end` when it does not: `state` is `failed` when a check failed (fix the transform), and `errored` when no check failed but one could not judge the change (fix the test or the setup); a failure outranks errors, since it is a finding about the change. A test run that times out, loses its connection or gets an HTTP error is an `error` check whose `detail.error_code` starts with `ci.`, and the next test runs. A failure every later request would repeat ends the unit stage early, `errored` unless a check failed, with the reason in `stage.end.stopped`: Metabase rejects the credential, the server has no transform testing, the entity-id lookup fails, or Metabase cannot be reached before a test runs. Exits 2 on a usage or config error: a bad flag, a --repo, --base or --head that git cannot resolve or relate, or no Metabase credential when a transform needs testing, which is found after `job.start`. Exits 1 on a crash, such as a changed content file that does not parse, and 130 on an interrupt: the stream stops before `job.end`, the error is on stderr, and no --results file is left, not even an earlier run's. When the reader closes stdout early, the job still runs to the end, writes --results and exits by its state.",
+	details: [
+		"Compares --head with its merge base with --base and finds the transforms whose files or tests changed. Two stages check them: `lint` fails each transform the branch adds or whose logic (source or target) it edits that has no transform test, fails each transform the branch leaves at head without the last of its transform tests, and warns about untested transforms whose logic the branch did not change. A transform whose source type is not `query`, such as a Python transform, cannot have transform tests, so `lint` does not fail it: an `untestable-transform` warning lists each such transform the branch adds, edits or strips of its tests. A change to the transform's query text, whitespace included, is an edit; a change to the YAML layout alone is not. A transform test is a TransformTest file at --head whose `transform_id` names the transform and whose `expectations` list is not empty; a test without expectations checks nothing, so it does not count. `unit` runs the instance's tests of the transforms in `job.start.checked`, on the Metabase instance that --url, MB_URL or --profile names, in that order, which must already hold the branch's content; it is absent when `checked` is empty, so a job with nothing to test never connects to Metabase, and it runs even when `lint` fails, so one job reports both stages' findings. A checked transform the branch tests but the instance lists no test for is `refused` with `detail.error_code` `ci.no-tests-on-instance`. Content files are the `.yaml` files Metabase's import reads: not dotfiles, under a top-level serialization folder such as `transforms/` or `collections/`. Only committed content is checked: when --head is the checked-out commit, a content file with uncommitted changes is listed in an `uncommitted-content` warning, and its committed version is checked.",
+		"With --format json, the default when stdout is not a terminal, writes one JSON event per line (`job.start`, then each stage and check, then `job.end`); `job.start.checked` lists the transforms the job covered, and a `no-content-changes` warning says when the change touches no content file, so no transform test ran; an `unread-content` warning lists the content files at --head that the change did not touch and this check cannot read, which coverage skips; each transform test's result is passed through as the check's `detail`, with every row the server sent. With --format text, the default on a terminal, writes the same events as lines for a person: each failed expectation with up to --max-rows lines of its missing and extra rows, keyed by the first column, then a count of the rest. The --results file is JSON whatever the format, and holds every row the server sent.",
+		"Exits 0 when the job passes. Exits 1 after `job.end` when it does not: `state` is `failed` when a check failed (fix the transform), and `errored` when no check failed but one could not judge the change (fix the test or the setup); a failure outranks errors, since it is a finding about the change. Exits 2 on a usage or config error: a bad flag, a --repo, --base or --head that git cannot resolve or relate, or, found after `job.start` when the unit stage connects, a configuration it cannot use, such as a browser-login profile bound to another URL; a missing credential is not one, since it ends the unit stage instead.",
+		"A test run that times out, loses its connection or gets an HTTP error is an `error` check whose `detail.error_code` starts with `ci.`, and the next test runs. A failure every later request would repeat ends the unit stage early, `errored` unless a check failed, with the reason in `stage.end.stopped`: no Metabase credential is configured (`ci.no-credential`, before any request), Metabase rejects the credential, the server has no transform testing, the entity-id lookup fails, or Metabase cannot be reached before a test runs. Exits 1 on a crash, such as a content file the change touched that does not parse at --head, and 130 on an interrupt: the stream stops before `job.end`, the error is on stderr, and no --results file is left, not even an earlier run's. When the reader closes stdout early, the job still runs to the end, writes --results and exits by its state."
+	].join("\n\n"),
 	requires: [
 		"eidTranslation.translate",
 		"transform.get",
@@ -1008,6 +1308,7 @@ var run_default = defineMetabaseCommand({
 		"transformTest.run"
 	],
 	args: {
+		...formatFlags,
 		...profileFlag,
 		...connectionFlags,
 		base: {
@@ -1027,12 +1328,21 @@ var run_default = defineMetabaseCommand({
 		},
 		results: {
 			type: "string",
-			description: "Also write every event to this file, as one JSON array"
+			description: "Also write every event to this file, as one JSON array, with every row the server sent"
+		},
+		"max-rows": {
+			type: "string",
+			description: "Row lines each failed expectation shows under --format text; 0 shows only counts. JSON output and the --results file keep every row",
+			default: String(5)
 		}
 	},
 	outputSchema: CiEvent,
-	examples: ["mb ci run --base origin/main", "mb ci run --base origin/main --results results.json"],
-	async run({ args, getClient }) {
+	examples: ["mb ci run --base origin/main", "mb ci run --base origin/main --format text --results results.json"],
+	async run({ args, ctx, getClient }) {
+		const maxRows = parseInteger(args["max-rows"], {
+			name: "--max-rows",
+			min: 0
+		});
 		const state = await runJob({
 			repo: args.repo,
 			base: args.base,
@@ -1040,16 +1350,25 @@ var run_default = defineMetabaseCommand({
 			stages: async (plan) => {
 				const lint = coverageStage(plan.coverage);
 				if (plan.checked.length === 0) return [lint];
-				return [lint, unitStage(plan.checked, async () => clientPort(await getClient()))];
+				const connect = async () => clientPort(await getClient());
+				return [lint, unitStage(plan.checked, untestedTransforms(plan.coverage), connect)];
 			},
 			job: randomUUID(),
 			now: () => /* @__PURE__ */ new Date(),
-			write: jsonLineWriter(process.stdout),
+			write: ctx.format === "json" ? jsonLineWriter(process.stdout) : textEventWriter(maxRows),
 			resultsPath: args.results ?? null,
 			signal: interruptSignal
 		});
 		if (state !== "passed") throw new FailedResultError(`ci job ${state}`);
 	}
 });
+function textEventWriter(maxRows) {
+	const writeLine = lineWriter(process.stdout);
+	let failed = NO_FAILED_CHECKS;
+	return (event) => {
+		for (const line of ciEventLines(event, maxRows, failed)) writeLine(line);
+		failed = failedChecksAfter(failed, event);
+	};
+}
 //#endregion
 export { run_default as default };