better-supabase 0.5.0 → 0.6.0

package/dist/cli/config-NiPxAmUF.js

@@ -0,0 +1,1077 @@
+import { n as CliError } from "./errors-4v4DTtda.js";
+import { t as display } from "./io-DI1mTdSA.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-DBPdlPYK.js";
+import { C as unknown, S as union, _ as record, a as integer, b as strictObject, c as minLength, d as number, f as objectWithRest, g as rawCheck, h as pipe, i as getDotPath, l as minValue, m as picklist, n as boolean, o as lazy, p as optional, r as custom, s as literal, t as array, u as nullable, v as regex, x as string, y as safeParse } from "./dist-DRAVaE6w.js";
+import { t as importFresh } from "./fresh-import-BeYf9I3x.js";
+import { m as tomlNumber, o as findUp, u as readSupabaseToml } from "./supabase-toml-B-bIukQF.js";
+import * as nodeUtil from "node:util";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { providerApiProblem, resolveConfig } from "better-supabase/config";
+import { SCOPE_ID_TYPES, scopeProblems } from "better-supabase/sql";
+import { pathToFileURL } from "node:url";
+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(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(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(value) && isPlainObject(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-BUniUpOk.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-DreZ24Sz.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-DreZ24Sz.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 privileges = array(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*\))$/, "Use select, insert, update or delete, or name columns such as \"update(title, body)\"")));
+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";
+/**
+* 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 moduleEntries = {
+	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()),
+	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(), strictObject({
+		schema: string(),
+		functions: optional(strings)
+	})]))
+};
+const disabledRow = strictObject({
+	table: string(),
+	id: string(),
+	disabledAt: optional(string()),
+	status: optional(string()),
+	active: optional(strings)
+});
+const accessModule = strictObject({
+	...moduleEntries,
+	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()),
+	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())
+	}),
+	requires: optional(array(strictObject({
+		function: string(),
+		args: optional(string()),
+		role: string()
+	}))),
+	permissions: optional(array(strictObject({
+		key: string(),
+		sqlComplete: optional(boolean()),
+		scopes: optional(strings)
+	}))),
+	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())
+	})),
+	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 ConfigSchema = strictObject({
+	$schema: optional(string()),
+	source: optional(strictObject({
+		dbUrl: optional(string()),
+		projectRef: optional(string()),
+		accessToken: optional(string()),
+		snapshot: optional(string())
+	})),
+	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(), unknown())),
+	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(custom(isGenerator, "must be a generator: { name, generate(input) }"))),
+	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(), record(string(), unknown()))),
+	topics: optional(stringRecord),
+	realtime: optional(strictObject({
+		tables: optional(strings),
+		global: optional(strings),
+		users: optional(stringRecord),
+		policies: optional(strictObject({
+			from: strings,
+			output: 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())
+	})]))),
+	sql: optional(strictObject({
+		dir: optional(string()),
+		prefix: optional(string()),
+		testsDir: optional(string()),
+		modules: optional(lazy((input) => Array.isArray(input) ? strings : objectWithRest({ access: optional(accessModule) }, strictObject(moduleEntries))))
+	})),
+	seed: optional(strictObject({
+		entry: optional(string()),
+		output: optional(string())
+	})),
+	openapi: optional(strictObject({
+		entry: optional(string()),
+		output: optional(string())
+	})),
+	doctor: optional(strictObject({
+		ignore: optional(strings),
+		strict: optional(boolean()),
+		sources: optional(strings),
+		policyHelperLimit: optional(number()),
+		claimsLimit: optional(number())
+	}))
+});
+/** Each issue as `path: message`, the path in config keys. */
+function configIssues(value) {
+	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;
+	});
+}
+//#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 Error(`Module not found: ${path}`);
+	const loaded = await importFresh(path);
+	return loaded[name] ?? loaded["default"];
+}
+function isConfig(value) {
+	return configIssues(value).length === 0;
+}
+/**
+* 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. A discovered file sets the
+* project root to its own directory; `--config` keeps `cwd` as the root.
+*/
+async function loadConfig(cwd, explicit) {
+	const path = discoverConfig(cwd, explicit);
+	if (!path) return 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 resolveConfig(config, 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 void 0;
+	const url = (await io.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`, then the local stack. */
+async function databaseUrl(config, env, fromStdin) {
+	if (fromStdin) return fromStdin;
+	if (config.source.dbUrl) return config.source.dbUrl;
+	if (env.DATABASE_URL) return env.DATABASE_URL;
+	return `postgresql://postgres:postgres@127.0.0.1:${await readSupabasePort(config.root, "db") ?? 54322}/postgres`;
+}
+//#endregion
+export { loadConfig as a, importExport as i, discoverConfig as n, readSupabasePort as o, findConfig as r, stdinDatabaseUrl as s, databaseUrl as t };