better-supabase 0.8.0 → 0.10.0

package/dist/cli/config-Bi_UBxXl.js

@@ -0,0 +1,1451 @@
+import { n as CliError } from "./errors-Caiz_0so.js";
+import { i as readStdin, t as display } from "./io-BiPX-_J1.js";
+import { c as resolve$1, i as extname$1, n as basename$1, o as join$1, r as dirname$1, s as normalize$1, t as resolveModulePath } from "./dist-DuiMMRbJ.js";
+import { A as string, C as picklist, D as regex, E as record, M as unknown, O as safeParse, S as optional, T as rawCheck, _ as minValue, a as array, c as exactOptional, f as lazy, g as minLength, h as maxValue, j as union, k as strictObject, l as getDotPath, m as maxLength, o as boolean, p as literal, s as custom, u as integer, v as nullable, w as pipe, x as objectWithRest, y as number } from "./env-Cf5OTqbK.js";
+import { n as INTEGRATIONS, t as GEN_TASKS } from "./names-D6LrQnOv.js";
+import { t as importFresh } from "./fresh-import-BeYf9I3x.js";
+import { n as readStackStatus } from "./stack-status-LeEoCtV1.js";
+import { d as readSupabaseToml, g as tomlNumber, s as findUp } from "./supabase-toml-DjLgBYEo.js";
+import * as nodeUtil from "node:util";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { readFile, rm } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { SCOPE_ID_TYPES, scopeProblems } from "better-supabase/sql";
+import { APP_COLUMN_ACCESS, APP_COLUMN_FORMATS, APP_COLUMN_TYPES, APP_ON_DELETE_ACTIONS, APP_ROLLUP_AGGREGATES, APP_TABLE_EVENT_KINDS, SKILLS_AGENTS, providerApiProblem, resolveConfig } from "better-supabase/config";
+import { homedir } from "node:os";
+//#region ../../node_modules/.pnpm/rc9@3.1.0/node_modules/rc9/dist/_chunks/libs/flat.mjs
+function isBuffer(obj) {
+	return obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+}
+function keyIdentity(key) {
+	return key;
+}
+function flatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const maxDepth = opts.maxDepth;
+	const transformKey = opts.transformKey || keyIdentity;
+	const output = {};
+	function step(object, prev, currentDepth) {
+		currentDepth = currentDepth || 1;
+		Object.keys(object).forEach(function(key) {
+			const value = object[key];
+			const isarray = opts.safe && Array.isArray(value);
+			const type = Object.prototype.toString.call(value);
+			const isbuffer = isBuffer(value);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			const newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+			if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+			output[newKey] = value;
+		});
+	}
+	step(target);
+	return output;
+}
+function unflatten(target, opts) {
+	opts = opts || {};
+	const delimiter = opts.delimiter || ".";
+	const overwrite = opts.overwrite || false;
+	const transformKey = opts.transformKey || keyIdentity;
+	const result = {};
+	if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") return target;
+	function getkey(key) {
+		const parsedKey = Number(key);
+		return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+	}
+	function addKeys(keyPrefix, recipient, target) {
+		return Object.keys(target).reduce(function(result, key) {
+			result[keyPrefix + delimiter + key] = target[key];
+			return result;
+		}, recipient);
+	}
+	function isEmpty(val) {
+		const type = Object.prototype.toString.call(val);
+		const isArray = type === "[object Array]";
+		const isObject = type === "[object Object]";
+		if (!val) return true;
+		else if (isArray) return !val.length;
+		else if (isObject) return !Object.keys(val).length;
+	}
+	target = Object.keys(target).reduce(function(result, key) {
+		const type = Object.prototype.toString.call(target[key]);
+		if (!(type === "[object Object]" || type === "[object Array]") || isEmpty(target[key])) {
+			result[key] = target[key];
+			return result;
+		} else return addKeys(key, result, flatten(target[key], opts));
+	}, {});
+	Object.keys(target).forEach(function(key) {
+		const split = key.split(delimiter).map(transformKey);
+		let key1 = getkey(split.shift());
+		let key2 = getkey(split[0]);
+		let recipient = result;
+		while (key2 !== void 0) {
+			if (key1 === "__proto__") return;
+			const type = Object.prototype.toString.call(recipient[key1]);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+			if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") return;
+			if (overwrite && !isobject || !overwrite && recipient[key1] == null) recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+			recipient = recipient[key1];
+			if (split.length > 0) {
+				key1 = getkey(split.shift());
+				key2 = getkey(split[0]);
+			}
+		}
+		recipient[key1] = unflatten(target[key], opts);
+	});
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/destr@2.0.5/node_modules/destr/dist/index.mjs
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+	if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+		warnKeyDropped(key);
+		return;
+	}
+	return value;
+}
+function warnKeyDropped(key) {
+	console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+	if (typeof value !== "string") return value;
+	if (value[0] === "\"" && value[value.length - 1] === "\"" && value.indexOf("\\") === -1) return value.slice(1, -1);
+	const _value = value.trim();
+	if (_value.length <= 9) switch (_value.toLowerCase()) {
+		case "true": return true;
+		case "false": return false;
+		case "undefined": return;
+		case "null": return null;
+		case "nan": return NaN;
+		case "infinity": return Number.POSITIVE_INFINITY;
+		case "-infinity": return Number.NEGATIVE_INFINITY;
+	}
+	if (!JsonSigRx.test(value)) {
+		if (options.strict) throw new SyntaxError("[destr] Invalid JSON");
+		return value;
+	}
+	try {
+		if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+			if (options.strict) throw new Error("[destr] Possible prototype pollution");
+			return JSON.parse(value, jsonParseTransform);
+		}
+		return JSON.parse(value);
+	} catch (error) {
+		if (options.strict) throw error;
+		return value;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/defu@6.1.7/node_modules/defu/dist/defu.mjs
+function isPlainObject$1(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) return false;
+	if (Symbol.iterator in value) return false;
+	if (Symbol.toStringTag in value) return Object.prototype.toString.call(value) === "[object Module]";
+	return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+	if (!isPlainObject$1(defaults)) return _defu(baseObject, {}, namespace, merger);
+	const object = { ...defaults };
+	for (const key of Object.keys(baseObject)) {
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = baseObject[key];
+		if (value === null || value === void 0) continue;
+		if (merger && merger(object, key, value, namespace)) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (isPlainObject$1(value) && isPlainObject$1(object[key])) object[key] = _defu(value, object[key], (namespace ? `${namespace}.` : "") + key.toString(), merger);
+		else object[key] = value;
+	}
+	return object;
+}
+function createDefu(merger) {
+	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
+}
+const defu = createDefu();
+//#endregion
+//#region ../../node_modules/.pnpm/rc9@3.1.0/node_modules/rc9/dist/index.mjs
+const RE_KEY_VAL = /^\s*([^\s=]+)\s*=\s*(.*)?\s*$/;
+const RE_LINES = /\n|\r|\r\n/;
+const defaults = {
+	name: ".conf",
+	dir: process.cwd(),
+	flat: false
+};
+function withDefaults(options) {
+	if (typeof options === "string") options = { name: options };
+	return {
+		...defaults,
+		...options
+	};
+}
+function parse(contents, options = {}) {
+	const config = {};
+	const lines = contents.split(RE_LINES);
+	for (const line of lines) {
+		const match = line.match(RE_KEY_VAL);
+		if (!match) continue;
+		const key = match[1];
+		if (!key || key === "__proto__" || key === "constructor") continue;
+		const value = destr((match[2] || "").trim());
+		if (key.endsWith("[]")) {
+			const nkey = key.slice(0, Math.max(0, key.length - 2));
+			config[nkey] = (config[nkey] || []).concat(value);
+			continue;
+		}
+		config[key] = value;
+	}
+	return options.flat ? config : unflatten(config, { overwrite: true });
+}
+function parseFile(path, options) {
+	if (!existsSync(path)) return {};
+	return parse(readFileSync(path, "utf8"), options);
+}
+function read(options) {
+	options = withDefaults(options);
+	return parseFile(resolve(options.dir, options.name), options);
+}
+function userConfigDir() {
+	return process.env.XDG_CONFIG_HOME || resolve(homedir(), ".config");
+}
+function readUserConfig(options) {
+	options = withDefaults(options);
+	options.dir = userConfigDir();
+	return read(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/c12@4.0.0-rc.2_dotenv@17.4.2_giget@3.3.1_jiti@2.7.0_magicast@0.5.5/node_modules/c12/dist/index.mjs
+async function setupDotenv(options) {
+	const targetEnvironment = options.env ?? process.env;
+	const environment = await loadDotenv({
+		cwd: options.cwd,
+		fileName: options.fileName ?? ".env",
+		env: targetEnvironment,
+		interpolate: options.interpolate ?? true,
+		expandFileReferences: options.expandFileReferences ?? false,
+		parse: options.parse
+	});
+	const dotenvVars = getDotEnvVars(targetEnvironment);
+	for (const key in environment) {
+		if (key.startsWith("_")) continue;
+		if (targetEnvironment[key] === void 0 || dotenvVars.has(key)) targetEnvironment[key] = environment[key];
+	}
+	return environment;
+}
+async function loadDotenv(options) {
+	const environment = Object.create(null);
+	const cwd = resolve$1(options.cwd || ".");
+	const _fileName = options.fileName || ".env";
+	const dotenvFiles = typeof _fileName === "string" ? [_fileName] : _fileName;
+	const dotenvVars = getDotEnvVars(options.env || {});
+	Object.assign(environment, options.env);
+	for (const file of dotenvFiles) {
+		const dotenvFile = resolve$1(cwd, file);
+		if (!statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) continue;
+		const parsed = await readEnvFile(dotenvFile, options.parse);
+		for (const key in parsed) {
+			if (key in environment && !dotenvVars.has(key)) continue;
+			environment[key] = parsed[key];
+			dotenvVars.add(key);
+		}
+	}
+	if (options.expandFileReferences) {
+		for (const key in environment) if (key.endsWith("_FILE")) {
+			const targetKey = key.slice(0, -5);
+			if (environment[targetKey] === void 0) {
+				const filePath = environment[key];
+				if (filePath && statSync(filePath, { throwIfNoEntry: false })?.isFile()) {
+					environment[targetKey] = readFileSync(filePath, "utf8").trim();
+					dotenvVars.add(targetKey);
+				}
+			}
+		}
+	}
+	if (options.interpolate) interpolate(environment);
+	return environment;
+}
+let _parseEnv = nodeUtil.parseEnv;
+async function readEnvFile(path, parse) {
+	const src = readFileSync(path, "utf8");
+	if (parse) return parse(src);
+	if (!_parseEnv) try {
+		const dotenv = await import("dotenv");
+		_parseEnv = (src) => dotenv.parse(src);
+	} catch {
+		throw new Error("Failed to parse .env file: `node:util.parseEnv` is not available and `dotenv` package is not installed. Please upgrade your runtime, install `dotenv` as a dependency or provide a custom `parse` option.");
+	}
+	return _parseEnv(src);
+}
+function interpolate(target, source = {}, parse = (v) => v) {
+	function getValue(key) {
+		return source[key] === void 0 ? target[key] : source[key];
+	}
+	function interpolate(value, parents = []) {
+		if (typeof value !== "string") return value;
+		let result = "";
+		let index = 0;
+		while (index < value.length) {
+			const char = value[index];
+			if (char === "\\" && value[index + 1] === "$") {
+				result += "$";
+				index += 2;
+				continue;
+			}
+			const ref = char === "$" ? parseRef(value, index) : void 0;
+			if (!ref) {
+				result += char;
+				index++;
+				continue;
+			}
+			if (parents.includes(ref.key)) {
+				if (ref.defaultValue !== void 0) {
+					result += interpolate(ref.defaultValue, parents);
+					index = ref.end;
+					continue;
+				}
+				console.warn(`Please avoid recursive environment variables ( loop: ${parents.join(" > ")} > ${ref.key} )`);
+				return "";
+			}
+			let resolved = interpolate(getValue(ref.key), [...parents, ref.key]);
+			if (ref.defaultValue !== void 0 && (resolved === void 0 || ref.operator === ":-" && resolved === "")) resolved = interpolate(ref.defaultValue, parents);
+			result += resolved === void 0 ? value.slice(index, ref.end) : resolved;
+			index = ref.end;
+		}
+		return parse(result);
+	}
+	for (const key in target) target[key] = interpolate(getValue(key));
+}
+const REF_NAME_RE = /\w+/y;
+const BRACED_REF_NAME_RE = /[\w:]+/y;
+function parseRef(input, start) {
+	let index = start + 1;
+	const braced = input[index] === "{";
+	if (braced) index++;
+	const nameRe = braced ? BRACED_REF_NAME_RE : REF_NAME_RE;
+	nameRe.lastIndex = index;
+	const name = nameRe.exec(input);
+	if (!name) return;
+	let key = name[0];
+	index = nameRe.lastIndex;
+	if (!braced) return {
+		key,
+		end: index
+	};
+	if (input[index] === "}") return {
+		key,
+		end: index + 1
+	};
+	if (input[index] === "-") {
+		let operator = "-";
+		if (key.endsWith(":")) {
+			key = key.slice(0, -1);
+			operator = ":-";
+		}
+		const defaultValue = key ? readDefault(input, index + 1) : void 0;
+		if (!defaultValue) return;
+		return {
+			key,
+			operator,
+			defaultValue: defaultValue.value,
+			end: defaultValue.end
+		};
+	}
+	return {
+		key,
+		end: index
+	};
+}
+function readDefault(input, start) {
+	let value = "";
+	let depth = 1;
+	for (let index = start; index < input.length; index++) {
+		const char = input[index];
+		if (char === "\\" && index + 1 < input.length) {
+			const next = input[index + 1];
+			value += next === "{" || next === "}" ? next : char + next;
+			index++;
+			continue;
+		}
+		if (char === "$" && input[index + 1] === "{") {
+			depth++;
+			value += "${";
+			index++;
+			continue;
+		}
+		if (char === "{") depth++;
+		if (char === "}") {
+			depth--;
+			if (depth === 0) return {
+				value,
+				end: index + 1
+			};
+		}
+		value += char;
+	}
+}
+function getDotEnvVars(targetEnvironment) {
+	const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map();
+	if (!globalRegistry.has(targetEnvironment)) globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set());
+	return globalRegistry.get(targetEnvironment);
+}
+const _normalize = (p) => p?.replace(/\\/g, "/");
+let importCounter = 0;
+const ASYNC_LOADERS = {
+	".json": () => JSON.parse,
+	".yaml": () => import("./yaml-CYCbJ6et.js").then((r) => r.parseYAML),
+	".yml": () => import("./yaml-CYCbJ6et.js").then((r) => r.parseYAML),
+	".jsonc": () => import("./jsonc-C8M0EhHB.js").then((r) => (source) => r.parseJSONC(source, { allowTrailingComma: true })),
+	".json5": () => import("./json5-ChRycquj.js").then((r) => r.parseJSON5),
+	".toml": () => import("./toml-DB-MNnFs.js").then((r) => r.parseTOML)
+};
+const SUPPORTED_EXTENSIONS = Object.freeze([
+	".js",
+	".ts",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts",
+	".json",
+	".jsonc",
+	".json5",
+	".yaml",
+	".yml",
+	".toml"
+]);
+async function loadConfig$1(options) {
+	options.cwd = resolve$1(process.cwd(), options.cwd || ".");
+	options.name = options.name || "config";
+	options.envName = options.envName ?? process.env.NODE_ENV;
+	options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+	options.rcFile = options.rcFile ?? `.${options.name}rc`;
+	if (options.extend !== false) options.extend = {
+		extendKey: "extends",
+		...options.extend
+	};
+	const _merger = options.merger || defu;
+	const r = {
+		config: {},
+		cwd: options.cwd,
+		configFile: resolve$1(options.cwd, options.configFile),
+		layers: [],
+		_configFile: void 0
+	};
+	const rawConfigs = {
+		overrides: options.overrides,
+		main: void 0,
+		rc: void 0,
+		packageJson: void 0,
+		defaultConfig: options.defaultConfig
+	};
+	if (options.dotenv) await setupDotenv({
+		cwd: options.cwd,
+		...options.dotenv === true ? {} : options.dotenv
+	});
+	const _mainConfig = await resolveConfig$1(".", options);
+	if (_mainConfig.configFile) {
+		rawConfigs.main = _mainConfig.config;
+		r.configFile = _mainConfig.configFile;
+		r._configFile = _mainConfig._configFile;
+	}
+	if (_mainConfig.meta) r.meta = _mainConfig.meta;
+	if (options.rcFile) {
+		const rcSources = [];
+		rcSources.push(read({
+			name: options.rcFile,
+			dir: options.cwd
+		}));
+		if (options.globalRc) {
+			const { findWorkspaceDir } = await import("./dist-D_VbPAMR.js");
+			const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {});
+			if (workspaceDir) rcSources.push(read({
+				name: options.rcFile,
+				dir: workspaceDir
+			}));
+			rcSources.push(readUserConfig({ name: options.rcFile }));
+			rcSources.push(read({
+				name: options.rcFile,
+				dir: homedir()
+			}));
+		}
+		rawConfigs.rc = _merger({}, ...rcSources);
+	}
+	if (options.packageJson) {
+		const keys = (Array.isArray(options.packageJson) ? options.packageJson : [typeof options.packageJson === "string" ? options.packageJson : options.name]).filter((t) => t && typeof t === "string");
+		const { readPackageJSON } = await import("./dist-D_VbPAMR.js");
+		const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {});
+		rawConfigs.packageJson = _merger({}, ...keys.map((key) => pkgJsonFile?.[key]));
+	}
+	const configs = {};
+	for (const key in rawConfigs) {
+		const value = rawConfigs[key];
+		configs[key] = await (typeof value === "function" ? value({
+			configs,
+			rawConfigs
+		}) : value);
+	}
+	if (Array.isArray(configs.main)) r.config = configs.main;
+	else {
+		r.config = _merger(configs.overrides, configs.main, configs.rc, configs.packageJson, configs.defaultConfig);
+		if (options.extend) {
+			await extendConfig(r.config, options);
+			r.layers = r.config._layers;
+			delete r.config._layers;
+			r.config = _merger(r.config, ...r.layers.map((e) => e.config));
+		}
+	}
+	r.layers = [...[
+		configs.overrides && {
+			config: configs.overrides,
+			configFile: void 0,
+			cwd: void 0
+		},
+		{
+			config: configs.main,
+			configFile: options.configFile,
+			cwd: options.cwd
+		},
+		configs.rc && {
+			config: configs.rc,
+			configFile: options.rcFile
+		},
+		configs.packageJson && {
+			config: configs.packageJson,
+			configFile: "package.json"
+		}
+	].filter((l) => l && l.config), ...r.layers];
+	if (options.defaults) r.config = _merger(r.config, options.defaults);
+	if (options.omit$Keys) {
+		for (const key in r.config) if (key.startsWith("$")) delete r.config[key];
+	}
+	if (options.configFileRequired && !r._configFile) throw new Error(`Required config (${r.configFile}) cannot be resolved.`);
+	if (options.schema != null) r.config = await validateConfig(r.config, options.schema);
+	return r;
+}
+async function extendConfig(config, options) {
+	config._layers = config._layers || [];
+	if (!options.extend) return;
+	let keys = options.extend.extendKey;
+	if (typeof keys === "string") keys = [keys];
+	const extendSources = [];
+	for (const key of keys) {
+		extendSources.push(...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(Boolean));
+		delete config[key];
+	}
+	for (let extendSource of extendSources) {
+		const originalExtendSource = extendSource;
+		let sourceOptions = {};
+		if (extendSource.source) {
+			sourceOptions = extendSource.options || {};
+			extendSource = extendSource.source;
+		}
+		if (Array.isArray(extendSource)) {
+			sourceOptions = extendSource[1] || {};
+			extendSource = extendSource[0];
+		}
+		if (typeof extendSource !== "string") {
+			console.warn(`Cannot extend config from \`${JSON.stringify(originalExtendSource)}\` in ${options.cwd}`);
+			continue;
+		}
+		const _config = await resolveConfig$1(extendSource, options, sourceOptions);
+		if (!_config.config) {
+			console.warn(`Cannot extend config from \`${extendSource}\` in ${options.cwd}`);
+			continue;
+		}
+		await extendConfig(_config.config, {
+			...options,
+			cwd: _config.cwd
+		});
+		config._layers.push(_config);
+		if (_config.config._layers) {
+			config._layers.push(..._config.config._layers);
+			delete _config.config._layers;
+		}
+	}
+}
+const GIGET_PREFIXES = [
+	"gh:",
+	"github:",
+	"gitlab:",
+	"bitbucket:",
+	"https://",
+	"http://"
+];
+const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
+async function resolveConfig$1(source, options, sourceOptions = {}) {
+	if (options.resolve) {
+		const res = await options.resolve(source, options);
+		if (res) return res;
+	}
+	const _merger = options.merger || defu;
+	const customProviderKeys = Object.keys(sourceOptions.giget?.providers || {}).map((key) => `${key}:`);
+	const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
+	if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
+		const { downloadTemplate } = await import("giget").catch((error) => {
+			throw new Error(`Extending config from \`${source}\` requires \`giget\` peer dependency to be installed.\n\nInstall it with: \`npx nypm i giget\``, { cause: error });
+		});
+		const { digest } = await import("./ohash-BjQY1cBb.js").then((n) => n.dist_exports);
+		const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
+		let cloneDir;
+		const localNodeModules = resolve$1(options.cwd, "node_modules");
+		const parentDir = dirname$1(options.cwd);
+		if (basename$1(parentDir) === ".c12") cloneDir = join$1(parentDir, cloneName);
+		else if (existsSync(localNodeModules)) cloneDir = join$1(localNodeModules, ".c12", cloneName);
+		else cloneDir = process.env.XDG_CACHE_HOME ? resolve$1(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve$1(homedir(), ".cache/c12", cloneName);
+		const install = sourceOptions.install ? defu(sourceOptions.install === true ? {} : sourceOptions.install, { ignoreWorkspace: true }) : false;
+		if (existsSync(cloneDir) && !install) await rm(cloneDir, { recursive: true });
+		source = (await downloadTemplate(source, {
+			dir: cloneDir,
+			install,
+			force: Boolean(install),
+			auth: sourceOptions.auth,
+			...options.giget,
+			...sourceOptions.giget
+		})).dir;
+	}
+	if (NPM_PACKAGE_RE.test(source)) source = tryResolve(source, options) || source;
+	const ext = extname$1(source);
+	const isDir = _isDirectory(resolve$1(options.cwd, source)) ?? (!ext || ext === basename$1(source));
+	const cwd = resolve$1(options.cwd, isDir ? source : dirname$1(source));
+	if (isDir) source = options.configFile;
+	const res = {
+		config: void 0,
+		configFile: void 0,
+		cwd,
+		source,
+		sourceOptions
+	};
+	res.configFile = tryResolve(resolve$1(cwd, source), options) || tryResolve(resolve$1(cwd, ".config", source.replace(/\.config$/, "")), options) || tryResolve(resolve$1(cwd, ".config", source), options) || source;
+	if (!existsSync(res.configFile)) return res;
+	res._configFile = res.configFile;
+	const configFileExt = extname$1(res.configFile) || "";
+	if (configFileExt in ASYNC_LOADERS) res.config = (await ASYNC_LOADERS[configFileExt]())(await readFile(res.configFile, "utf8"));
+	else {
+		const _resolveModule = options.resolveModule || ((mod) => mod.default || mod);
+		if (options.import) res.config = _resolveModule(await options.import(res.configFile));
+		else {
+			const _configURL = pathToFileURL(res.configFile);
+			_configURL.search = `_${++importCounter}`;
+			res.config = await import(_configURL.href).then(_resolveModule, async (error) => {
+				const { createJiti } = await import("jiti").catch(() => {
+					throw new Error(`Failed to load config file \`${res.configFile}\`: ${error?.message}.  Hint install \`jiti\` for compatibility.`, { cause: error });
+				});
+				const jiti = createJiti(join$1(options.cwd || ".", options.configFile || "/"), {
+					interopDefault: true,
+					moduleCache: false,
+					extensions: [...SUPPORTED_EXTENSIONS],
+					...options.jitiOptions
+				});
+				options.import = (id) => jiti.import(id);
+				return _resolveModule(await options.import(res.configFile));
+			});
+		}
+	}
+	if (typeof res.config === "function") res.config = await res.config(options.context);
+	if (res.config && typeof res.config === "object" && !Array.isArray(res.config) && !Object.isExtensible(res.config)) res.config = { ...res.config };
+	const envConfigs = (Array.isArray(options.envName) ? options.envName : [options.envName]).filter(Boolean).reverse().flatMap((envName) => [res.config.$env?.[envName], res.config["$" + envName]]).filter((c) => c && Object.keys(c).length > 0);
+	if (envConfigs.length > 0) res.config = (options.envMerger || _merger)({}, ...envConfigs, res.config);
+	res.meta = defu(res.sourceOptions.meta, res.config.$meta);
+	delete res.config.$meta;
+	if (res.sourceOptions.overrides) res.config = _merger(res.sourceOptions.overrides, res.config);
+	res.configFile = _normalize(res.configFile);
+	res.source = _normalize(res.source);
+	return res;
+}
+async function validateConfig(config, schema) {
+	if (typeof schema?.["~standard"]?.validate !== "function") throw new TypeError("Invalid `schema` option: expected a Standard Schema (https://standardschema.dev).");
+	const result = await schema["~standard"].validate(config);
+	if (result.issues) {
+		const messages = result.issues.map((issue) => {
+			const path = issue.path?.map((p) => String(typeof p === "object" ? p.key : p)).join(".");
+			return `  - ${path ? `${path}: ` : ""}${issue.message}`;
+		});
+		throw new Error(`Config validation failed (${schema["~standard"].vendor}):\n${messages.join("\n")}`, { cause: result.issues });
+	}
+	return result.value;
+}
+function tryResolve(id, options) {
+	const res = resolveModulePath(id, {
+		try: true,
+		from: pathToFileURL(join$1(options.cwd || ".", options.configFile || "/")),
+		suffixes: ["", "/index"],
+		extensions: SUPPORTED_EXTENSIONS,
+		cache: false
+	});
+	return res ? normalize$1(res) : void 0;
+}
+function _isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/cli/config-schema.ts
+const strings = array(string());
+const stringRecord = record(string(), string());
+const privilege = pipe(string(), regex(/^(?:select|insert|update|delete|(?:select|insert|update)\s*\(\s*(?:[a-z_][a-z0-9_$]*(?:\s*,\s*[a-z_][a-z0-9_$]*)*|\*(?:\s*,\s*-\s*[a-z_][a-z0-9_$]*)*)\s*\))$/, "Use select, insert, update or delete, name columns such as \"update(title, body)\", or exclude them from every column with \"select(*, -secret)\""));
+const privileges = array(privilege);
+const triggerValue = union([string(), strictObject({
+	from: string(),
+	via: lazy(() => triggerValue),
+	select: string(),
+	key: exactOptional(string())
+})]);
+const triggerValues = record(string(), triggerValue);
+const pluginFlag = union([boolean(), record(string(), unknown())]);
+const isGenerator = (value) => typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "generate" in value && typeof value.generate === "function";
+const generator = custom(isGenerator, "must be a generator: { name, generate(input) }");
+/**
+* The top level of `better-supabase.config.*`. It rejects unknown keys and
+* checks the leaves a typo or an old value breaks; nested objects the
+* library reads loosely stay loose.
+*/
+const blockEntries = {
+	mode: optional(picklist([
+		"managed",
+		"adopt",
+		"custom"
+	])),
+	schema: optional(string()),
+	tables: optional(record(string(), nullable(string()))),
+	columns: optional(record(string(), record(string(), nullable(string())))),
+	idType: optional(string()),
+	scope: optional(picklist([
+		"tenant",
+		"user",
+		"none"
+	])),
+	functions: optional(stringRecord),
+	permissions: optional(stringRecord),
+	options: optional(record(string(), unknown())),
+	hooks: optional(strictObject({
+		schema: optional(string()),
+		functions: optional(stringRecord)
+	})),
+	events: optional(boolean()),
+	audit: optional(boolean()),
+	api: optional(union([
+		string(),
+		literal(false),
+		strictObject({
+			schema: string(),
+			functions: optional(strings)
+		})
+	]))
+};
+const disabledRow = strictObject({
+	table: string(),
+	id: string(),
+	disabledAt: optional(string()),
+	status: optional(string()),
+	active: optional(strings)
+});
+const accessBlock = strictObject({
+	...blockEntries,
+	model: optional(picklist([
+		"roles",
+		"catalog",
+		"provider",
+		"custom"
+	])),
+	roles: optional(record(string(), strings)),
+	functions: optional(strictObject({
+		can: optional(string()),
+		tenantIdsWith: optional(string()),
+		isPlatform: optional(string()),
+		canUser: optional(string()),
+		canAssign: optional(string()),
+		canAssignFor: optional(string()),
+		permissionClaims: optional(string())
+	})),
+	platformClaim: optional(string()),
+	scopes: optional(record(string(), strings)),
+	disabled: optional(strictObject({
+		tenant: optional(union([string(), disabledRow])),
+		user: optional(union([string(), disabledRow])),
+		userKey: optional(string())
+	})),
+	activeTenant: optional(union([picklist(["claim", "resolver"]), strictObject({
+		profileColumn: string(),
+		key: optional(string())
+	})]))
+});
+const scopeName = pipe(string(), regex(/^[a-z][a-z0-9_]*$/, "Use lower case letters, digits and _"));
+const membershipScope = union([strictObject({ column: string() }), strictObject({ value: string() })]);
+const authorization = strictObject({
+	apiVersion: literal(1),
+	name: string(),
+	scopes: array(strictObject({
+		name: scopeName,
+		idType: optional(picklist(SCOPE_ID_TYPES)),
+		parent: optional(string())
+	})),
+	tenantScope: scopeName,
+	functions: strictObject({
+		idsWith: string(),
+		isPlatform: string(),
+		idsWithFor: optional(string()),
+		isPlatformFor: optional(string()),
+		memberIds: optional(string()),
+		memberIdsFor: optional(string()),
+		canAssign: optional(string()),
+		canAssignFor: optional(string()),
+		permissionsFor: optional(string()),
+		canApprove: optional(string()),
+		isApprover: optional(string()),
+		holdersOf: optional(string()),
+		actorMayWrite: optional(string()),
+		permitted: optional(string())
+	}),
+	requires: optional(array(strictObject({
+		function: string(),
+		args: optional(string()),
+		role: string()
+	}))),
+	permissions: optional(array(strictObject({
+		key: string(),
+		sqlComplete: optional(boolean()),
+		scopes: optional(strings)
+	}))),
+	operations: optional(record(string(), strictObject({
+		permission: pipe(string(), minLength(1)),
+		meta: optional(strictObject({
+			risk: optional(picklist([
+				"low",
+				"medium",
+				"high"
+			])),
+			effects: optional(array(picklist([
+				"read",
+				"write",
+				"delete",
+				"external"
+			]))),
+			title: optional(string())
+		}))
+	}))),
+	memberships: optional(array(strictObject({
+		table: string(),
+		userColumn: string(),
+		scope: membershipScope,
+		idColumn: string()
+	}))),
+	suspension: optional(strictObject({
+		user: optional(disabledRow),
+		tenant: optional(disabledRow)
+	})),
+	roleSources: optional(array(strictObject({
+		table: string(),
+		role: strictObject({
+			column: string(),
+			through: strictObject({
+				table: string(),
+				id: string(),
+				column: string()
+			})
+		})
+	}))),
+	decidingColumns: optional(array(pipe(string(), regex(/^[A-Za-z_][\w$]*\.[A-Za-z_][\w$]*\.[A-Za-z_][\w$]*$/, "Use schema.table.column")))),
+	tokenHook: optional(strictObject({
+		function: string(),
+		tenantClaim: optional(string()),
+		ownedClaims: pipe(strings, minLength(1, "List at least one claim")),
+		registeredClaims: optional(array(strictObject({
+			name: string(),
+			function: string()
+		}))),
+		budget: optional(strictObject({
+			claims: strings,
+			bytes: pipe(number(), integer("Use a whole number of bytes"), minValue(1, "Use at least 1 byte")),
+			truncatedClaim: optional(string())
+		})),
+		markers: optional(strictObject({
+			hook: optional(string()),
+			grants: optional(string())
+		})),
+		grantsCommand: optional(string())
+	})),
+	delegation: optional(strictObject({ scopes: optional(record(string(), strings)) })),
+	approvals: optional(strictObject({ distinctApprover: optional(boolean()) })),
+	problems: optional(strings)
+});
+const checkedAuthorization = pipe(authorization, rawCheck(({ dataset, addIssue }) => {
+	if (!dataset.typed) return;
+	for (const problem of scopeProblems(dataset.value)) addIssue({ message: problem });
+}));
+const jsonSchema$1 = record(string(), unknown());
+const onDelete = optional(picklist(APP_ON_DELETE_ACTIONS));
+const positiveInteger = pipe(number(), integer(), minValue(1));
+const bucket = strictObject({
+	id: optional(string()),
+	public: optional(boolean()),
+	path: union([string(), pipe(strings, minLength(1))]),
+	policy: optional(union([picklist([
+		"tenant",
+		"owner",
+		"public",
+		"none"
+	]), strictObject({
+		access: strictObject({
+			read: string(),
+			list: optional(string()),
+			write: string(),
+			delete: optional(string())
+		}),
+		scope: optional(string()),
+		segment: optional(positiveInteger),
+		sql: optional(union([literal("provider"), strictObject({
+			idsWith: string(),
+			isPlatform: string()
+		})]))
+	})])),
+	fileSizeLimit: optional(string()),
+	allowedMimeTypes: optional(strings),
+	versioning: optional(boolean()),
+	lifecycle: optional(strictObject({ rules: pipe(array(strictObject({
+		id: optional(string()),
+		status: optional(picklist(["Enabled", "Disabled"])),
+		noncurrentVersionExpiration: strictObject({
+			noncurrentDays: positiveInteger,
+			newerNoncurrentVersions: optional(pipe(number(), integer(), minValue(1), maxValue(100)))
+		})
+	})), minLength(1), maxLength(1e3)) }))
+});
+const ENTRIES = {
+	source: optional(strictObject({
+		dbUrl: optional(string()),
+		projectRef: optional(string()),
+		accessToken: optional(string()),
+		snapshot: optional(string()),
+		lite: optional(boolean())
+	})),
+	schemas: optional(strings),
+	casing: optional(picklist(["snake", "camel"])),
+	tables: optional(record(string(), strictObject({
+		casing: optional(picklist(["snake", "camel"])),
+		exclude: optional(boolean()),
+		serviceRole: optional(boolean()),
+		relations: optional(stringRecord),
+		insertOptional: optional(strings)
+	}))),
+	output: optional(string()),
+	postgrestVersion: optional(string()),
+	json: optional(record(string(), union([strictObject({
+		import: string(),
+		schema: optional(jsonSchema$1)
+	}), strictObject({
+		type: string(),
+		schema: optional(jsonSchema$1)
+	})], "Use { import } or { type }, with an optional schema"))),
+	codecs: optional(strictObject({
+		timestamptz: optional(picklist(["string", "instant"])),
+		int8: optional(picklist([
+			"number",
+			"string",
+			"bigint"
+		])),
+		numeric: optional(picklist(["number", "string"]))
+	})),
+	relations: optional(strictObject({ nullableUnderRls: optional(boolean()) })),
+	sensitive: optional(strings),
+	storagePaths: optional(stringRecord),
+	functions: optional(record(string(), strictObject({ notNull: optional(union([literal(true), strings])) }))),
+	expose: optional(record(string(), union([
+		privileges,
+		strictObject({
+			anon: optional(privileges),
+			authenticated: optional(privileges),
+			serviceRole: optional(privileges)
+		}),
+		strictObject({
+			execute: array(picklist(["anon", "authenticated"])),
+			serviceRole: optional(boolean())
+		})
+	]))),
+	readSets: optional(strings),
+	generators: optional(array(generator)),
+	plugins: optional(strictObject({
+		timestamps: optional(pluginFlag),
+		softDelete: optional(pluginFlag),
+		tenant: optional(pluginFlag),
+		actor: optional(pluginFlag)
+	})),
+	claims: optional(strictObject({
+		tenant: optional(string()),
+		scope: optional(string()),
+		features: optional(string()),
+		memberships: optional(string())
+	})),
+	buckets: optional(record(string(), bucket)),
+	topics: optional(stringRecord),
+	realtime: optional(strictObject({
+		tables: optional(strings),
+		global: optional(strings),
+		users: optional(stringRecord),
+		policies: optional(strictObject({
+			from: strings,
+			output: string()
+		})),
+		triggers: optional(array(strictObject({
+			topic: string(),
+			table: string(),
+			values: optional(triggerValues),
+			events: optional(array(picklist([
+				"insert",
+				"update",
+				"delete"
+			]))),
+			event: optional(union([string(), strictObject({
+				insert: optional(string()),
+				update: optional(string()),
+				delete: optional(string())
+			})])),
+			payload: optional(union([picklist(["keys", "row"]), record(string(), union([triggerValue, strictObject({ sql: string() })]))])),
+			topics: optional(array(strictObject({
+				topic: string(),
+				values: optional(triggerValues)
+			}))),
+			functionSchema: optional(string())
+		})))
+	})),
+	entitlements: optional(strictObject({
+		customer: optional(string()),
+		key: optional(string()),
+		memberships: optional(picklist(["tenant", "provider"])),
+		source: optional(union([picklist(["stripe-sync", "custom"]), strictObject({ plans: strictObject({
+			subscriptions: strictObject({
+				table: string(),
+				tenant: string(),
+				plan: string(),
+				status: optional(string()),
+				activeStatuses: optional(strings)
+			}),
+			features: strictObject({
+				table: string(),
+				plan: string(),
+				feature: string(),
+				included: optional(string()),
+				value: optional(string())
+			})
+		}) })])),
+		claim: optional(union([literal(false), strictObject({
+			maxTenants: optional(number()),
+			keys: optional(stringRecord)
+		})]))
+	})),
+	authorization: optional(checkedAuthorization),
+	vectorSearch: optional(record(string(), union([string(), strictObject({
+		column: string(),
+		distance: optional(picklist([
+			"cosine",
+			"l2",
+			"inner_product"
+		])),
+		type: optional(picklist(["vector", "halfvec"])),
+		key: optional(string()),
+		hybrid: optional(strictObject({
+			tsvector: string(),
+			config: optional(string()),
+			k: optional(number())
+		})),
+		boost: optional(string()),
+		prefilter: optional(strings),
+		predicate: optional(string()),
+		boostMode: optional(picklist(["multiply", "add"])),
+		order: optional(string())
+	})]))),
+	subjects: optional(record(pipe(string(), regex(/^[a-z][a-z0-9_]{0,62}$/, "a subject type is lowercase letters, digits and underscores")), strictObject({
+		table: string(),
+		id: optional(string()),
+		idType: optional(string()),
+		tenant: optional(union([string(), literal(false)])),
+		title: optional(string()),
+		url: optional(string()),
+		permissions: optional(record(string(), string())),
+		scope: optional(string()),
+		cascade: optional(boolean()),
+		deletedAt: optional(string()),
+		search: optional(strictObject({
+			title: optional(string()),
+			body: optional(strings)
+		})),
+		rank: optional(strictObject({
+			column: string(),
+			group: optional(string())
+		})),
+		versions: optional(strictObject({
+			columns: strings,
+			auto: boolean()
+		}))
+	}))),
+	appTables: optional(record(string(), strictObject({
+		columns: optional(record(string(), strictObject({
+			type: picklist(APP_COLUMN_TYPES),
+			nullable: optional(boolean()),
+			default: optional(string()),
+			unique: optional(boolean()),
+			references: optional(union([strictObject({
+				table: string(),
+				onDelete
+			}), strictObject({
+				block: string(),
+				table: string(),
+				onDelete
+			})])),
+			format: optional(picklist(APP_COLUMN_FORMATS)),
+			options: optional(array(string())),
+			min: optional(number()),
+			max: optional(number()),
+			comment: optional(string()),
+			identity: optional(boolean()),
+			access: optional(picklist(APP_COLUMN_ACCESS))
+		}))),
+		scope: optional(picklist([
+			"inherit",
+			"user",
+			"none"
+		])),
+		timestamps: optional(boolean()),
+		id: optional(picklist(["uuid", "bigint"])),
+		unique: optional(array(array(string()))),
+		indexes: optional(array(array(string()))),
+		comment: optional(string()),
+		subject: optional(strictObject({
+			type: string(),
+			title: optional(string()),
+			url: optional(string()),
+			search: optional(strictObject({
+				title: optional(string()),
+				body: optional(array(string()))
+			})),
+			permissions: optional(record(string(), string())),
+			rank: optional(union([literal(true), strictObject({ group: optional(string()) })])),
+			softDelete: optional(boolean()),
+			versions: optional(union([literal(true), strictObject({
+				columns: optional(strings),
+				auto: optional(boolean())
+			})]))
+		})),
+		rollups: optional(record(string(), strictObject({
+			table: string(),
+			via: string(),
+			aggregate: picklist(APP_ROLLUP_AGGREGATES),
+			column: optional(string()),
+			where: optional(strictObject({
+				column: string(),
+				equals: string()
+			}))
+		}))),
+		lookups: optional(record(string(), strictObject({
+			via: string(),
+			column: string()
+		}))),
+		events: optional(union([literal(true), strictObject({
+			on: optional(array(picklist(APP_TABLE_EVENT_KINDS))),
+			include: optional(strings)
+		})]))
+	}))),
+	blocks: optional(lazy((input) => Array.isArray(input) ? strings : objectWithRest({ access: optional(accessBlock) }, strictObject(blockEntries)))),
+	sql: optional(strictObject({
+		workflow: optional(picklist([
+			"pg-delta",
+			"migra",
+			"migrations"
+		])),
+		dir: optional(string()),
+		prefix: optional(string()),
+		testsDir: optional(string()),
+		schema: optional(string()),
+		api: optional(string()),
+		scope: optional(picklist([
+			"tenant",
+			"user",
+			"none"
+		])),
+		naming: optional(strictObject({ tenant: optional(pipe(string(), regex(/^[a-z][a-z0-9_]{0,40}$/, "a tenant name is lowercase letters, digits and underscores"))) }))
+	})),
+	seed: optional(strictObject({
+		entry: optional(string()),
+		output: optional(string())
+	})),
+	openapi: optional(strictObject({
+		entry: optional(string()),
+		output: optional(string())
+	})),
+	specs: optional(strictObject({
+		entry: optional(string()),
+		outputs: optional(array(strictObject({
+			format: pipe(string(), minLength(1)),
+			version: optional(string()),
+			output: optional(string()),
+			overlays: optional(strings),
+			serialize: optional(picklist(["json", "yaml"])),
+			ui: optional(picklist([
+				"scalar",
+				"swagger",
+				"redoc",
+				"elements",
+				"rapidoc"
+			]))
+		}))),
+		failOn: optional(picklist([
+			"error",
+			"warning",
+			"never"
+		])),
+		manifest: optional(string())
+	})),
+	doctor: optional(strictObject({
+		ignore: optional(strings),
+		only: optional(strings),
+		strict: optional(boolean()),
+		format: optional(picklist([
+			"text",
+			"sarif",
+			"github"
+		])),
+		output: optional(string()),
+		sources: optional(strings),
+		policyHelperLimit: optional(number()),
+		claimsLimit: optional(number()),
+		migrationSafety: optional(strictObject({ since: optional(string()) }))
+	})),
+	gen: optional(strictObject({
+		tasks: optional(array(picklist(GEN_TASKS))),
+		watchInterval: optional(pipe(number(), minValue(1, "must be a positive number of ms")))
+	})),
+	env: optional(strictObject({
+		output: optional(string()),
+		prefix: optional(string())
+	})),
+	scaffold: optional(strictObject({ api: optional(strictObject({
+		framework: optional(picklist(["hono", "next"])),
+		tables: optional(strings),
+		name: optional(string()),
+		basePath: optional(string())
+	})) })),
+	integrations: optional(array(picklist(INTEGRATIONS))),
+	skills: optional(strictObject({ agents: optional(array(picklist(SKILLS_AGENTS))) })),
+	keys: optional(strictObject({ output: optional(string()) }))
+};
+const EnvironmentSchema = strictObject(ENTRIES);
+const ConfigSchema = strictObject({
+	$schema: optional(string()),
+	preset: optional(pipe(string(), minLength(1))),
+	...ENTRIES,
+	$env: optional(record(string(), EnvironmentSchema)),
+	$development: optional(EnvironmentSchema),
+	$production: optional(EnvironmentSchema),
+	$test: optional(EnvironmentSchema),
+	$ci: optional(EnvironmentSchema)
+});
+/** Each issue as `path: message`, the path in config keys. */
+const hasSqlModules = (value) => typeof value === "object" && value !== null && "sql" in value && typeof value.sql === "object" && value.sql !== null && "modules" in value.sql;
+/**
+* `sql.modules` in the config or one of its environment blocks. The key
+* moved to `blocks` in 0.9, and the codemod moves it.
+*/
+function sqlModulesIssues(value) {
+	if (typeof value !== "object" || value === null) return [];
+	const blocks = [["", value]];
+	const entries = Object.entries(value);
+	for (const [key, block] of entries) if (key === "$env" && typeof block === "object" && block !== null) {
+		const named = Object.entries(block);
+		blocks.push(...named.map(([name, env]) => [`$env.${name}.`, env]));
+	} else if (key.startsWith("$")) blocks.push([`${key}.`, block]);
+	return blocks.filter(([, block]) => hasSqlModules(block)).map(([prefix]) => `${prefix}sql.modules: moved to the top-level \`blocks\` key in 0.9; run \`better-supabase codemod 0.9\``);
+}
+function configIssues(value) {
+	const moved = sqlModulesIssues(value);
+	if (moved.length > 0) return moved;
+	if (typeof value === "object" && value !== null && "authorization" in value) {
+		const provider = value.authorization;
+		const problem = typeof provider === "object" && provider !== null ? providerApiProblem(provider) : void 0;
+		if (problem !== void 0) {
+			const { authorization: _, ...rest } = value;
+			return [`authorization.apiVersion: ${problem}`, ...configIssues(rest)];
+		}
+	}
+	const result = safeParse(ConfigSchema, value);
+	if (result.success) return [];
+	return result.issues.map((issue) => {
+		const path = getDotPath(issue);
+		return path ? `${path}: ${issue.message}` : issue.message;
+	});
+}
+strictObject(blockEntries);
+//#endregion
+//#region src/cli/core/credentials.ts
+/** The first source that has a value, in order. */
+function first(sources) {
+	for (const [from, value] of sources) if (value !== void 0 && value !== "") return {
+		value,
+		from
+	};
+}
+/** The Supabase access token: `source.accessToken`, then `$SUPABASE_ACCESS_TOKEN`. */
+function accessToken(config, env) {
+	return first([["source.accessToken", config.source.accessToken], ["$SUPABASE_ACCESS_TOKEN", env.SUPABASE_ACCESS_TOKEN]]);
+}
+/** A connection string given by the user: `--db-url-stdin`, `source.dbUrl`, `$DATABASE_URL`, then `$SUPABASE_DB_URL`. */
+function databaseUrlCredential(config, env, fromStdin) {
+	return first([
+		["--db-url-stdin", fromStdin],
+		["source.dbUrl", config.source.dbUrl],
+		["$DATABASE_URL", env.DATABASE_URL],
+		["$SUPABASE_DB_URL", env.SUPABASE_DB_URL]
+	]);
+}
+//#endregion
+//#region src/cli/config.ts
+const CONFIG_FILES = [
+	"better-supabase.config.ts",
+	"better-supabase.config.mts",
+	"better-supabase.config.js",
+	"better-supabase.config.mjs",
+	"better-supabase.config.json"
+];
+function configIn(dir) {
+	for (const name of CONFIG_FILES) {
+		const path = join(dir, name);
+		if (existsSync(path)) return path;
+	}
+}
+function findConfig(cwd, explicit) {
+	if (explicit) return resolve(cwd, explicit);
+	return configIn(cwd);
+}
+/**
+* `--config`, else the first `better-supabase.config.*` at or above `cwd`,
+* within the same `.git` boundary as the Supabase project search.
+*/
+function discoverConfig(cwd, explicit) {
+	if (explicit) return resolve(cwd, explicit);
+	const dir = findUp(cwd, (candidate) => configIn(candidate) !== void 0);
+	return dir === void 0 ? void 0 : configIn(dir);
+}
+/** The named export, then `default`, of a project module. */
+async function importExport(path, name) {
+	if (!existsSync(path)) throw new CliError("not_found", `Module not found: ${path}`);
+	const loaded = await importFresh(path);
+	return loaded[name] ?? loaded["default"];
+}
+function isConfig(value) {
+	return configIssues(value).length === 0;
+}
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Objects merge key by key; arrays and every other value replace what `base` had. */
+function mergeConfig(base, override) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		if (value === void 0) continue;
+		const current = merged[key];
+		merged[key] = isPlainObject(current) && isPlainObject(value) ? mergeConfig(current, value) : value;
+	}
+	return merged;
+}
+/**
+* The config with the `environment` blocks merged in: `$env.<name>`, then
+* the `$development`, `$production`, `$test` or `$ci` shorthand. Every `$`
+* key is dropped from the result.
+*/
+function applyEnvironment(config, environment) {
+	const { $schema: _schema, $env, $development, $production, $test, $ci, ...base } = config;
+	if (environment === void 0) return base;
+	const shorthand = (/* @__PURE__ */ new Map([
+		["development", $development],
+		["production", $production],
+		["test", $test],
+		["ci", $ci]
+	])).get(environment);
+	let merged = { ...base };
+	for (const block of [$env?.[environment], shorthand]) if (block) merged = mergeConfig(merged, block);
+	if (!isConfig(merged)) throw new CliError("config_invalid", `The ${environment} environment makes the config invalid:\n${configIssues(merged).map((issue) => `  ${issue}`).join("\n")}`);
+	return merged;
+}
+function defaultConfig(cwd, explicit, environment, path = discoverConfig(cwd, explicit)) {
+	const resolved = resolveConfig({}, !path || explicit ? cwd : dirname(path));
+	return environment === void 0 ? resolved : {
+		...resolved,
+		environment
+	};
+}
+/**
+* Loads `better-supabase.config.*` with c12 and checks it against the config
+* schema. c12 imports `.ts` natively (Node 24 strips the types), so no
+* loader is needed; rc files, `package.json`, env overrides and `extends`
+* are off so the one file is the whole config. `environment` merges its
+* blocks in (`applyEnvironment`); c12's own `envName` is off because it
+* concatenates arrays. A discovered file sets the project root to its own
+* directory; `--config` keeps `cwd` as the root. `path` is the file
+* `discoverConfig` found, for callers that already looked it up.
+*/
+async function loadConfig(cwd, explicit, environment, path = discoverConfig(cwd, explicit)) {
+	const withEnvironment = (resolved) => environment === void 0 ? resolved : {
+		...resolved,
+		environment
+	};
+	if (!path) return withEnvironment(resolveConfig({}, cwd));
+	if (!existsSync(path)) throw new CliError("config_not_found", `Config file not found: ${path}`);
+	const { config } = await loadConfig$1({
+		cwd,
+		configFile: path,
+		rcFile: false,
+		globalRc: false,
+		packageJson: false,
+		dotenv: false,
+		envName: false,
+		extend: false,
+		giget: false
+	});
+	if (!isConfig(config)) {
+		const issues = configIssues(config);
+		throw new CliError("config_invalid", `${display(cwd, path)} is not a valid config:\n${issues.map((issue) => `  ${issue}`).join("\n")}`, { issues });
+	}
+	return withEnvironment(resolveConfig(applyEnvironment(config, environment), explicit ? cwd : dirname(path)));
+}
+/** `[db] port` or `[api] port` from `supabase/config.toml`. */
+async function readSupabasePort(root, section) {
+	const toml = await readSupabaseToml(root);
+	return toml ? tomlNumber(toml.document, [section, "port"]) : void 0;
+}
+/** The connection string piped in for `--db-url-stdin`, when it was passed. */
+async function stdinDatabaseUrl(enabled, io) {
+	if (enabled !== true) return;
+	const url = (await readStdin(io, "--db-url-stdin")).trim();
+	if (!url) throw new CliError("missing_value", "--db-url-stdin read nothing from stdin. Pipe the connection string: printf %s \"$URL\" | better-supabase <command> --db-url-stdin", { flag: "--db-url-stdin" });
+	return url;
+}
+/**
+* Connection string: stdin, config, `$DATABASE_URL`, `$SUPABASE_DB_URL`, then the
+* local stack: the `[db] port` in `config.toml`, else the running stack's
+* `DB_URL`, else port 54322.
+*/
+async function databaseUrl(config, env, fromStdin) {
+	const given = databaseUrlCredential(config, env, fromStdin);
+	if (given) return given.value;
+	let resolved = localUrls.get(config);
+	if (!resolved) {
+		resolved = localDatabaseUrl(config.root, env);
+		localUrls.set(config, resolved);
+	}
+	return resolved;
+}
+/** One lookup per loaded config, so a run asks `supabase status` at most once. */
+const localUrls = /* @__PURE__ */ new WeakMap();
+async function localDatabaseUrl(root, env) {
+	const port = await readSupabasePort(root, "db");
+	if (port === void 0 && await readSupabaseToml(root)) {
+		const stack = await readStackStatus(root, env).catch(() => void 0);
+		const url = stack?.ok ? stack.status["DB_URL"] : void 0;
+		if (typeof url === "string" && url.length > 0) return url;
+	}
+	return `postgresql://postgres:postgres@127.0.0.1:${port ?? 54322}/postgres`;
+}
+//#endregion
+export { findConfig as a, readSupabasePort as c, discoverConfig as i, stdinDatabaseUrl as l, databaseUrl as n, importExport as o, defaultConfig as r, loadConfig as s, applyEnvironment as t, accessToken as u };