@metabase/cli 0.5.6 → 0.5.7-alpha.bryan-rci-6-coverage.6f886fd

package/dist/run-Dc3u_olU.mjs

@@ -0,0 +1,819 @@
+import { c as InternalError, h as ValidationError, o as ConfigError, r as isPlainObject, s as FailedResultError } from "./predicates-0C0TsWcJ.mjs";
+import { at as connectionFlags, d as serializeJson, dt as profileFlag, p as writeJsonLine, q as HttpError, t as interruptSignal } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-DsfR_yrb.mjs";
+import { i as TransformTestRefusalCode } from "./transform-test-DHTxBt4k.mjs";
+import { i as runProcessBinary, r as runProcess, t as ProcessNotFoundError } from "./process-cDa9fEBe.mjs";
+import { t as parseYaml } from "./yaml-QoEP-7KU.mjs";
+import { z } from "zod";
+import { writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { performance } from "node:perf_hooks";
+//#region src/core/ci-coverage.ts
+function byName(a, b) {
+	return a.name.localeCompare(b.name);
+}
+function assessCoverage(inputs) {
+	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"
+		});
+	}
+	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),
+		untouchedUntested: untouchedUntested.toSorted(byName)
+	};
+}
+const UNTOUCHED_CHECK_ID = "untouched";
+function untouchedWarnings(untouched) {
+	if (untouched.length === 0) return [];
+	return [{
+		code: "no-tests-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(", ")}`
+	}];
+}
+function coverageStage(assessment) {
+	return {
+		name: "lint",
+		run: async (report) => {
+			for (const transform of assessment.untestedChanges) report({
+				check: {
+					kind: "coverage",
+					id: transform.entityId,
+					label: transform.name
+				},
+				verdict: "failed",
+				warnings: [],
+				ms: 0,
+				detail: {
+					change: transform.change,
+					message: `${transform.name} is ${transform.change} in this change and has no transform tests`
+				}
+			});
+			const untouched = assessment.untouchedUntested;
+			report({
+				check: {
+					kind: "coverage",
+					id: UNTOUCHED_CHECK_ID,
+					label: "Transforms whose logic this change did not touch"
+				},
+				verdict: "passed",
+				warnings: untouchedWarnings(untouched),
+				ms: 0,
+				detail: { untested: untouched.map((transform) => ({
+					entity_id: transform.entityId,
+					name: transform.name
+				})) }
+			});
+		}
+	};
+}
+const StageName = z.enum(["lint", "unit"]);
+const Verdict = z.enum([
+	"passed",
+	"failed",
+	"error",
+	"refused"
+]);
+const StageStatus = z.enum([
+	"passed",
+	"failed",
+	"errored",
+	"skipped"
+]);
+const JobState = StageStatus.exclude(["skipped"]);
+const CiWarning = z.object({
+	code: z.string(),
+	message: z.string()
+});
+const CheckedTransform = z.object({
+	entity_id: z.string(),
+	name: z.string()
+});
+const Snapshot = z.object({
+	base: z.string(),
+	head: z.string()
+});
+const Check = z.object({
+	kind: z.enum([
+		"coverage",
+		"yaml",
+		"cycles",
+		"broken-refs",
+		"transform-test"
+	]),
+	id: z.string(),
+	label: z.string()
+});
+const EventEnvelope = z.object({
+	seq: z.number().int().nonnegative(),
+	job: z.string(),
+	at: z.iso.datetime()
+});
+const JobStart = EventEnvelope.extend({
+	type: z.literal("job.start"),
+	v: z.literal(1),
+	snapshot: Snapshot,
+	checked: z.array(CheckedTransform),
+	warnings: z.array(CiWarning)
+});
+const StageStart = EventEnvelope.extend({
+	type: z.literal("stage.start"),
+	stage: StageName
+});
+const CheckResult = EventEnvelope.extend({
+	type: z.literal("check.result"),
+	stage: StageName,
+	check: Check,
+	verdict: Verdict,
+	warnings: z.array(CiWarning),
+	ms: z.number().nonnegative(),
+	detail: z.unknown()
+});
+const StageEnd = EventEnvelope.extend({
+	type: z.literal("stage.end"),
+	stage: StageName,
+	status: StageStatus
+});
+const JobEnd = EventEnvelope.extend({
+	type: z.literal("job.end"),
+	state: JobState,
+	counts: z.object({
+		checks: z.number().int(),
+		warnings: z.number().int()
+	})
+});
+const CiEvent = z.discriminatedUnion("type", [
+	JobStart,
+	StageStart,
+	CheckResult,
+	StageEnd,
+	JobEnd
+]);
+function createEmitter(options) {
+	let seq = 0;
+	return (body) => {
+		const parsed = CiEvent.safeParse({
+			...body,
+			seq,
+			job: options.job,
+			at: options.now().toISOString()
+		});
+		if (!parsed.success) throw new InternalError(`ci event "${body.type}" does not match its schema: ${parsed.error.message}`);
+		seq += 1;
+		options.write(parsed.data);
+	};
+}
+function stageStatus(verdicts) {
+	if (verdicts.includes("failed")) return "failed";
+	if (verdicts.includes("refused") || verdicts.includes("error")) return "errored";
+	return "passed";
+}
+async function runStages(stages, emit) {
+	let state = "passed";
+	let checks = 0;
+	let warnings = 0;
+	for (const stage of stages) {
+		if (state !== "passed") {
+			emit({
+				type: "stage.end",
+				stage: stage.name,
+				status: "skipped"
+			});
+			continue;
+		}
+		emit({
+			type: "stage.start",
+			stage: stage.name
+		});
+		const verdicts = [];
+		await stage.run((check) => {
+			verdicts.push(check.verdict);
+			checks += 1;
+			warnings += check.warnings.length;
+			emit({
+				type: "check.result",
+				stage: stage.name,
+				...check
+			});
+		});
+		state = stageStatus(verdicts);
+		emit({
+			type: "stage.end",
+			stage: stage.name,
+			status: state
+		});
+	}
+	return {
+		state,
+		checks,
+		warnings
+	};
+}
+//#endregion
+//#region src/core/ci-affected.ts
+const SINGLE_PATH_STATUSES = /* @__PURE__ */ new Map([
+	["A", "added"],
+	["M", "modified"],
+	["D", "deleted"],
+	["T", "modified"]
+]);
+const RENAME_STATUS = "R";
+const COPY_STATUS = "C";
+function nameStatusError(message) {
+	return new InternalError(`git diff --name-status -z: ${message}`);
+}
+function requireToken(token, what) {
+	if (token === void 0 || token === "") throw nameStatusError(`missing ${what}`);
+	return token;
+}
+function parseNameStatus(output) {
+	if (output === "") return [];
+	if (!output.endsWith("\0")) throw nameStatusError("truncated: the output does not end in a NUL");
+	const tokens = output.slice(0, -1).split("\0");
+	const entries = [];
+	let index = 0;
+	while (index < tokens.length) {
+		const code = requireToken(tokens[index], "a status");
+		const missingPath = `a path for status "${code}"`;
+		const first = tokens[index + 1];
+		const second = tokens[index + 2];
+		const letter = code.charAt(0);
+		const single = SINGLE_PATH_STATUSES.get(letter);
+		if (single !== void 0) {
+			entries.push({
+				status: single,
+				path: requireToken(first, missingPath)
+			});
+			index += 2;
+			continue;
+		}
+		if (letter === RENAME_STATUS) {
+			entries.push({
+				status: "renamed",
+				path: requireToken(second, missingPath),
+				oldPath: requireToken(first, missingPath)
+			});
+			index += 3;
+			continue;
+		}
+		if (letter === COPY_STATUS) {
+			entries.push({
+				status: "added",
+				path: requireToken(second, missingPath)
+			});
+			index += 3;
+			continue;
+		}
+		throw nameStatusError(`unexpected status "${code}"`);
+	}
+	return entries;
+}
+const PORCELAIN_STATUS_WIDTH = 2;
+const PORCELAIN_SOURCE_STATUSES = /* @__PURE__ */ new Set(["R", "C"]);
+function parseStatusPorcelain(output) {
+	if (output === "") return [];
+	if (!output.endsWith("\0")) throw new InternalError("git status --porcelain -z: truncated: the output does not end in a NUL");
+	const paths = [];
+	let sourceFollows = false;
+	for (const record of output.slice(0, -1).split("\0")) {
+		if (sourceFollows) {
+			sourceFollows = false;
+			continue;
+		}
+		const status = record.slice(0, PORCELAIN_STATUS_WIDTH);
+		const path = record.slice(3);
+		if (status.length !== PORCELAIN_STATUS_WIDTH || record.charAt(PORCELAIN_STATUS_WIDTH) !== " " || path === "") throw new InternalError(`git status --porcelain -z: malformed entry "${record}"`);
+		paths.push(path);
+		sourceFollows = [...status].some((letter) => PORCELAIN_SOURCE_STATUSES.has(letter));
+	}
+	return paths;
+}
+const SERDES_META_KEY = "serdes/meta";
+const TransformDocument = z.object({
+	entity_id: z.string().min(1),
+	name: z.string().min(1),
+	source: z.unknown(),
+	target: z.unknown()
+}).loose();
+const TransformTestDocument = z.object({ transform_id: z.string().min(1) }).loose();
+const SerdesMeta = z.array(z.object({ model: z.string() }).loose()).min(1);
+function serdesModel(path, document) {
+	if (!isPlainObject(document) || !(SERDES_META_KEY in document)) return null;
+	const meta = SerdesMeta.safeParse(document[SERDES_META_KEY]);
+	if (!meta.success) throw new ValidationError(`${path}: ${SERDES_META_KEY} must be a non-empty list of entries with a model`, {
+		source: path,
+		zodIssues: meta.error.issues
+	});
+	const last = meta.data.at(-1);
+	if (last === void 0) throw new InternalError(`${path}: ${SERDES_META_KEY} passed a non-empty check but has no entries`);
+	return last.model;
+}
+function classifyContentFile(path, document) {
+	const model = serdesModel(path, document);
+	if (model === "Transform") {
+		const transform = TransformDocument.safeParse(document);
+		if (!transform.success) throw new ValidationError(`${path}: a Transform must have an entity_id, a name, a source and a target`, {
+			source: path,
+			zodIssues: transform.error.issues
+		});
+		return {
+			kind: "transform",
+			entityId: transform.data.entity_id,
+			name: transform.data.name,
+			logic: {
+				source: transform.data.source,
+				target: transform.data.target
+			}
+		};
+	}
+	if (model === "TransformTest") {
+		const test = TransformTestDocument.safeParse(document);
+		if (!test.success) throw new ValidationError(`${path}: a TransformTest must name its transform_id`, {
+			source: path,
+			zodIssues: test.error.issues
+		});
+		return {
+			kind: "transform-test",
+			transformId: test.data.transform_id
+		};
+	}
+	return { kind: "other" };
+}
+function transformEntityId(file) {
+	return file?.kind === "transform" ? file.entityId : null;
+}
+function affectedTransforms(changes) {
+	const touched = /* @__PURE__ */ new Set();
+	const atHead = /* @__PURE__ */ new Set();
+	const atBase = /* @__PURE__ */ new Set();
+	for (const { base, head } of changes) {
+		const headId = transformEntityId(head);
+		const baseId = transformEntityId(base);
+		if (headId !== null) {
+			touched.add(headId);
+			atHead.add(headId);
+		}
+		if (baseId !== null) atBase.add(baseId);
+		for (const side of [base, head]) if (side?.kind === "transform-test") touched.add(side.transformId);
+	}
+	return [...touched].filter((entityId) => atHead.has(entityId) || !atBase.has(entityId));
+}
+const CONTENT_FILE_EXTENSIONS = [".yaml", ".yml"];
+function isContentPath(path) {
+	return CONTENT_FILE_EXTENSIONS.some((extension) => path.endsWith(extension));
+}
+function uncommittedContentWarning(paths) {
+	const content = paths.filter(isContentPath);
+	if (content.length === 0) return null;
+	return {
+		code: "uncommitted-content",
+		message: `${content.length === 1 ? "1 content file is" : `${content.length} content files are`} not committed, so CI did not check: ${content.join(", ")}`
+	};
+}
+//#endregion
+//#region src/runtime/git.ts
+const GIT = "git";
+const NO_MATCH_EXIT_CODE = 1;
+const NO_MERGE_BASE_EXIT_CODE = 1;
+const UNKNOWN_REF_EXIT_CODE = 1;
+async function withGit(spawn) {
+	try {
+		return await spawn();
+	} catch (error) {
+		if (error instanceof ProcessNotFoundError) throw new ConfigError("git is not installed or not on PATH");
+		throw error;
+	}
+}
+function runGit(repo, args) {
+	return withGit(() => runProcess(GIT, [
+		"-C",
+		repo,
+		...args
+	]));
+}
+async function git(repo, args) {
+	const result = await runGit(repo, args);
+	if (result.exitCode !== 0) throw new ConfigError(`git ${args.join(" ")} failed in ${repo}: ${result.stderr.trim()}`);
+	return result.stdout;
+}
+async function repositoryRoot(repo) {
+	const result = await runGit(repo, ["rev-parse", "--show-toplevel"]);
+	if (result.exitCode !== 0) throw new ConfigError(`--repo ${repo} is not inside a git work tree: ${result.stderr.trim()}`);
+	return result.stdout.trim();
+}
+async function resolveCommit(repo, ref, flag) {
+	const result = await runGit(repo, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"--end-of-options",
+		`${ref}^{commit}`
+	]);
+	if (result.exitCode === UNKNOWN_REF_EXIT_CODE) throw new ConfigError(`${flag} ${ref} is not a commit in ${repo}`);
+	if (result.exitCode !== 0) throw new ConfigError(`git rev-parse failed in ${repo}: ${result.stderr.trim()}`);
+	return result.stdout.trim();
+}
+async function checkedOutCommit(repo) {
+	const result = await runGit(repo, [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		"HEAD"
+	]);
+	if (result.exitCode === UNKNOWN_REF_EXIT_CODE) return null;
+	if (result.exitCode !== 0) throw new ConfigError(`git rev-parse HEAD failed in ${repo}: ${result.stderr.trim()}`);
+	return result.stdout.trim();
+}
+async function mergeBase(repo, base, head) {
+	const result = await runGit(repo, [
+		"merge-base",
+		base,
+		head
+	]);
+	if (result.exitCode === NO_MERGE_BASE_EXIT_CODE) throw new ConfigError(`--base and --head share no history in ${repo}: the clone may be shallow (fetch the full history, e.g. actions/checkout with fetch-depth: 0), or the histories are unrelated`);
+	if (result.exitCode !== 0) throw new ConfigError(`git merge-base failed in ${repo}: ${result.stderr.trim()}`);
+	return result.stdout.trim();
+}
+function diffNameStatus(repo, from, to) {
+	return git(repo, [
+		"diff",
+		"--name-status",
+		"-z",
+		"-M",
+		from,
+		to
+	]);
+}
+function statusPorcelain(repo) {
+	return git(repo, [
+		"status",
+		"--porcelain",
+		"-z",
+		"--untracked-files=all"
+	]);
+}
+function readFileAt(repo, commit, path) {
+	return git(repo, [
+		"cat-file",
+		"blob",
+		`${commit}:${path}`
+	]);
+}
+async function filesMatching(repo, commit, pattern, pathspecs) {
+	const result = await runGit(repo, [
+		"grep",
+		"--no-color",
+		"-z",
+		"-l",
+		"-E",
+		"-e",
+		pattern,
+		commit,
+		"--",
+		...pathspecs
+	]);
+	if (result.exitCode === NO_MATCH_EXIT_CODE) return [];
+	if (result.exitCode !== 0) throw new ConfigError(`git grep failed in ${repo}: ${result.stderr.trim()}`);
+	const prefix = `${commit}:`;
+	return result.stdout.split("\0").filter((entry) => entry !== "").map((entry) => {
+		if (!entry.startsWith(prefix)) throw new InternalError(`git grep printed "${entry}", which does not start with ${prefix}`);
+		return entry.slice(prefix.length);
+	});
+}
+const NEWLINE = 10;
+const utf8 = new TextDecoder("utf-8");
+async function readFilesAt(repo, commit, paths) {
+	const files = /* @__PURE__ */ new Map();
+	if (paths.length === 0) return files;
+	const multiline = paths.find((path) => path.includes("\n"));
+	if (multiline !== void 0) throw new ConfigError(`cannot read ${JSON.stringify(multiline)}: a path with a newline cannot be batched`);
+	const result = await withGit(() => runProcessBinary(GIT, [
+		"-C",
+		repo,
+		"cat-file",
+		"--batch"
+	], { stdin: paths.map((path) => `${commit}:${path}\n`).join("") }));
+	if (result.exitCode !== 0) throw new ConfigError(`git cat-file --batch failed in ${repo}: ${result.stderr.trim()}`);
+	const output = result.stdout;
+	let offset = 0;
+	for (const path of paths) {
+		const headerEnd = output.indexOf(NEWLINE, offset);
+		if (headerEnd === -1) throw new InternalError(`git cat-file --batch stopped before ${path}`);
+		const header = utf8.decode(output.subarray(offset, headerEnd)).split(" ");
+		const size = Number(header[2]);
+		if (header[1] !== "blob" || !Number.isInteger(size)) throw new InternalError(`${path} is not a file at ${commit}, though git listed it there`);
+		const start = headerEnd + 1;
+		if (output[start + size] !== NEWLINE) throw new InternalError(`git cat-file --batch framed ${path} with ${size} bytes, but no newline follows them`);
+		files.set(path, utf8.decode(output.subarray(start, start + size)));
+		offset = start + size + 1;
+	}
+	if (offset !== output.length) throw new InternalError("git cat-file --batch printed more than the paths it was asked for");
+	return files;
+}
+//#endregion
+//#region src/commands/ci/job-plan.ts
+const CONTENT_PATHSPECS = CONTENT_FILE_EXTENSIONS.map((extension) => `*${extension}`);
+async function classifyAt(repo, commit, path) {
+	if (path === null || !isContentPath(path)) return null;
+	return classifyContentFile(path, parseYaml(await readFileAt(repo, commit, path), z.unknown(), { source: `${commit}:${path}` }));
+}
+function basePath(entry) {
+	if (entry.status === "added") return null;
+	return entry.status === "renamed" ? entry.oldPath : entry.path;
+}
+function headPath(entry) {
+	return entry.status === "deleted" ? null : entry.path;
+}
+async function classifyChange(repo, forkPoint, head, entry) {
+	const [baseSide, headSide] = await Promise.all([classifyAt(repo, forkPoint, basePath(entry)), classifyAt(repo, head, headPath(entry))]);
+	return {
+		base: baseSide,
+		head: headSide
+	};
+}
+const TRANSFORM_MODEL_PATTERN = `model["']?:[[:space:]]*["']?Transform`;
+function record(atHead, file) {
+	if (file?.kind === "transform") atHead.names.set(file.entityId, file.name);
+	else if (file?.kind === "transform-test") atHead.tested.add(file.transformId);
+}
+async function scanHead(repo, head, changes, changedPaths) {
+	const atHead = {
+		names: /* @__PURE__ */ new Map(),
+		tested: /* @__PURE__ */ new Set()
+	};
+	for (const change of changes) record(atHead, change.head);
+	const unchanged = (await filesMatching(repo, head, TRANSFORM_MODEL_PATTERN, CONTENT_PATHSPECS)).filter((path) => !changedPaths.has(path));
+	for (const [path, text] of await readFilesAt(repo, head, unchanged)) record(atHead, classifyContentFile(path, parseYaml(text, z.unknown(), { source: `${head}:${path}` })));
+	return atHead;
+}
+async function planJob(repoPath, baseRef, headRef) {
+	const repo = await repositoryRoot(repoPath);
+	const [base, head, checkout] = await Promise.all([
+		resolveCommit(repo, baseRef, "--base"),
+		resolveCommit(repo, headRef, "--head"),
+		checkedOutCommit(repo)
+	]);
+	const forkPoint = await mergeBase(repo, base, head);
+	const entries = parseNameStatus(await diffNameStatus(repo, forkPoint, head));
+	const changes = await Promise.all(entries.map((entry) => classifyChange(repo, forkPoint, head, entry)));
+	const atHead = await scanHead(repo, head, changes, new Set(entries.map((entry) => entry.path)));
+	const checked = [];
+	const warnings = [];
+	for (const entityId of affectedTransforms(changes)) {
+		const name = atHead.names.get(entityId);
+		if (name === void 0) {
+			warnings.push({
+				code: "missing-transform",
+				message: `a changed transform test covers transform ${entityId}, which is not in the repo at ${head}`
+			});
+			continue;
+		}
+		checked.push({
+			entity_id: entityId,
+			name
+		});
+	}
+	const coverage = assessCoverage({
+		changes,
+		transformsAtHead: atHead.names,
+		testedAtHead: atHead.tested
+	});
+	if (head === checkout) {
+		const uncommitted = uncommittedContentWarning(parseStatusPorcelain(await statusPorcelain(repo)));
+		if (uncommitted !== null) warnings.push(uncommitted);
+	}
+	return {
+		snapshot: {
+			base,
+			head
+		},
+		checked,
+		warnings,
+		coverage
+	};
+}
+//#endregion
+//#region src/commands/ci/job.ts
+async function runJob(options) {
+	const events = [];
+	const emit = createEmitter({
+		job: options.job,
+		now: options.now,
+		write: (event) => {
+			events.push(event);
+			options.write(event);
+		}
+	});
+	const plan = await planJob(options.repo, options.base, options.head);
+	emit({
+		type: "job.start",
+		v: 1,
+		snapshot: plan.snapshot,
+		checked: plan.checked,
+		warnings: plan.warnings
+	});
+	const outcome = await runStages(await options.stages(plan), emit);
+	emit({
+		type: "job.end",
+		state: outcome.state,
+		counts: {
+			checks: outcome.checks,
+			warnings: outcome.warnings + plan.warnings.length
+		}
+	});
+	if (options.resultsPath !== null) await writeFile(options.resultsPath, serializeJson(events, false) + "\n", "utf8");
+	return outcome.state;
+}
+//#endregion
+//#region src/core/ci-unit.ts
+function testVerdict(result) {
+	const statuses = new Set(result.expectations.map((expectation) => expectation.status));
+	if (statuses.has("failed")) return "failed";
+	if (statuses.has("error")) return "error";
+	return "passed";
+}
+function testRefusal(error) {
+	if (!(error instanceof HttpError)) return null;
+	const code = TransformTestRefusalCode.safeParse(error.errorCode);
+	if (!code.success) return null;
+	return {
+		error_code: code.data,
+		message: error.serverMessage ?? error.message
+	};
+}
+const CHANGE_FAILURE_CODES = /* @__PURE__ */ new Set(["transform-test.transform-failed", "transform-test.unparseable-source"]);
+function refusalVerdict(refusal) {
+	return CHANGE_FAILURE_CODES.has(refusal.error_code) ? "failed" : "refused";
+}
+//#endregion
+//#region src/commands/ci/unit-stage.ts
+const TEST_TIMEOUT_MS = 12e4;
+const OK_STATUS = "ok";
+const LOOKUP_KIND_BY_STATUS = /* @__PURE__ */ new Map([["not-found", "not-found"], ["invalid-format", "invalid-entity-id"]]);
+function transformLookup(entityId, entry) {
+	if (entry?.status === OK_STATUS && entry.id !== void 0) return {
+		kind: "found",
+		id: entry.id
+	};
+	const kind = entry === void 0 ? void 0 : LOOKUP_KIND_BY_STATUS.get(entry.status);
+	if (kind === void 0) throw new InternalError(`eid translation answered ${entityId} with ${JSON.stringify(entry ?? null)}`);
+	return { kind };
+}
+function clientPort(client) {
+	return {
+		lookUpTransforms: async (entityIds) => {
+			const result = await client.eidTranslation.translate({ entity_ids: { transform: [...entityIds] } });
+			const lookups = /* @__PURE__ */ new Map();
+			for (const entityId of entityIds) lookups.set(entityId, transformLookup(entityId, result.entity_ids[entityId]));
+			return lookups;
+		},
+		listTests: async (transformId) => (await client.transformTest.list({ "transform-id": transformId })).data,
+		runTest: (testId) => client.transformTest.run(testId, {
+			timeoutMs: TEST_TIMEOUT_MS,
+			signal: interruptSignal
+		}),
+		nowMs: () => performance.now()
+	};
+}
+const MISSING_TRANSFORM_DETAIL = {
+	"not-found": {
+		error_code: "ci.transform-not-on-instance",
+		message: "the transform is in the branch but not on the Metabase instance; load the branch into it first"
+	},
+	"invalid-entity-id": {
+		error_code: "ci.invalid-entity-id",
+		message: "the transform's entity_id in the branch is not a valid entity id"
+	}
+};
+function unitStage(checked, connect) {
+	return {
+		name: "unit",
+		run: async (report) => {
+			const port = await connect();
+			const lookups = await port.lookUpTransforms(checked.map((transform) => transform.entity_id));
+			for (const transform of checked) {
+				const lookup = lookups.get(transform.entity_id);
+				if (lookup === void 0) throw new InternalError(`no lookup for transform ${transform.entity_id}`);
+				if (lookup.kind !== "found") {
+					report({
+						check: {
+							kind: "transform-test",
+							id: transform.entity_id,
+							label: transform.name
+						},
+						verdict: "refused",
+						warnings: [],
+						ms: 0,
+						detail: MISSING_TRANSFORM_DETAIL[lookup.kind]
+					});
+					continue;
+				}
+				const tests = await port.listTests(lookup.id);
+				for (const test of tests.toSorted((a, b) => a.id - b.id)) {
+					const check = {
+						kind: "transform-test",
+						id: String(test.id),
+						label: `${transform.name}: ${test.name}`
+					};
+					const started = port.nowMs();
+					try {
+						const result = await port.runTest(test.id);
+						report({
+							check,
+							verdict: testVerdict(result),
+							warnings: [],
+							ms: port.nowMs() - started,
+							detail: result
+						});
+					} catch (error) {
+						const refusal = testRefusal(error);
+						if (refusal === null) throw error;
+						report({
+							check,
+							verdict: refusalVerdict(refusal),
+							warnings: [],
+							ms: port.nowMs() - started,
+							detail: refusal
+						});
+					}
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/commands/ci/run.ts
+var run_default = defineMetabaseCommand({
+	meta: {
+		name: "run",
+		description: "Check the transforms a branch changed, writing one JSON event per line"
+	},
+	details: "Compares --head with its merge base with --base, finds the transforms whose files or tests changed, and runs their transform tests on the Metabase instance of --profile, which must already hold the branch's content. Only committed content is checked: when --head is the checked-out commit, a content file that is modified or untracked in the working tree is listed in an `uncommitted-content` warning instead. 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 each transform test's result is passed through as the check's `detail`. Exits 1 when the job does not pass; `job.end.state` says whether a check failed (`failed`: fix the transform) or could not run (`errored`: fix the test or the setup). A crash stops the stream before `job.end` and writes no --results file.",
+	requires: [
+		"eidTranslation.translate",
+		"transformTest.list",
+		"transformTest.run"
+	],
+	args: {
+		...profileFlag,
+		...connectionFlags,
+		base: {
+			type: "string",
+			description: "Ref the branch is compared against",
+			required: true
+		},
+		head: {
+			type: "string",
+			description: "Ref to check",
+			default: "HEAD"
+		},
+		repo: {
+			type: "string",
+			description: "Path to the git repository",
+			default: "."
+		},
+		results: {
+			type: "string",
+			description: "Also write every event to this JSON file"
+		}
+	},
+	outputSchema: CiEvent,
+	examples: ["mb ci run --base origin/main", "mb ci run --base origin/main --results results.json"],
+	async run({ args, getClient }) {
+		const state = await runJob({
+			repo: args.repo,
+			base: args.base,
+			head: args.head,
+			stages: async (plan) => {
+				const lint = coverageStage(plan.coverage);
+				if (plan.checked.length === 0) return [lint];
+				return [lint, unitStage(plan.checked, async () => clientPort(await getClient()))];
+			},
+			job: randomUUID(),
+			now: () => /* @__PURE__ */ new Date(),
+			write: writeJsonLine,
+			resultsPath: args.results ?? null
+		});
+		if (state !== "passed") throw new FailedResultError(`ci job ${state}`);
+	}
+});
+//#endregion
+export { run_default as default };