@metabase/cli 0.4.0 → 0.4.1-alpha.release-65-integration-branch.5cbe297

package/dist/transform-BZaNFGeK.mjs

@@ -0,0 +1,28 @@
+import { t as defineCommandGroup } from "./group-D4w87fXL.mjs";
+//#region src/commands/transform/index.ts
+var transform_default = defineCommandGroup({
+	name: "transform",
+	description: "Manage Metabase transforms",
+	skills: [{
+		skill: "transform",
+		purpose: "body shape, run-with-wait, iterate"
+	}, {
+		skill: "mbql",
+		purpose: "MBQL source.query bodies"
+	}],
+	subCommands: {
+		list: () => import("./list-2EWHwbQs.mjs").then((mod) => mod.default),
+		get: () => import("./get-D7HPiBB0.mjs").then((mod) => mod.default),
+		dependencies: () => import("./dependencies-DZ-kMsDa.mjs").then((mod) => mod.default),
+		create: () => import("./create-XnYN2zoc.mjs").then((mod) => mod.default),
+		update: () => import("./update-DneJLQXe.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-DOn2uk0u.mjs").then((mod) => mod.default),
+		"delete-table": () => import("./delete-table-DFqm6bAq.mjs").then((mod) => mod.default),
+		run: () => import("./run-Buf4B8QH.mjs").then((mod) => mod.default),
+		cancel: () => import("./cancel-DCOvSQsq.mjs").then((mod) => mod.default),
+		"get-run": () => import("./get-run-bU-d--nM.mjs").then((mod) => mod.default),
+		runs: () => import("./runs-D2CXgW10.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { transform_default as default };

package/dist/{transform-CNBIV7No.mjs → transform-D4z70PIN.mjs}

@@ -1,4 +1,4 @@
-import { _ as MALFORMED_CELL } from "./cli.mjs";
+import { v as MALFORMED_CELL } from "./cli.mjs";
 import { d as TransformTarget, n as TransformCompact, s as TransformRunCompact } from "./transform-DiW7bREn.mjs";
 //#region src/output/views/transform.ts
 function formatTarget(value) {

package/dist/transform-job-QMI2qWin.mjs

@@ -0,0 +1,22 @@
+import { t as defineCommandGroup } from "./group-D4w87fXL.mjs";
+//#region src/commands/transform-job/index.ts
+var transform_job_default = defineCommandGroup({
+	name: "transform-job",
+	description: "Manage Metabase transform jobs",
+	skills: [{
+		skill: "transform",
+		purpose: "tag-driven job schedules"
+	}],
+	subCommands: {
+		list: () => import("./list-CYlPgzD1.mjs").then((mod) => mod.default),
+		get: () => import("./get-DpYTiE4D.mjs").then((mod) => mod.default),
+		create: () => import("./create-B57D5E-o.mjs").then((mod) => mod.default),
+		update: () => import("./update-DgmlUn64.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-BztmAfPc.mjs").then((mod) => mod.default),
+		run: () => import("./run-DyGMvbMm.mjs").then((mod) => mod.default),
+		transforms: () => import("./transforms-0uhBh0H4.mjs").then((mod) => mod.default),
+		"set-active": () => import("./set-active-CbiJv8Hg.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { transform_job_default as default };

package/dist/{transform-tag-nTb0Ivpj.mjs → transform-tag-CzjLKILh.mjs}

@@ -1,4 +1,4 @@
-import { t as defineCommandGroup } from "./group-bpD_KcjA.mjs";
+import { t as defineCommandGroup } from "./group-D4w87fXL.mjs";
 //#region src/commands/transform-tag/index.ts
 var transform_tag_default = defineCommandGroup({
 	name: "transform-tag",
@@ -8,10 +8,10 @@ var transform_tag_default = defineCommandGroup({
 		purpose: "tags that drive job schedules"
 	}],
 	subCommands: {
-		list: () => import("./list-BT7xiUQe.mjs").then((mod) => mod.default),
-		create: () => import("./create-B4gXKDRr.mjs").then((mod) => mod.default),
-		update: () => import("./update-CM5uuhjB.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-DndykJn2.mjs").then((mod) => mod.default)
+		list: () => import("./list-DoLqxEjq.mjs").then((mod) => mod.default),
+		create: () => import("./create-g4pZa_Xa.mjs").then((mod) => mod.default),
+		update: () => import("./update-Cv6IMLyu.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-C7QmQlp9.mjs").then((mod) => mod.default)
 	}
 });
 //#endregion

package/dist/transform-test-B9le1jKH.mjs

@@ -0,0 +1,16 @@
+import { t as defineCommandGroup } from "./group-D4w87fXL.mjs";
+//#region src/commands/transform-test/index.ts
+var transform_test_default = defineCommandGroup({
+	name: "transform-test",
+	description: "Manage transform tests — fixtures and expectations run against temp tables",
+	subCommands: {
+		list: () => import("./list-CzxrdWB8.mjs").then((mod) => mod.default),
+		get: () => import("./get-DSjITPED.mjs").then((mod) => mod.default),
+		create: () => import("./create--b64pMVM.mjs").then((mod) => mod.default),
+		update: () => import("./update-CXfLvhmK.mjs").then((mod) => mod.default),
+		delete: () => import("./delete-DPU-uQxU.mjs").then((mod) => mod.default),
+		run: () => import("./run-DlG3Ykj1.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { transform_test_default as default };

package/dist/transform-test-BjjCQ2xm.mjs

@@ -0,0 +1,169 @@
+import { z } from "zod";
+//#region ../client/src/domain/transform-test.ts
+const TransformTestTable = z.object({
+	schema: z.string().min(1).nullable().optional(),
+	name: z.string().min(1)
+}).loose();
+const TransformTestColumn = z.object({
+	name: z.string().min(1),
+	cast_type: z.string().min(1)
+}).loose();
+const TransformTestCell = z.union([
+	z.boolean(),
+	z.number(),
+	z.string(),
+	z.null()
+]);
+const TransformTestRow = z.record(z.string(), TransformTestCell);
+const TransformTestSqlInput = z.object({
+	table: TransformTestTable,
+	format: z.literal("sql"),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestRowsInput = z.object({
+	table: TransformTestTable,
+	format: z.literal("rows"),
+	columns: z.array(TransformTestColumn).min(1),
+	rows: z.array(TransformTestRow)
+}).loose();
+const TransformTestInput = z.discriminatedUnion("format", [TransformTestSqlInput, TransformTestRowsInput]);
+const TransformTestEqualsSqlExpectation = z.object({
+	type: z.literal("equals"),
+	name: z.string().min(1),
+	format: z.literal("sql"),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestEqualsRowsExpectation = z.object({
+	type: z.literal("equals"),
+	name: z.string().min(1),
+	format: z.literal("rows"),
+	columns: z.array(TransformTestColumn).min(1),
+	rows: z.array(TransformTestRow)
+}).loose();
+const TransformTestEqualsExpectation = z.discriminatedUnion("format", [TransformTestEqualsSqlExpectation, TransformTestEqualsRowsExpectation]);
+const TransformTestEmptyExpectation = z.object({
+	type: z.literal("empty"),
+	name: z.string().min(1),
+	sql: z.string().min(1)
+}).loose();
+const TransformTestExpectation = z.discriminatedUnion("type", [TransformTestEqualsExpectation, TransformTestEmptyExpectation]);
+const TransformTest = z.object({
+	id: z.number().int(),
+	entity_id: z.string(),
+	transform_id: z.number().int(),
+	creator_id: z.number().int(),
+	name: z.string(),
+	description: z.string().nullable(),
+	inputs: z.array(TransformTestInput),
+	expectations: z.array(TransformTestExpectation),
+	created_at: z.string(),
+	updated_at: z.string()
+}).loose();
+const TransformTestCompact = TransformTest.pick({
+	id: true,
+	transform_id: true,
+	name: true,
+	description: true
+}).strip();
+/**
+* The server closes this map, so an unrecognized key is a 400 there. Refusing it here names the key
+* instead: a body cloned from `get` has to shed `id`, `entity_id`, `creator_id`, `created_at` and
+* `updated_at` before it can be sent back.
+*/
+const TransformTestCreateInput = z.object({
+	transform_id: z.number().int().positive(),
+	name: z.string().min(1),
+	description: z.string().nullable().optional(),
+	inputs: z.array(TransformTestInput),
+	expectations: z.array(TransformTestExpectation)
+}).strict();
+/** Closed for the same reason as [[TransformTestCreateInput]]; every field is optional. */
+const TransformTestUpdateInput = z.object({
+	transform_id: z.number().int().positive().optional(),
+	name: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	inputs: z.array(TransformTestInput).optional(),
+	expectations: z.array(TransformTestExpectation).optional()
+}).strict();
+const TransformTestResultColumn = z.object({
+	name: z.string(),
+	database_type: z.string()
+}).loose();
+const TransformTestExpectationError = z.object({
+	type: z.string(),
+	message: z.string()
+}).loose();
+const TransformTestCellMismatch = z.object({
+	column: z.string(),
+	expected: TransformTestCell,
+	actual: TransformTestCell
+}).loose();
+const TransformTestRowCounts = z.object({
+	actual: z.number().int(),
+	expected: z.number().int()
+}).loose();
+const TransformTestEqualsFindings = z.object({
+	name: z.string(),
+	type: z.literal("equals"),
+	status: z.enum(["passed", "failed"]),
+	columns: z.array(TransformTestResultColumn),
+	"row-counts": TransformTestRowCounts,
+	"extra-rows": z.array(TransformTestRow),
+	"missing-rows": z.array(TransformTestRow),
+	"cell-mismatches": z.array(TransformTestCellMismatch),
+	truncated: z.number().int()
+}).loose();
+const TransformTestEqualsError = z.object({
+	name: z.string(),
+	type: z.literal("equals"),
+	status: z.literal("error"),
+	error: TransformTestExpectationError
+}).loose();
+const TransformTestEqualsResult = z.discriminatedUnion("status", [TransformTestEqualsFindings, TransformTestEqualsError]);
+const TransformTestEmptyPassed = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("passed")
+}).loose();
+const TransformTestEmptyFailed = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("failed"),
+	columns: z.array(TransformTestResultColumn),
+	sample: z.array(TransformTestRow),
+	truncated: z.number().int()
+}).loose();
+const TransformTestEmptyError = z.object({
+	name: z.string(),
+	type: z.literal("empty"),
+	status: z.literal("error"),
+	error: TransformTestExpectationError
+}).loose();
+const TransformTestEmptyResult = z.discriminatedUnion("status", [
+	TransformTestEmptyPassed,
+	TransformTestEmptyFailed,
+	TransformTestEmptyError
+]);
+const TransformTestExpectationResult = z.discriminatedUnion("type", [TransformTestEqualsResult, TransformTestEmptyResult]);
+const TransformTestRunResult = z.object({
+	status: z.enum(["passed", "failed"]),
+	expectations: z.array(TransformTestExpectationResult),
+	tables: z.record(z.string(), z.string())
+}).loose();
+z.enum([
+	"transform-test.unknown-column",
+	"transform-test.ambiguous-column",
+	"transform-test.missing-inputs",
+	"transform-test.unused-inputs",
+	"transform-test.duplicate-input-table",
+	"transform-test.unparseable-source",
+	"transform-test.unremapped-reference",
+	"transform-test.unsupported-transform",
+	"transform-test.unsupported-driver",
+	"transform-test.transform-failed",
+	"transform-test.setup-failed",
+	"transform-test.expectation-failed",
+	"transform-test.unsupported-format"
+]);
+//#endregion
+export { TransformTestUpdateInput as a, TransformTestRunResult as i, TransformTestCompact as n, TransformTestCreateInput as r, TransformTest as t };

package/dist/transform-test-DHGKeuHa.mjs

@@ -0,0 +1,32 @@
+import { i as TransformTestRunResult, n as TransformTestCompact } from "./transform-test-BjjCQ2xm.mjs";
+//#region src/output/views/transform-test.ts
+const transformTestView = {
+	compactPick: TransformTestCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "transform_id",
+			label: "Transform"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "description",
+			label: "Description"
+		}
+	]
+};
+const transformTestRunResultView = {
+	compactPick: TransformTestRunResult,
+	tableColumns: [{
+		key: "status",
+		label: "Status"
+	}]
+};
+//#endregion
+export { transformTestView as n, transformTestRunResultView as t };

package/dist/{transforms-BSsAfwAg.mjs → transforms-0uhBh0H4.mjs}

@@ -1,9 +1,9 @@
-import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
-import { t as parseId } from "./parse-id-BW09NysN.mjs";
-import { n as windowList } from "./window-CI_QD04s.mjs";
+import { J as outputFlags, K as listFlags, U as connectionFlags, Y as profileFlag, Z as listEnvelopeSchema, d as renderList } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-X6hVzSMW.mjs";
+import { t as parseId } from "./parse-id-CxHp2akh.mjs";
+import { n as windowList } from "./window-2ybHqui2.mjs";
 import { n as TransformCompact } from "./transform-DiW7bREn.mjs";
-import { n as transformView } from "./transform-CNBIV7No.mjs";
+import { n as transformView } from "./transform-D4z70PIN.mjs";
 //#region src/commands/transform-job/transforms.ts
 const TransformJobTransformsEnvelope = listEnvelopeSchema(TransformCompact);
 var transforms_default = defineMetabaseCommand({

package/dist/transport-BmNrb0Lz.mjs

@@ -0,0 +1,313 @@
+import { dt as ResponseShapeError, ft as TimeoutError, ht as errorMessage, mt as ValidationError, n as methodRequirements, ut as NetworkError } from "./cli.mjs";
+import { $ as CapabilityError, B as assertCredentialHeaderSafe, G as normalizeUrl, H as credentialSecrets, I as isRetryableStatus, J as checkFeatures, L as JSON_CONTENT_TYPE, M as buildNetworkError, N as isConnectionClosed, P as HttpError, Q as probeServer, R as parseJson, V as credentialAuthHeader, X as createServerProfile } from "./runtime-X6hVzSMW.mjs";
+import { n as throwIfAborted, r as untilAborted, t as combineAborts } from "./signal-0Yt8JTMn.mjs";
+import { setTimeout } from "node:timers/promises";
+//#region ../client/src/http/response-shape.ts
+async function parseJsonResponse(text, schema, context) {
+	try {
+		return parseJson(text, schema, { source: context.url });
+	} catch (error) {
+		if (error instanceof ValidationError) throw ResponseShapeError.fromZodIssues({
+			kind: "zod",
+			method: context.method,
+			url: context.url,
+			status: context.status,
+			zodIssues: error.developerDetail.zodIssues,
+			serverTag: await context.getServerTag(),
+			serverSkew: context.serverSkew
+		});
+		throw error;
+	}
+}
+//#endregion
+//#region ../client/src/http/retry.ts
+const BASE_DELAY_MS = 250;
+const MAX_DELAY_MS = 8e3;
+const MS_PER_SECOND = 1e3;
+function backoffDelay({ attempt, retryAfterHeader }) {
+	const fromHeader = parseRetryAfter(retryAfterHeader);
+	if (fromHeader !== null) return fromHeader;
+	return Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
+}
+function parseRetryAfter(header) {
+	if (!header) return null;
+	const numeric = Number(header);
+	if (Number.isFinite(numeric) && numeric >= 0) return Math.round(numeric * MS_PER_SECOND);
+	const dateMs = Date.parse(header);
+	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
+	return null;
+}
+function sleep(ms, signal) {
+	return setTimeout(ms, void 0, { signal });
+}
+async function runWithRetries(attempt, signal) {
+	let attemptIndex = 0;
+	while (true) {
+		const outcome = await attempt(attemptIndex);
+		if (outcome.kind === "success") return outcome.response;
+		await sleep(outcome.delayMs, signal);
+		attemptIndex += 1;
+	}
+}
+//#endregion
+//#region ../client/src/http/transport.ts
+const UNAUTHORIZED_STATUS = 401;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const OCTET_STREAM_CONTENT_TYPE = "application/octet-stream";
+const TEXT_CONTENT_TYPE_PREFIX = "text/";
+const ERROR_BODY_BYTE_CAP = 64 * 1024;
+const IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+function createTransport(config, options) {
+	const baseUrl = normalizeUrl(config.url);
+	assertCredentialHeaderSafe(config.credential);
+	const fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+	let settledProfile = options.server ?? null;
+	const getServerTag = options.getServerTag ?? (async () => tagOf(settledProfile));
+	const serverSkew = () => settledProfile === null ? null : settledProfile.skew;
+	const refreshCredential = options.refreshCredential;
+	let credential = config.credential;
+	const knownSecrets = new Set(credentialSecrets(credential));
+	const redactionContext = { knownSecrets };
+	let refreshInFlight = null;
+	function tryRefreshCredential() {
+		const refresh = refreshCredential;
+		if (credential.kind !== "oauth" || refresh === void 0) return Promise.resolve(false);
+		refreshInFlight ??= refreshOnce(refresh).finally(() => {
+			refreshInFlight = null;
+		});
+		return refreshInFlight;
+	}
+	async function refreshOnce(refresh) {
+		const next = await refresh();
+		if (next === null) return false;
+		credential = next;
+		for (const secret of credentialSecrets(next)) knownSecrets.add(secret);
+		return true;
+	}
+	async function attemptOnce(prepared, attempt) {
+		const hasRetriesLeft = attempt < prepared.retries;
+		const timeoutSignal = AbortSignal.timeout(prepared.timeoutMs);
+		const combined = combineAborts(timeoutSignal, prepared.cancelSignal);
+		let response;
+		try {
+			response = await fetchImpl(prepared.url, {
+				method: prepared.method,
+				headers: prepared.headers,
+				body: prepared.body,
+				signal: combined
+			});
+		} catch (error) {
+			throwIfAborted(prepared.cancelSignal);
+			const isStaleSocketFirstTry = attempt === 0 && isConnectionClosed(error);
+			if (prepared.idempotent && (hasRetriesLeft || isStaleSocketFirstTry)) return {
+				kind: "retry",
+				delayMs: backoffDelay({ attempt })
+			};
+			if (timeoutSignal.aborted) throw new TimeoutError(`Request timed out after ${prepared.timeoutMs}ms`, {
+				kind: "http",
+				method: prepared.method,
+				url: prepared.url,
+				timeoutMs: prepared.timeoutMs
+			});
+			throw buildNetworkError(error, prepared.method, prepared.url);
+		}
+		const canRetryStatus = hasRetriesLeft && prepared.idempotent;
+		if (!response.ok && isRetryableStatus(response.status) && canRetryStatus) {
+			const retryAfter = response.headers.get("Retry-After");
+			response.body?.cancel().catch(() => void 0);
+			return {
+				kind: "retry",
+				delayMs: backoffDelay({
+					attempt,
+					retryAfterHeader: retryAfter
+				})
+			};
+		}
+		if (!response.ok) {
+			const rawBody = await readBodyForError(response);
+			const serverTag = await getServerTag();
+			throw new HttpError({
+				status: response.status,
+				statusText: response.statusText,
+				method: prepared.method,
+				url: prepared.url,
+				responseHeaders: response.headers,
+				rawBody,
+				serverTag,
+				redactionContext
+			});
+		}
+		assertContentType(response, prepared);
+		return {
+			kind: "success",
+			response
+		};
+	}
+	async function executeRaw(prepared) {
+		try {
+			return await runWithRetries((attempt) => attemptOnce(prepared, attempt), prepared.cancelSignal);
+		} catch (error) {
+			throwIfAborted(prepared.cancelSignal);
+			throw error;
+		}
+	}
+	async function executeWithAuthRefresh(path, opts) {
+		const prepared = prepare(path, opts);
+		try {
+			return {
+				response: await executeRaw(prepared),
+				prepared
+			};
+		} catch (error) {
+			if (error instanceof HttpError && error.status === UNAUTHORIZED_STATUS) {
+				if (await tryRefreshCredential()) {
+					const retried = prepare(path, opts);
+					return {
+						response: await executeRaw(retried),
+						prepared: retried
+					};
+				}
+			}
+			throw error;
+		}
+	}
+	function prepare(path, opts = {}) {
+		const method = opts.method ?? "GET";
+		const expectContentType = opts.expectContentType ?? "json";
+		const url = buildUrl(baseUrl, path, opts.query);
+		const headers = new Headers();
+		const auth = credentialAuthHeader(credential);
+		headers.set(auth.name, auth.value);
+		headers.set("accept", acceptHeader(expectContentType));
+		headers.set("user-agent", options.userAgent);
+		let body = null;
+		if (opts.body !== void 0 && opts.body !== null) if (typeof opts.body === "string" || opts.body instanceof URLSearchParams) body = opts.body;
+		else if (opts.body instanceof FormData || opts.body instanceof ReadableStream) body = opts.body;
+		else if (opts.body instanceof Uint8Array) {
+			body = opts.body;
+			headers.set("content-type", OCTET_STREAM_CONTENT_TYPE);
+		} else {
+			body = JSON.stringify(opts.body);
+			headers.set("content-type", JSON_CONTENT_TYPE);
+		}
+		return {
+			url,
+			method,
+			headers,
+			body,
+			expectContentType,
+			retries: opts.retries ?? 3,
+			idempotent: opts.idempotent ?? IDEMPOTENT_METHODS.has(method),
+			timeoutMs: opts.timeoutMs ?? 3e4,
+			cancelSignal: combineAborts(opts.signal, options.signal)
+		};
+	}
+	let serverProfile = options.server === void 0 ? null : Promise.resolve(options.server);
+	async function server(wait = {}) {
+		throwIfAborted(wait.signal);
+		if (serverProfile === null) {
+			const probe = probeServer(transport).then((info) => {
+				settledProfile = createServerProfile(info);
+				return settledProfile;
+			});
+			probe.catch(() => {
+				serverProfile = null;
+			});
+			serverProfile = probe;
+		}
+		return untilAborted(serverProfile, wait.signal);
+	}
+	const enforceRequirements = options.enforceRequirements ?? true;
+	async function requireFeatures(features, wait = {}) {
+		if (!enforceRequirements || features.length === 0) return;
+		const failure = checkFeatures(features, await server(wait));
+		if (failure !== null) throw new CapabilityError(failure);
+	}
+	async function requireMethod(key, wait = {}) {
+		return requireFeatures(methodRequirements(key), wait);
+	}
+	const transport = {
+		server,
+		require: requireMethod,
+		requireFeatures,
+		async requestRaw(path, opts) {
+			return (await executeWithAuthRefresh(path, opts ?? {})).response;
+		},
+		async requestParsed(schema, path, opts) {
+			const { response, prepared } = await executeWithAuthRefresh(path, {
+				...opts,
+				expectContentType: "json"
+			});
+			return parseJsonResponse(await response.text(), schema, {
+				method: prepared.method,
+				url: prepared.url,
+				status: response.status,
+				getServerTag,
+				serverSkew: serverSkew()
+			});
+		},
+		async requestStream(path, opts) {
+			const { response, prepared } = await executeWithAuthRefresh(path, {
+				...opts,
+				expectContentType: opts?.expectContentType ?? "binary"
+			});
+			if (!response.body) throw new NetworkError("Response had no body to stream", {
+				method: prepared.method,
+				url: prepared.url,
+				cause: "missing body"
+			});
+			return response.body;
+		}
+	};
+	return transport;
+}
+function tagOf(profile) {
+	return profile === null ? null : profile.version.tag;
+}
+function buildUrl(baseUrl, path, query) {
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+	const target = new URL(baseUrl + normalizedPath);
+	if (query) for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const entry of value) target.searchParams.append(key, String(entry));
+		else target.searchParams.append(key, String(value));
+	}
+	return target.toString();
+}
+function acceptHeader(expected) {
+	if (expected === "json") return JSON_CONTENT_TYPE;
+	if (expected === "text") return "text/*";
+	return "*/*";
+}
+function assertContentType(response, prepared) {
+	if (prepared.expectContentType === "binary") return;
+	const contentType = response.headers.get("content-type");
+	if (contentType === null) throwContentTypeMismatch(response, prepared, prepared.expectContentType);
+	if (prepared.expectContentType === "json" && !contentType.includes("application/json")) throwContentTypeMismatch(response, prepared, "json");
+	if (prepared.expectContentType === "text" && !contentType.startsWith(TEXT_CONTENT_TYPE_PREFIX)) throwContentTypeMismatch(response, prepared, "text");
+}
+function throwContentTypeMismatch(response, prepared, expected) {
+	const actual = response.headers.get("content-type") ?? "no content-type";
+	throw new HttpError({
+		status: response.status,
+		statusText: response.statusText,
+		method: prepared.method,
+		url: prepared.url,
+		responseHeaders: response.headers,
+		rawBody: null,
+		overrideUserMessage: `Expected ${expected} response but got ${actual}`
+	});
+}
+async function readBodyForError(response) {
+	try {
+		return Buffer.from(await response.arrayBuffer()).subarray(0, ERROR_BODY_BYTE_CAP).toString("utf8");
+	} catch (error) {
+		return `[body read failed: ${errorMessage(error)}]`;
+	}
+}
+//#endregion
+export { createTransport as n, DEFAULT_TIMEOUT_MS as t };

package/dist/{tree-lMvw1jnZ.mjs → tree-oBEw8hDj.mjs}

@@ -1,6 +1,6 @@
-import { H as connectionFlags, J as profileFlag, U as formatFlags, at as ConfigError, h as writeJson } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
-import { m as CollectionTreeNode } from "./collection-D3KXhvnc.mjs";
+import { U as connectionFlags, W as formatFlags, Y as profileFlag, g as writeJson, ot as ConfigError } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-X6hVzSMW.mjs";
+import { m as CollectionTreeNode } from "./collection-BgPYl2c5.mjs";
 import { z } from "zod";
 //#region src/commands/collection/tree.ts
 const CollectionTreeResponse = z.array(CollectionTreeNode);

package/dist/{unpublish-CYFDd828.mjs → unpublish-BJ9OKN1N.mjs}

@@ -1,6 +1,6 @@
-import { H as connectionFlags, J as profileFlag, p as renderSummary, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
-import { i as tableSelectorFlags, n as parseTableSelectors } from "./table-selector-flags-1bYkAKld.mjs";
+import { J as outputFlags, U as connectionFlags, Y as profileFlag, p as renderSummary } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-X6hVzSMW.mjs";
+import { i as tableSelectorFlags, n as parseTableSelectors } from "./table-selector-flags-BUR0-n6j.mjs";
 import { z } from "zod";
 //#region src/commands/library/unpublish.ts
 const LibraryUnpublishResult = z.object({

package/dist/{unreferenced-8Xdq76Kw.mjs → unreferenced-D6UyA_Nu.mjs}

@@ -1,9 +1,9 @@
-import { G as listFlags, H as connectionFlags, J as profileFlag, X as listEnvelopeSchema, d as renderList, q as outputFlags } from "./cli.mjs";
-import { t as defineMetabaseCommand } from "./runtime-CZ5zh32z.mjs";
-import { t as collectForOutput } from "./window-CI_QD04s.mjs";
-import { d as DependencyNodeCompact } from "./dependency-DKSjKT8P.mjs";
-import { i as dependencyNodeView } from "./dependency-DSxKm9oS.mjs";
-import { a as readItemFilters, n as itemFilterFlags } from "./filter-flags-BYcbB85j.mjs";
+import { J as outputFlags, K as listFlags, U as connectionFlags, Y as profileFlag, Z as listEnvelopeSchema, d as renderList } from "./cli.mjs";
+import { t as defineMetabaseCommand } from "./runtime-X6hVzSMW.mjs";
+import { t as collectForOutput } from "./window-2ybHqui2.mjs";
+import { d as DependencyNodeCompact } from "./dependency-B4J1bwFh.mjs";
+import { i as dependencyNodeView } from "./dependency-BHKwKjhO.mjs";
+import { a as readItemFilters, n as itemFilterFlags } from "./filter-flags-yY4RM312.mjs";
 //#region src/commands/dependency/unreferenced.ts
 const DependencyUnreferencedListEnvelope = listEnvelopeSchema(DependencyNodeCompact);
 var unreferenced_default = defineMetabaseCommand({