better-supabase 0.2.0 → 0.4.0

package/dist/cli/env-BZ0uy8XK.js

@@ -0,0 +1,108 @@
+import { n as CliError } from "./errors-4v4DTtda.js";
+import { g as url, l as pipe, p as string, s as optional } from "./dist-Du7VnEUG.js";
+//#region ../../node_modules/.pnpm/@t3-oss+env-core@0.13.11_arktype@2.2.3_typescript@7.0.2_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/@t3-oss/env-core/dist/standard.js
+function ensureSynchronous(value, message) {
+	if (value instanceof Promise) throw new Error(message);
+}
+function parseWithDictionary(dictionary, value) {
+	const result = {};
+	const issues = [];
+	for (const key in dictionary) {
+		const propResult = dictionary[key]["~standard"].validate(value[key]);
+		ensureSynchronous(propResult, `Validation must be synchronous, but ${key} returned a Promise.`);
+		if (propResult.issues) {
+			issues.push(...propResult.issues.map((issue) => ({
+				...issue,
+				message: issue.message,
+				path: [key, ...issue.path ?? []]
+			})));
+			continue;
+		}
+		result[key] = propResult.value;
+	}
+	if (issues.length) return { issues };
+	return { value: result };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@t3-oss+env-core@0.13.11_arktype@2.2.3_typescript@7.0.2_valibot@1.5.0_typescript@7.0.2__zod@4.6.5/node_modules/@t3-oss/env-core/dist/index.js
+/**
+* Create a new environment variable schema.
+*/
+function createEnv(opts) {
+	const runtimeEnv = opts.runtimeEnvStrict ?? opts.runtimeEnv ?? process.env;
+	if (opts.emptyStringAsUndefined ?? false) {
+		for (const [key, value] of Object.entries(runtimeEnv)) if (value === "") delete runtimeEnv[key];
+	}
+	if (!!opts.skipValidation) {
+		if (opts.extends) for (const preset of opts.extends) preset.skipValidation = true;
+		return runtimeEnv;
+	}
+	const _client = typeof opts.client === "object" ? opts.client : {};
+	const _server = typeof opts.server === "object" ? opts.server : {};
+	const _shared = typeof opts.shared === "object" ? opts.shared : {};
+	const isServer = opts.isServer ?? (typeof window === "undefined" || "Deno" in window);
+	const finalSchemaShape = isServer ? {
+		..._server,
+		..._shared,
+		..._client
+	} : {
+		..._client,
+		..._shared
+	};
+	const parsed = (opts.createFinalSchema?.(finalSchemaShape, isServer))?.["~standard"].validate(runtimeEnv) ?? parseWithDictionary(finalSchemaShape, runtimeEnv);
+	ensureSynchronous(parsed, "Validation must be synchronous");
+	const onValidationError = opts.onValidationError ?? ((issues) => {
+		console.error("❌ Invalid environment variables:", issues);
+		throw new Error("Invalid environment variables");
+	});
+	const onInvalidAccess = opts.onInvalidAccess ?? (() => {
+		throw new Error("❌ Attempted to access a server-side environment variable on the client");
+	});
+	if (parsed.issues) return onValidationError(parsed.issues);
+	const isServerAccess = (prop) => {
+		if (!opts.clientPrefix) return true;
+		return !prop.startsWith(opts.clientPrefix) && !(prop in _shared);
+	};
+	const isValidServerAccess = (prop) => {
+		return isServer || !isServerAccess(prop);
+	};
+	const ignoreProp = (prop) => {
+		return prop === "__esModule" || prop === "$$typeof";
+	};
+	const extendedObj = (opts.extends ?? []).reduce((acc, curr) => {
+		return Object.assign(acc, curr);
+	}, {});
+	const fullObj = Object.assign(extendedObj, parsed.value);
+	return new Proxy(fullObj, { get(target, prop) {
+		if (typeof prop !== "string") return void 0;
+		if (ignoreProp(prop)) return void 0;
+		if (!isValidServerAccess(prop)) return onInvalidAccess(prop);
+		return Reflect.get(target, prop);
+	} });
+}
+//#endregion
+//#region src/cli/env.ts
+const optionalString = optional(string());
+const optionalUrl = optional(pipe(string(), url("must be a URL, e.g. postgresql://user@host/db")));
+/** Parses the variables the CLI reads; an invalid value is a `env_invalid` usage error. */
+function parseEnv(env) {
+	return createEnv({
+		server: {
+			DATABASE_URL: optionalUrl,
+			SUPABASE_ACCESS_TOKEN: optionalString,
+			SUPABASE_API_URL: optionalUrl,
+			SUPABASE_BIN: optionalString,
+			HOME: optionalString,
+			CI: optionalString
+		},
+		runtimeEnv: env,
+		isServer: true,
+		emptyStringAsUndefined: true,
+		onValidationError: (issues) => {
+			const lines = issues.map((issue) => `${issue.path?.map((key) => String(typeof key === "object" ? key.key : key)).join(".") ?? "env"}: ${issue.message}`);
+			throw new CliError("env_invalid", `Invalid environment variable:\n${lines.map((line) => `  ${line}`).join("\n")}`, { issues: lines });
+		}
+	});
+}
+//#endregion
+export { parseEnv };

package/dist/cli/env-jIFUADLY.js

@@ -0,0 +1,511 @@
+import { r as defineCliCommand } from "./command-CK14fP91.js";
+import { r as writeIfChanged, t as display } from "./io-k41_z-jT.js";
+import { r as publicPrefix, t as detectProject } from "./project-B_GeXyHh.js";
+import { basename, delimiter, dirname, normalize, resolve } from "node:path";
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { cwd } from "node:process";
+import l__default from "node:readline";
+import { spawn } from "node:child_process";
+import { pipeline } from "node:stream/promises";
+import { PassThrough } from "node:stream";
+//#region ../../node_modules/.pnpm/tinyexec@1.3.1/node_modules/tinyexec/dist/main.mjs
+const isPathLikePattern = /^path$/i;
+const defaultEnvPathInfo = {
+	key: "PATH",
+	value: ""
+};
+function getPathFromEnv(env) {
+	for (const key in env) {
+		if (!Object.prototype.hasOwnProperty.call(env, key) || !isPathLikePattern.test(key)) continue;
+		const value = env[key];
+		if (!value) return defaultEnvPathInfo;
+		return {
+			key,
+			value
+		};
+	}
+	return defaultEnvPathInfo;
+}
+function addNodeBinToPath(cwd, path) {
+	const parts = path.value.split(delimiter);
+	const nodeBinPaths = [];
+	let currentPath = typeof cwd === "string" ? cwd : fileURLToPath(cwd, { windows: false });
+	let lastPath;
+	do {
+		nodeBinPaths.push(resolve(currentPath, "node_modules", ".bin"));
+		lastPath = currentPath;
+		currentPath = dirname(currentPath);
+	} while (currentPath !== lastPath);
+	nodeBinPaths.push(dirname(process.execPath));
+	const newPath = nodeBinPaths.concat(parts).join(delimiter);
+	return {
+		key: path.key,
+		value: newPath
+	};
+}
+function computeEnv(cwd, env, nodePath = true) {
+	const envWithDefault = {
+		...process.env,
+		...env
+	};
+	if (!nodePath) return envWithDefault;
+	const envPathInfo = addNodeBinToPath(cwd, getPathFromEnv(envWithDefault));
+	envWithDefault[envPathInfo.key] = envPathInfo.value;
+	return envWithDefault;
+}
+const combineStreams = (streams) => {
+	let streamCount = streams.length;
+	const combined = new PassThrough();
+	const maybeEmitEnd = () => {
+		if (--streamCount === 0) combined.end();
+	};
+	for (const stream of streams) pipeline(stream, combined, { end: false }).then(maybeEmitEnd).catch(maybeEmitEnd);
+	return combined;
+};
+const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+const shebangRegExp = /^#!\s*(.+)/;
+const isWindowsExecutableRegExp = /\.(?:com|exe)$/i;
+const isNodeModulesCmdRegExp = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+const isWindows = process.platform === "win32";
+const defaultPathExt = [
+	".EXE",
+	".CMD",
+	".BAT",
+	".COM"
+];
+const noPathExt = [""];
+/**
+* Normalizes the command and arguments to work cross-platform.
+* On Windows, this basically handles things like shebangs, calling
+* `node_modules/.bin` commands, and escaping meta characters.
+* On other platforms, it just returns the command and arguments as-is.
+*/
+function normalizeSpawnCommand(command, args = [], options = {}) {
+	if (options.shell === true || !isWindows) return {
+		command,
+		args,
+		options
+	};
+	let file = resolveCommand(command, options);
+	let shebang = null;
+	if (file !== null) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd = null;
+		try {
+			fd = openSync(file, "r");
+			readSync(fd, buffer, 0, size, 0);
+		} catch {} finally {
+			if (fd !== null) closeSync(fd);
+		}
+		const match = buffer.toString().match(shebangRegExp);
+		if (match !== null) {
+			const line = match[1].trim();
+			const separatorIndex = line.indexOf(" ");
+			const path = separatorIndex !== -1 ? line.slice(0, separatorIndex) : line;
+			const argument = separatorIndex !== -1 ? line.slice(separatorIndex + 1) : "";
+			const binary = basename(path);
+			shebang = binary === "env" ? argument || null : binary;
+		}
+	}
+	if (shebang !== null && file !== null) {
+		args = [file, ...args];
+		command = shebang;
+		file = resolveCommand(command, options);
+	}
+	if (file === null || !isWindowsExecutableRegExp.test(file)) {
+		const needsDoubleEscapeMetaChars = file !== null && isNodeModulesCmdRegExp.test(file);
+		command = normalize(command);
+		command = command.replace(metaCharsRegExp, "^$1");
+		args = args.map((arg) => {
+			arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+			arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+			arg = `"${arg}"`;
+			arg = arg.replace(metaCharsRegExp, "^$1");
+			if (needsDoubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+			return arg;
+		});
+		args = [
+			"/d",
+			"/s",
+			"/c",
+			`"${[command, ...args].join(" ")}"`
+		];
+		command = options.env?.comspec ?? "cmd.exe";
+		options = {
+			...options,
+			windowsVerbatimArguments: true
+		};
+	}
+	return {
+		command,
+		args,
+		options
+	};
+}
+/**
+* Resolves the command to an absolute path if possible.
+* Handles things like traversing PATH and adding extensions from PATHEXT
+*/
+function resolveCommand(command, options) {
+	const cwd$3 = (options.cwd ?? cwd()).toString();
+	const env = options.env ?? process.env;
+	const PATH = getPathFromEnv(env).value;
+	const pathEnv = command.includes("/") || command.includes("\\") ? [""] : [cwd$3, ...PATH.split(delimiter)];
+	let pathExt = env.PATHEXT ? env.PATHEXT.split(delimiter) : defaultPathExt;
+	if (command.includes(".") && pathExt[0] !== "") pathExt = ["", ...pathExt];
+	for (const extensions of [pathExt, noPathExt]) for (const path of pathEnv) {
+		const unquoted = path.startsWith("\"") && path.endsWith("\"") && path.length > 1 ? path.slice(1, -1) : path;
+		const dest = resolve(cwd$3, unquoted, command);
+		for (const ext of extensions) {
+			const destWithExt = dest + ext;
+			try {
+				if (statSync(destWithExt).isFile()) return destWithExt;
+			} catch {}
+		}
+	}
+	return null;
+}
+var NonZeroExitError = class extends Error {
+	result;
+	output;
+	exitCode;
+	get signalCode() {
+		return this.result.signalCode;
+	}
+	constructor(result, output, command, args) {
+		let target = "The process";
+		if (command) target = `The command \`${args?.length ? `${command} ${args.map((a) => /[ "'`()]/.test(a) ? JSON.stringify(a) : a).join(" ")}` : command}\``;
+		const exitCode = result.exitCode ?? 1;
+		super(result.signalCode !== null ? `${target} was killed by the signal ${result.signalCode}` : `${target} exited with a non-zero status (${exitCode})`);
+		this.result = result;
+		this.output = output;
+		this.exitCode = exitCode;
+		Object.defineProperty(this, "result", {
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+};
+const defaultOptions = {
+	timeout: void 0,
+	persist: false
+};
+const defaultNodeOptions = { windowsHide: true };
+function combineSignals(signals) {
+	const controller = new AbortController();
+	for (const signal of signals) {
+		if (signal.aborted) {
+			controller.abort();
+			return signal;
+		}
+		const onAbort = () => {
+			controller.abort(signal.reason);
+		};
+		signal.addEventListener("abort", onAbort, { signal: controller.signal });
+	}
+	return controller.signal;
+}
+async function readStream(stream) {
+	let output = "";
+	try {
+		for await (const chunk of stream) output += chunk.toString();
+	} catch {}
+	return output;
+}
+var ExecProcess = class {
+	_process;
+	_aborted = false;
+	_options;
+	_command;
+	_args;
+	_resolveClose;
+	_processClosed;
+	_thrownError;
+	get process() {
+		return this._process;
+	}
+	get pid() {
+		return this._process?.pid;
+	}
+	get exitCode() {
+		if (this._process && this._process.exitCode !== null) return this._process.exitCode;
+	}
+	get signalCode() {
+		return this._process?.signalCode ?? null;
+	}
+	constructor(command, args, options) {
+		this._options = {
+			...defaultOptions,
+			...options
+		};
+		this._command = command;
+		this._args = args ?? [];
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
+		});
+	}
+	kill(signal) {
+		return this._process?.kill(signal) === true;
+	}
+	get aborted() {
+		return this._aborted;
+	}
+	get killed() {
+		return this._process?.killed === true;
+	}
+	pipe(command, args, options) {
+		return exec$1(command, args, {
+			...options,
+			stdin: this
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		const proc = this._process;
+		if (!proc) return;
+		const streams = [];
+		if (this._streamErr) streams.push(this._streamErr);
+		if (this._streamOut) streams.push(this._streamOut);
+		const streamCombined = combineStreams(streams);
+		const rl = l__default.createInterface({ input: streamCombined });
+		for await (const chunk of rl) yield chunk.toString();
+		await this._processClosed;
+		proc.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		if (this._options?.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, void 0, this._command, this._args);
+	}
+	async _waitForOutput() {
+		const proc = this._process;
+		if (!proc) throw new Error("No process was started");
+		const [stdout, stderr] = await Promise.all([this._streamOut ? readStream(this._streamOut) : "", this._streamErr ? readStream(this._streamErr) : ""]);
+		await this._processClosed;
+		const { stdin } = this._options;
+		if (stdin && typeof stdin !== "string") await stdin;
+		proc.removeAllListeners();
+		if (this._thrownError) throw this._thrownError;
+		const result = {
+			stderr,
+			stdout,
+			exitCode: this.exitCode
+		};
+		if (this._options.throwOnError && (this.exitCode !== 0 && this.exitCode !== void 0 || this.signalCode !== null)) throw new NonZeroExitError(this, result, this._command, this._args);
+		return result;
+	}
+	then(onfulfilled, onrejected) {
+		return this._waitForOutput().then(onfulfilled, onrejected);
+	}
+	_streamOut;
+	_streamErr;
+	spawn() {
+		const options = this._options;
+		const nodeOptions = {
+			...defaultNodeOptions,
+			...options.nodeOptions
+		};
+		const cwd$1 = nodeOptions?.cwd ?? cwd();
+		const signals = [];
+		this._resetState();
+		if (options.timeout !== void 0) signals.push(AbortSignal.timeout(options.timeout));
+		if (options.signal !== void 0) signals.push(options.signal);
+		if (options.persist === true) nodeOptions.detached = true;
+		if (signals.length > 0) nodeOptions.signal = combineSignals(signals);
+		nodeOptions.env = computeEnv(cwd$1, nodeOptions.env, options.nodePath);
+		const crossResult = normalizeSpawnCommand(this._command, this._args, nodeOptions);
+		const handle = spawn(crossResult.command, crossResult.args, crossResult.options);
+		if (handle.stderr) this._streamErr = handle.stderr;
+		if (handle.stdout) this._streamOut = handle.stdout;
+		this._process = handle;
+		handle.once("error", this._onError);
+		handle.once("close", this._onClose);
+		if (handle.stdin) {
+			const { stdin } = options;
+			if (typeof stdin === "string") handle.stdin.end(stdin);
+			else stdin?.process?.stdout?.pipe(handle.stdin);
+		}
+	}
+	_resetState() {
+		this._aborted = false;
+		this._processClosed = new Promise((resolve) => {
+			this._resolveClose = resolve;
+		});
+		this._thrownError = void 0;
+	}
+	_onError = (err) => {
+		if (err.name === "AbortError" && (!(err.cause instanceof Error) || err.cause.name !== "TimeoutError")) {
+			this._aborted = true;
+			return;
+		}
+		this._thrownError = err;
+	};
+	_onClose = () => {
+		if (this._resolveClose) this._resolveClose();
+	};
+};
+const x = (command, args, userOptions) => {
+	const proc = new ExecProcess(command, args, userOptions);
+	proc.spawn();
+	return proc;
+};
+const exec$1 = x;
+//#endregion
+//#region src/cli/exec.ts
+async function exec(command, args, cwd) {
+	try {
+		const result = await x(command, [...args], {
+			nodeOptions: {
+				cwd,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			},
+			throwOnError: false
+		});
+		return {
+			code: result.exitCode ?? 1,
+			stdout: result.stdout,
+			stderr: result.stderr
+		};
+	} catch (error) {
+		return {
+			code: 127,
+			stdout: "",
+			stderr: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/** Runs the Supabase CLI: `$SUPABASE_BIN`, then `supabase`, then `npx supabase`. */
+async function supabaseCli(args, cwd, env) {
+	const result = await exec(env.SUPABASE_BIN ?? "supabase", args, cwd);
+	if (result.code !== 127) return result;
+	return exec("npx", [
+		"--yes",
+		"supabase",
+		...args
+	], cwd);
+}
+//#endregion
+//#region src/cli/commands/env.ts
+const ARGS = {
+	out: {
+		type: "string",
+		description: "Env file to write. Defaults to .env.local",
+		valueHint: "file"
+	},
+	prefix: {
+		type: "string",
+		description: "Prefix for browser variables, detected from your framework; \"none\" for no prefix",
+		valueHint: "prefix"
+	},
+	from: {
+		type: "string",
+		description: "Read `supabase status -o json` output from a file",
+		valueHint: "file"
+	},
+	print: {
+		type: "boolean",
+		description: "Print the variables instead of writing them"
+	}
+};
+async function readStatus(config, args, env) {
+	const from = args.from;
+	if (from) return JSON.parse(await readFile(resolve(config.root, from), "utf8"));
+	let result = await supabaseCli([
+		"status",
+		"-o",
+		"json"
+	], config.root, env);
+	if (result.code !== 0) {
+		const native = await supabaseCli([
+			"status",
+			"--env",
+			"--output-format",
+			"json"
+		], config.root, env);
+		if (native.code === 0) result = native;
+	}
+	if (result.code !== 0) throw new Error(`supabase status failed (${result.code}). Is the local stack running (supabase start)?`);
+	const start = result.stdout.indexOf("{");
+	if (start === -1) throw new Error("supabase status printed no JSON.");
+	return JSON.parse(result.stdout.slice(start));
+}
+const text = (status, ...keys) => {
+	for (const key of keys) {
+		const value = status[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+};
+/** Replaces `KEY=` lines in place and appends the rest under a header. */
+function mergeEnv(current, values) {
+	const pending = new Map(Object.entries(values));
+	const merged = (current.length > 0 ? current.replace(/\n$/, "").split("\n") : []).map((line) => {
+		const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
+		if (!key || !pending.has(key)) return line;
+		const value = pending.get(key);
+		pending.delete(key);
+		return `${key}=${value}`;
+	});
+	if (pending.size > 0) {
+		if (merged.length > 0 && merged.at(-1) !== "") merged.push("");
+		merged.push("# Local Supabase stack (better-supabase env)");
+		for (const [key, value] of pending) merged.push(`${key}=${value}`);
+	}
+	return `${merged.join("\n")}\n`;
+}
+async function runEnv(config, args, env) {
+	const status = await readStatus(config, args, env);
+	const project = await detectProject(config.root);
+	const prefixFlag = args.prefix;
+	const prefix = prefixFlag === void 0 ? publicPrefix(project) : prefixFlag === "none" ? "" : prefixFlag;
+	const url = text(status, "API_URL");
+	const publishableKey = text(status, "PUBLISHABLE_KEY", "ANON_KEY");
+	const secretKey = text(status, "SECRET_KEY", "SERVICE_ROLE_KEY");
+	if (!url || !publishableKey) return {
+		code: 1,
+		error: "supabase status has no API_URL or publishable key. Is the stack running?"
+	};
+	const values = {
+		[`${prefix}SUPABASE_URL`]: url,
+		[`${prefix}SUPABASE_PUBLISHABLE_KEY`]: publishableKey
+	};
+	if (secretKey) values["SUPABASE_SECRET_KEY"] = secretKey;
+	const dbUrl = text(status, "DB_URL");
+	if (dbUrl) values["SUPABASE_DB_URL"] = dbUrl;
+	const jwtSecret = text(status, "JWT_SECRET");
+	if (jwtSecret) values["SUPABASE_JWT_SECRET"] = jwtSecret;
+	if (args.print === true) return {
+		code: 0,
+		output: Object.entries(values).map(([key, value]) => `${key}=${value}`).join("\n")
+	};
+	const out = args.out ?? ".env.local";
+	const path = resolve(config.root, out);
+	const current = existsSync(path) ? await readFile(path, "utf8") : "";
+	const lines = [`${await writeIfChanged(path, mergeEnv(current, values)) ? "Wrote" : "Unchanged"} ${display(config.root, out)}: ${Object.keys(values).join(", ")}`];
+	if (!text(status, "PUBLISHABLE_KEY")) lines.push("Warning: this Supabase CLI prints only legacy JWT keys. Upgrade it to get sb_publishable_/sb_secret_ keys.");
+	const gitignore = resolve(config.root, ".gitignore");
+	if (!(existsSync(gitignore) && (await readFile(gitignore, "utf8")).split("\n").some((line) => [
+		out,
+		`/${out}`,
+		".env*",
+		".env*.local",
+		"*.local"
+	].includes(line.trim())))) lines.push(`Warning: add ${out} to .gitignore; it contains the secret key.`);
+	return {
+		code: 0,
+		output: lines.join("\n")
+	};
+}
+const envCommand = defineCliCommand({
+	meta: {
+		name: "env",
+		description: "Writes the local stack's URL and keys from `supabase status` to an env file, keeping its other lines"
+	},
+	args: ARGS,
+	run: (args, { config, env }) => runEnv(config, args, env)
+});
+//#endregion
+export { envCommand };

package/dist/cli/errors-4v4DTtda.js

@@ -0,0 +1,56 @@
+//#region src/cli/errors.ts
+/** Each code has a heading on this page, so `type` links to its explanation. */
+const CLI_ERRORS_URL = "https://bettersupabase.com/docs/cli/errors";
+const TITLES = {
+	usage: "Invalid arguments",
+	unknown_command: "Unknown command",
+	missing_value: "Missing value",
+	config_not_found: "Config file not found",
+	config_invalid: "Invalid config",
+	env_invalid: "Invalid environment variable",
+	failed: "Command failed",
+	internal: "Unexpected error"
+};
+const EXIT_CODES = {
+	usage: 2,
+	unknown_command: 2,
+	missing_value: 2,
+	config_not_found: 2,
+	config_invalid: 2,
+	env_invalid: 2,
+	failed: 1,
+	internal: 1
+};
+/** An error the CLI reports as text, or as Problem Details under `--json`. */
+var CliError = class extends Error {
+	name = "CliError";
+	code;
+	exitCode;
+	problem;
+	constructor(code, message, options = {}) {
+		super(message, options.cause === void 0 ? {} : { cause: options.cause });
+		const { exitCode = EXIT_CODES[code], cause: _cause, ...extensions } = options;
+		this.code = code;
+		this.exitCode = exitCode;
+		this.problem = {
+			type: `${CLI_ERRORS_URL}#${code}`,
+			title: TITLES[code],
+			detail: message,
+			code,
+			exitCode,
+			...extensions
+		};
+	}
+};
+/** citty's own argument errors. */
+function isCittyUsageError(cause) {
+	return cause instanceof Error && cause.name === "CLIError";
+}
+/** Any thrown value as a `CliError`: citty's argument errors become `usage`, the rest `internal`. */
+function toCliError(cause) {
+	if (cause instanceof CliError) return cause;
+	if (isCittyUsageError(cause)) return new CliError("usage", cause.message);
+	return new CliError("internal", cause instanceof Error ? cause.message : String(cause), { cause });
+}
+//#endregion
+export { CliError as n, toCliError as r, CLI_ERRORS_URL as t };