better-supabase 0.14.0 → 0.15.0

package/dist/cli/add-BgsUjCan.js

@@ -0,0 +1,1252 @@
+import { a as list, p as commandMeta, r as defineCliCommand } from "./command-CQ61x6gN.js";
+import { i as plain } from "./style-Bm2X5JrN.js";
+import { t as VERSION } from "./version-Du4CgONY.js";
+import { a as parseNames, n as CliError } from "./errors-BTe6A15O.js";
+import { r as readIfExists, t as display } from "./io-DH1kcmmP.js";
+import { t as loadSnapshot } from "./snapshot-C8MVPyO8.js";
+import { t as isRecord } from "./guards-CUlDNYZs.js";
+import { a as toCatalog } from "./source-DANaJJVc.js";
+import { f as dataMigration } from "./module-migration-aPCckev6.js";
+import { a as findConfig, f as INTEGRATIONS, s as loadConfig } from "./config-9t5ec_N7.js";
+import { i as changeLines, n as PLAN_ARGS, r as applyPlan, u as planResult } from "./files-CX71yBm8.js";
+import { a as wiringFiles, d as libEntry, f as needsLib, i as wiringChecklist, l as importFrom, n as latestMigrationVersion, o as wiringFor, p as resolveIntegrations, s as TEMPLATES, u as isIntegration } from "./migration-safety-D7PhzFxm.js";
+import { n as installCommand, t as detectProject } from "./detect-D9JaAX20.js";
+import { d as setBlockInJson, f as setPathInConfig, h as setPresetInJson, m as setPresetInConfig, n as addBlocksToJson, p as setPathInJson, r as addBlocksToWiring, t as addBlocksToConfig, u as setBlockInConfig } from "./config-edit-CrWfk8s3.js";
+import { t as syncModules } from "./sync-btj01bcM.js";
+import { t as addModules } from "./add-DCI5JKjA.js";
+import { n as ident } from "./live-iEeH15ck.js";
+import { t as blockNames } from "./blocks-BZHI8mRC.js";
+import { i as sourceArgs, n as SOURCE_ARGS } from "./source-args-IpJRJO5t.js";
+import { existsSync } from "node:fs";
+import { dirname, join, posix, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { INTEGRATION_INFO, blockEntrySource } from "better-supabase/config";
+import { DEFAULT_CONVENTIONS, PRESET_CATALOG, PRESET_FRAMEWORKS, PRESET_NAMES, PRESET_TENANT_NAMES, designConfig, diffAppTables, glueCommand, isPresetName, presetAndDesignOf, presetField, presetFromSpec, presetSpec, presetValueLabel, readDesignFile, resolvePreset } from "better-supabase/preset";
+import { SQL_MODULES, adoptedColumnProblems, migrationOptionUses, moduleBody, moduleIdType } from "better-supabase/sql";
+import { toSnake } from "better-supabase";
+//#region src/cli/conventions.ts
+const arg = (key, description) => ({
+	type: "string",
+	description,
+	valueHint: presetField(key).values.join("|")
+});
+/** The convention flags `init` and `apply` take; each one overrides the preset. */
+const CONVENTION_ARGS = {
+	casing: arg("casing", "Row keys: snake keeps the database's names (the default), camel renames them in the query"),
+	scope: arg("scope", "Row ownership (database.sql.owner): tenant (the default), user or none for one shared space"),
+	"tenant-name": {
+		type: "string",
+		description: "What a tenant is called (blocks.memberships.names.organization): organization (the default), workspace, team or another lowercase name",
+		valueHint: "name"
+	},
+	access: arg("access", "Auth and permissions (blocks.permissions.model): roles (the default), catalog, provider or custom"),
+	"id-type": arg("idType", "The type of the permissions block's ids (blocks.permissions.idType): uuid (the default), text, bigint or integer"),
+	api: arg("api", "API schema (database.sql.api): none (the default) or api for security invoker wrappers in an api schema")
+};
+/** The flag of each convention. */
+const FLAGS = {
+	casing: "casing",
+	scope: "scope",
+	tenantName: "tenant-name",
+	access: "access",
+	idType: "id-type",
+	api: "api"
+};
+/** Every convention, in the order `init` asks for them (as on /create). */
+const KEYS = [
+	"casing",
+	"scope",
+	"tenantName",
+	"access",
+	"idType",
+	"api"
+];
+const TENANT_NAME = /^[a-z][a-z0-9_]{0,40}$/;
+/** The convention flags that were passed, each checked against its values. */
+function conventionFlags(args) {
+	const out = {};
+	for (const key of KEYS) {
+		const flag = FLAGS[key];
+		const value = args[flag];
+		if (value === void 0) continue;
+		if (key === "tenantName") {
+			if (!TENANT_NAME.test(value)) throw new CliError("usage", `--${flag} must be a lowercase name that starts with a letter (letters, digits and _), like workspace.`);
+		} else if (!presetField(key).values.some((each) => each === value)) throw new CliError("invalid_value", `--${flag} must be one of ${presetField(key).values.join(", ")}.`);
+		out[key] = value;
+	}
+	return out;
+}
+/** Whether any convention flag was passed. */
+const hasConventionFlags = (flags) => Object.keys(flags).length > 0;
+/**
+* `preset` with the flags' conventions. A preset holds the tenant names /create
+* offers, so another `--tenant-name` throws.
+*/
+function withConventions(preset, flags) {
+	let next = preset;
+	for (const key of KEYS) {
+		const value = flags[key];
+		if (value === void 0) continue;
+		if (key === "tenantName" && !PRESET_TENANT_NAMES.some((name) => name === value)) throw new CliError("usage", `--tenant-name with a preset takes ${PRESET_TENANT_NAMES.join(", ")}. Leave it out and set blocks.memberships.names.organization in the config for another name.`);
+		next = presetFromSpec({
+			...next,
+			[key]: value
+		});
+	}
+	return next;
+}
+/** The conventions with the flags over the defaults, for `--yes` and CI. */
+const defaultConventions = (flags) => ({
+	...DEFAULT_CONVENTIONS,
+	...flags
+});
+/**
+* Asks for each convention in /create's order, with its labels and hints. The
+* tenant name is asked only for tenant scope. Undefined when the person
+* cancels.
+*/
+async function promptConventions(prompts) {
+	const defaults = DEFAULT_CONVENTIONS;
+	const answers = {};
+	for (const key of KEYS) {
+		const scope = answers.scope ?? defaults.scope;
+		if (key === "tenantName" && scope !== "tenant") continue;
+		const field = presetField(key);
+		const values = key === "tenantName" ? PRESET_TENANT_NAMES : field.values;
+		const picked = await prompts.select(field.label, values.map((value) => {
+			const info = presetValueLabel(key, value);
+			return {
+				value,
+				label: info.label,
+				...info.hint === void 0 ? {} : { hint: info.hint }
+			};
+		}), defaults[key]);
+		if (picked === void 0) return;
+		answers[FLAGS[key]] = picked;
+	}
+	return {
+		...defaults,
+		...conventionFlags(answers)
+	};
+}
+/** The values a shell offers for each convention flag. */
+const CONVENTION_COMPLETIONS = {
+	casing: () => presetField("casing").values,
+	scope: () => presetField("scope").values,
+	"tenant-name": () => PRESET_TENANT_NAMES,
+	access: () => presetField("access").values,
+	"id-type": () => presetField("idType").values,
+	api: () => presetField("api").values
+};
+//#endregion
+//#region src/cli/glue.ts
+const CANCELLED = {
+	code: 1,
+	error: "Cancelled."
+};
+/**
+* `--force`, or the person's answer when files exist; `undefined` when they
+* cancel.
+*/
+async function overwrite(root, files, args, prompts, base = root) {
+	if (args.force === true) return true;
+	const existing = [...new Set(files.map((file) => file.path).filter((path) => existsSync(resolve(root, path))))];
+	if (!prompts || existing.length === 0) return false;
+	return prompts.confirm(`${existing.map((path) => display(base, resolve(root, path))).join(", ")} ${existing.length === 1 ? "exists" : "exist"}. Overwrite?`);
+}
+/**
+* Template files as a plan: each is written once, and an existing file is the
+* app's.
+*/
+function templatePlan(root, files, regenerate, base = root) {
+	return {
+		root,
+		base,
+		regenerate,
+		files: files.map((file) => ({
+			path: file.path,
+			contents: file.contents,
+			policy: "create"
+		}))
+	};
+}
+function templateContextFor(project, generated, blocks = false) {
+	return {
+		srcDir: project.srcDir,
+		generated,
+		tsExtensions: project.tsExtensions,
+		frameworks: project.frameworks,
+		version: VERSION,
+		blocks
+	};
+}
+function integrationFiles(names, templateContext) {
+	return names.flatMap((name) => TEMPLATES[name].files(templateContext));
+}
+function packagesFor(project, names) {
+	const wanted = [
+		"better-supabase",
+		"@supabase/supabase-js",
+		...names.flatMap((name) => TEMPLATES[name].packages)
+	];
+	return [...new Set(wanted)].filter((name) => !(name in project.dependencies));
+}
+function chooseIntegrations(prompts, initial) {
+	return prompts.multiselect("Integrations", INTEGRATIONS.map((name) => ({
+		value: name,
+		label: INTEGRATION_INFO[name].title,
+		hint: INTEGRATION_INFO[name].description
+	})), initial);
+}
+function parseIntegrations(values) {
+	return parseNames(values, isIntegration, "integration", INTEGRATIONS);
+}
+//#endregion
+//#region src/cli/sql/adopt.ts
+/**
+* Other names apps give a logical column. They are tried after the module's
+* default name and the logical name in snake case.
+*/
+const ALIASES = {
+	tenant: [
+		"organization_id",
+		"org_id",
+		"tenant_id",
+		"workspace_id",
+		"account_id",
+		"company_id"
+	],
+	user: [
+		"user_id",
+		"profile_id",
+		"owner_id",
+		"member_id"
+	],
+	createdBy: [
+		"created_by",
+		"author_id",
+		"creator_id",
+		"owner_id"
+	],
+	rank: [
+		"position",
+		"sort_order",
+		"sort_key",
+		"order_index"
+	],
+	key: ["id", "user_id"],
+	note: ["notes", "note"]
+};
+/** Whether the app's table can stand in for one of the block's tables. */
+const overAppTables = (block) => Object.values(SQL_MODULES[block]?.names?.tables ?? {}).some((table) => table.app !== void 0);
+/** The blocks with a table the app's table can stand in for, in registry order. */
+function adoptableBlocks() {
+	return Object.values(SQL_MODULES).filter((module) => overAppTables(module.name)).map((module) => module.name);
+}
+/**
+* `schema.table` from `table` or `schema.table`; an unqualified name is in
+* `public`.
+*/
+function qualifiedName(name) {
+	return name.includes(".") ? name : `public.${name}`;
+}
+/** The introspected tables in the shape a proposal reads. */
+function existingTables(tables) {
+	return tables.filter((table) => table.kind === "table");
+}
+function candidates(logical, physical) {
+	const snake = toSnake(logical);
+	const singular = physical.endsWith("s") ? physical.slice(0, -1) : void 0;
+	return [
+		physical,
+		snake,
+		`${snake}_id`,
+		`${physical}s`,
+		...singular === void 0 ? [] : [singular],
+		...ALIASES[logical] ?? []
+	];
+}
+/** The logical columns of `logical` matched to the columns of `table`. */
+function matchColumns(spec, table) {
+	const names = new Set(table.columns.map((column) => column.name));
+	const used = /* @__PURE__ */ new Set();
+	const matches = [];
+	for (const physical of Object.values(spec.columns)) if (names.has(physical)) used.add(physical);
+	for (const [logical, physical] of Object.entries(spec.columns)) {
+		if (names.has(physical)) {
+			matches.push({
+				logical,
+				column: physical,
+				by: "name"
+			});
+			continue;
+		}
+		const found = candidates(logical, physical).find((name) => names.has(name) && !used.has(name)) ?? unique(table.columns.map((column) => column.name).filter((name) => name.endsWith(`_${physical}`) && !used.has(name)));
+		if (found === void 0) matches.push(spec.optional?.includes(logical) === true ? {
+			logical,
+			column: null,
+			by: "missing"
+		} : {
+			logical,
+			column: null,
+			by: "added",
+			adds: physical
+		});
+		else {
+			used.add(found);
+			matches.push({
+				logical,
+				column: found,
+				by: "alias"
+			});
+		}
+	}
+	return matches;
+}
+const unique = (names) => names.length === 1 ? names[0] : void 0;
+/**
+* The share of logical columns a table matches, so a wide table doesn't win on
+* size.
+*/
+const score = (matches) => matches.length === 0 ? 0 : matches.filter((match) => match.column !== null).length / matches.length;
+/**
+* The table each logical table of `block` maps to: the tables in `from` go to
+* the logical tables whose columns they match best, and the rest are looked up
+* by the module's default names in `schemas`.
+*/
+function matchTables(block, tables, from, schemas, errors) {
+	const spec = Object.fromEntries(Object.entries(SQL_MODULES[block]?.names?.tables ?? {}).filter(([, table]) => table.app !== void 0));
+	const byName = new Map(tables.map((table) => [`${table.schema}.${table.name}`, table]));
+	const chosen = /* @__PURE__ */ new Map();
+	for (const name of from) {
+		const table = byName.get(qualifiedName(name));
+		if (table === void 0) {
+			errors.push(`${qualifiedName(name)} is not a table in the database.`);
+			continue;
+		}
+		const best = Object.entries(spec).filter(([logical]) => !chosen.has(logical)).map(([logical, names]) => ({
+			logical,
+			score: score(matchColumns(names, table)) + (table.name === names.name ? 1 : 0)
+		})).toSorted((left, right) => right.score - left.score)[0];
+		if (best === void 0 || best.score === 0) {
+			errors.push(`${qualifiedName(name)} matches none of the ${block} tables (${Object.keys(spec).join(", ")}).`);
+			continue;
+		}
+		chosen.set(best.logical, table);
+	}
+	for (const [logical, table] of Object.entries(spec)) {
+		if (chosen.has(logical) || table.app?.onlyWhenMapped === true) continue;
+		const found = schemas.map((schema) => byName.get(`${schema}.${table.name}`)).find((match) => match !== void 0);
+		if (found !== void 0) chosen.set(logical, found);
+		else if (table.optionalTable === true) chosen.set(logical, null);
+	}
+	if (chosen.size === 0) errors.push(`None of the ${block} tables (${Object.values(spec).map((table) => table.name).join(", ")}) is in the database. Pass yours with --tables.`);
+	return chosen;
+}
+const enumType = (column) => `"${column.typeSchema ?? "public"}"."${column.udt}"`;
+/**
+* A `create table` per table of the app's, with its enum types, for
+* `adoptedColumnProblems`.
+*/
+const declaration = (table) => [...table.columns.filter((column) => column.isEnum === true).map((column) => `create type ${enumType(column)} as enum ();`), `create table ${table.schema}.${table.name} (\n${table.columns.map((column) => `  "${column.name}" ${column.isEnum === true ? enumType(column) : column.udt}`).join(",\n")}\n);`].join("\n");
+/** The entry for `block` over the app's `tables`, and what can't map. */
+function proposeAdoption(block, tables, options = {}) {
+	const module = SQL_MODULES[block];
+	if (module === void 0 || !overAppTables(block)) return {
+		block,
+		entry: {},
+		tables: [],
+		errors: [module === void 0 ? `${block} is not a block. See \`better-supabase blocks list\`.` : `${block} creates all its tables. Blocks that can run over yours: ${adoptableBlocks().join(", ")}.`],
+		warnings: []
+	};
+	const errors = [];
+	const warnings = [];
+	const spec = module.names?.tables ?? {};
+	const chosen = matchTables(block, tables, options.from ?? [], options.schemas ?? ["public"], errors);
+	const matched = [];
+	const entryTables = {};
+	const entryColumns = {};
+	let idType;
+	for (const [logical, table] of Object.entries(spec)) {
+		if (!chosen.has(logical)) continue;
+		const existing = chosen.get(logical) ?? null;
+		if (existing === null) {
+			entryTables[logical] = null;
+			matched.push({
+				logical,
+				table: null,
+				columns: []
+			});
+			continue;
+		}
+		const name = `${existing.schema}.${existing.name}`;
+		entryTables[logical] = name;
+		const columns = matchColumns(table, existing);
+		matched.push({
+			logical,
+			table: name,
+			columns
+		});
+		const mapped = {};
+		for (const match of columns) {
+			if (match.column === null) {
+				if (table.optional?.includes(match.logical) === true) mapped[match.logical] = null;
+				else warnings.push(`${name} has no column for ${logical}.${match.logical}, so the block's migration adds ${table.columns[match.logical]}. Map blocks.${block}.columns.${logical}.${match.logical} instead when another column holds it.`);
+				continue;
+			}
+			if (match.column !== table.columns[match.logical]) mapped[match.logical] = match.column;
+			if (match.logical === "tenant" && idType === void 0) {
+				const udt = existing.columns.find((column) => column.name === match.column)?.udt;
+				const type = udt === void 0 ? void 0 : moduleIdType(udt);
+				if (type !== void 0 && type !== "uuid") idType = type;
+			}
+		}
+		if (Object.keys(mapped).length > 0) entryColumns[logical] = mapped;
+	}
+	const current = options.blocks?.[block];
+	const entry = {
+		...current,
+		tables: entryTables,
+		...Object.keys(entryColumns).length > 0 ? { columns: entryColumns } : {},
+		...idType === void 0 || current?.idType !== void 0 ? {} : { idType }
+	};
+	if (errors.length === 0) {
+		const blocks = {
+			...options.blocks,
+			[block]: entry
+		};
+		const adopted = [...chosen.values()].filter((table) => table !== null);
+		const ownTables = Object.fromEntries(tables.map((table) => [`${table.schema}.${table.name}`, "database"]));
+		try {
+			moduleBody(block, {
+				modules: blocks,
+				ownTables
+			});
+			errors.push(...adoptedColumnProblems(blocks, adopted.map((table) => ({ text: declaration(table) })), [...new Set(adopted.map((table) => table.schema))], ownTables));
+		} catch (error) {
+			errors.push(error instanceof Error ? error.message : String(error));
+		}
+		warnings.push(...migrationOptionUses({ [block]: entry }).map((use) => use.message));
+	}
+	return {
+		block,
+		entry,
+		tables: matched,
+		errors,
+		warnings
+	};
+}
+/**
+* Whether one of `block`'s logical tables has an existing table under its
+* default name, so `apply --adopt` proposes adopting the block.
+*/
+function hasDefaultTable(block, tables, schemas = ["public"]) {
+	const names = new Set(Object.values(SQL_MODULES[block]?.names?.tables ?? {}).map((table) => table.name));
+	return tables.some((table) => names.has(table.name) && schemas.includes(table.schema));
+}
+/** The proposal as lines: each table and column, then the errors and warnings. */
+function describeProposal(proposal) {
+	const lines = [];
+	for (const table of proposal.tables) {
+		lines.push(`  ${table.logical}: ${table.table ?? "null (not in the app)"}`);
+		const width = Math.max(0, ...table.columns.map((c) => c.logical.length));
+		for (const column of table.columns) {
+			const target = column.by === "added" ? `${column.adds} (the block adds it)` : column.column === null ? "null (not in the table)" : column.by === "alias" ? `${column.column} (guessed)` : column.column;
+			lines.push(`    ${column.logical.padEnd(width)}  ${target}`);
+		}
+	}
+	for (const error of proposal.errors) lines.push(`  error  ${error}`);
+	for (const warning of proposal.warnings) lines.push(`  warn   ${warning}`);
+	return lines;
+}
+//#endregion
+//#region src/cli/commands/adopt.ts
+const ADOPT_ARGS = {
+	block: {
+		type: "positional",
+		required: false,
+		description: "The block to adopt existing tables for"
+	},
+	tables: {
+		type: "string",
+		description: "The existing tables, as table or schema.table; the block's other tables are looked up by their default names",
+		valueHint: "schema.table,..."
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show the proposed mapping and the config diff, and write nothing"
+	},
+	check: {
+		type: "boolean",
+		description: "Write nothing; exit 1 with the diff when the config lacks this mapping"
+	}
+};
+/** The schemas searched for a block's default table names. */
+const adoptSchemas = (config) => [.../* @__PURE__ */ new Set(["public", ...config.schemas])];
+/** `source` with `blocks.<block>` set to the proposal's entry. */
+function withAdoptedBlock(file, source, proposal) {
+	return file.endsWith(".json") ? setBlockInJson(source, proposal.block, blockEntrySource(proposal.entry)) : setBlockInConfig(source, proposal.block, blockEntrySource(proposal.entry));
+}
+/**
+* `edit` with `doctor.migrationSafety.since` set to the newest migration when
+* the config has none, so doctor's lock checks skip the migrations that ran
+* before the tables were adopted.
+*/
+async function withMigrationSince(config, file, edit) {
+	if (!edit.ok || config.doctor.migrationSafety?.since !== void 0) return edit;
+	const since = await latestMigrationVersion(config.root);
+	if (since === void 0) return edit;
+	const path = [
+		"tooling",
+		"doctor",
+		"migrationSafety",
+		"since"
+	];
+	const next = file.endsWith(".json") ? setPathInJson(edit.text, path, since) : setPathInConfig(edit.text, path, since);
+	return next.ok ? next : edit;
+}
+/** The tables `loadSnapshot` reads, for the adopt commands. */
+function snapshotTables(config, env, source) {
+	return async () => existingTables(toCatalog(await loadSnapshot(config, env, source)).tables);
+}
+/**
+* Proposes `blocks.<block>` over existing tables, reports what can't map, and
+* writes the entry's `tables` and `columns` to the config when everything
+* maps.
+*/
+async function runAdopt(config, args, deps) {
+	const block = args.block;
+	if (block === void 0) throw new CliError("usage", "Name the block to adopt, e.g. `better-supabase add --adopt teams --tables public.teams`.");
+	const proposal = proposeAdoption(block, await deps.tables(), {
+		from: list(args.tables),
+		blocks: config.blocks,
+		schemas: adoptSchemas(config)
+	});
+	const lines = [`Adopting ${block}:`, ...describeProposal(proposal)];
+	const data = {
+		block,
+		entry: blockEntrySource(proposal.entry),
+		tables: proposal.tables,
+		errors: proposal.errors,
+		warnings: proposal.warnings
+	};
+	if (proposal.errors.length > 0) return {
+		code: 1,
+		output: lines.join("\n"),
+		error: `blocks.${block} wasn't written: fix what the report lists, then run adopt again.`,
+		data: {
+			...data,
+			written: false
+		}
+	};
+	const file = deps.configFile;
+	if (file === void 0) {
+		lines.push("", `No config file: add this to blocks yourself.`, `${block}: ${JSON.stringify(blockEntrySource(proposal.entry), null, 2)}`);
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	const edit = await withMigrationSince(config, file, withAdoptedBlock(file, await readFile(file, "utf-8"), proposal));
+	const shown = display(config.root, file);
+	if (!edit.ok) return {
+		code: 1,
+		output: lines.join("\n"),
+		error: `${shown} wasn't changed: ${edit.reason}. Set blocks.${block} in it yourself.`,
+		data: {
+			...data,
+			written: false
+		}
+	};
+	const paint = deps.paint ?? plain;
+	const plan = {
+		root: config.root,
+		regenerate: "better-supabase add --adopt",
+		files: [{
+			path: file,
+			contents: edit.text,
+			policy: "edit"
+		}]
+	};
+	const applied = await applyPlan(plan, args, paint);
+	if (applied.mode === "check") return planResult(plan, applied, { data: {
+		...data,
+		written: false
+	} });
+	if (applied.drift) lines.push("", ...applied.diffs);
+	if (applied.mode === "dry-run" || !applied.drift) {
+		lines.push("", applied.drift ? "Dry run: nothing written. Run without --dry-run to write it." : `${shown} already holds this mapping.`);
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	lines.push("", `Updated ${shown}. Run \`better-supabase upgrade\` to write the block's module over these tables.`);
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			...data,
+			written: true
+		}
+	};
+}
+//#endregion
+//#region src/cli/create-url.ts
+/**
+* A query parameter of a `/create` URL, decoded; undefined for a name or a
+* code.
+*/
+function createUrlParam(input, name) {
+	const value = input?.match(new RegExp(`[?&]${name}=([^&#]*)`))?.[1];
+	return value === void 0 || value === "" ? void 0 : decodeURIComponent(value);
+}
+/** What `init` and `apply` print for a URL with `&authz=`. */
+const AUTHZ_NOTE = "The authorization library chosen on Create isn't part of the preset. Open Get code on Create for its setup, then set `authorization` in the config to its adapter.";
+//#endregion
+//#region src/cli/preset-input.ts
+/** Whether `--preset` names a design file rather than a preset or URL. */
+const isDesignFilePath = (input) => input.endsWith(".json");
+/**
+* Reads `--preset`: a named preset, a design code, a `/create` URL, or the path
+* of a design file Create downloaded (relative to `root`). Throws a usage error
+* naming the problem.
+*/
+async function readPresetInput(input, root) {
+	try {
+		if (isDesignFilePath(input)) {
+			const path = resolve(root, input);
+			if (!existsSync(path)) throw new TypeError(`${input} doesn't exist. Download the design file from Create, or pass a preset name or a /create URL.`);
+			return readDesignFile(await readFile(path, "utf-8"));
+		}
+		return await presetAndDesignOf(input);
+	} catch (error) {
+		throw new CliError("usage", error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
+//#region src/cli/sql/design-edit.ts
+/** The `extraColumns` a block already has in the config, as plain strings. */
+function currentExtraColumns(config, module) {
+	const value = config?.blocks[module]?.options?.["extraColumns"];
+	if (!isRecord(value)) return {};
+	return Object.fromEntries(Object.entries(value).flatMap(([name, type]) => typeof type === "string" ? [[name, type]] : []));
+}
+/**
+* `source` with a `/create` design written into it: each block's
+* `options.extraColumns` (merged over the columns `config` already gives it)
+* and each design table under `tables`, replacing a table of the same name and
+* keeping the others. Positions only matter to the canvas and stay out.
+*/
+function writeDesign(file, source, design, config) {
+	const set = file.endsWith(".json") ? setPathInJson : setPathInConfig;
+	let text = source;
+	const apply = (path, value) => {
+		const edit = set(text, path, value);
+		if (!edit.ok) return `${path.join(".")} can't be set: ${edit.reason}`;
+		text = edit.text;
+	};
+	for (const [module, columns] of Object.entries(design.extraColumns ?? {})) {
+		const problem = apply([
+			"blocks",
+			module,
+			"options",
+			"extraColumns"
+		], {
+			...currentExtraColumns(config, module),
+			...columns
+		});
+		if (problem !== void 0) return {
+			ok: false,
+			reason: problem
+		};
+	}
+	for (const [name, table] of Object.entries(design.appTables ?? {})) {
+		const { scope, ...rest } = table;
+		const problem = apply(["tables", name], scope === void 0 ? rest : {
+			...rest,
+			owner: scope
+		});
+		if (problem !== void 0) return {
+			ok: false,
+			reason: problem
+		};
+	}
+	return {
+		ok: true,
+		text
+	};
+}
+//#endregion
+//#region src/cli/commands/apply.ts
+const APPLY_ARGS = {
+	preset: {
+		type: "string",
+		description: "A named preset, a design code from /create, its URL or a downloaded design file; the design sets the preset and adds its app tables and extra columns",
+		valueHint: "name|code|url|file"
+	},
+	package: {
+		type: "string",
+		description: "Workspace package whose config to edit, relative to --cwd; a Create URL's package= sets it too",
+		valueHint: "dir"
+	},
+	only: {
+		type: "string",
+		description: "blocks: add the preset's blocks to blocks and leave the conventions; conventions: take the conventions and no blocks",
+		valueHint: "blocks|conventions"
+	},
+	adopt: {
+		type: "boolean",
+		description: "Map existing tables onto a block (with --tables), the preset's blocks onto tables under their default names, or, alone, write the data rows migration for blocks over your tables"
+	},
+	"allow-breaking": {
+		type: "boolean",
+		description: "Write a design with breaking app table changes (a rename, a retyped or required column, a tighter constraint); renames print their alter statements"
+	},
+	"dry-run": {
+		type: "boolean",
+		description: "Show the config diff and write nothing"
+	},
+	check: {
+		type: "boolean",
+		description: "Write nothing; exit 1 with the diff when the config lacks the preset"
+	}
+};
+/**
+* `text` with a `tables` and `columns` entry for each of `blocks` that has a
+* table under one of its default names. A block in custom mode is left as it
+* is.
+*/
+function adoptBlocks(config, file, text, blocks, tables) {
+	const schemas = adoptSchemas(config);
+	const adoptable = new Set(adoptableBlocks());
+	const adopted = [];
+	const refused = [];
+	const lines = [];
+	let next = text;
+	for (const block of blocks) {
+		if (!adoptable.has(block) || !hasDefaultTable(block, tables, schemas)) continue;
+		if ((config.blocks[block]?.mode ?? "managed") !== "managed") continue;
+		const proposal = proposeAdoption(block, tables, {
+			blocks: config.blocks,
+			schemas
+		});
+		lines.push(`Adopting ${block}:`, ...describeProposal(proposal));
+		if (proposal.errors.length > 0) {
+			refused.push(proposal);
+			continue;
+		}
+		const edit = withAdoptedBlock(file, next, proposal);
+		if (!edit.ok) {
+			refused.push({
+				...proposal,
+				errors: [`blocks.${block} can't be set: ${edit.reason}.`]
+			});
+			continue;
+		}
+		next = edit.text;
+		adopted.push(proposal);
+	}
+	return {
+		text: next,
+		lines,
+		adopted,
+		refused
+	};
+}
+const describeConflicts = (preset) => {
+	const { conflicts } = resolvePreset(preset);
+	return conflicts.length === 0 ? void 0 : `The preset can't install: ${conflicts.map((conflict) => `${conflict.block ?? conflict.field ?? ""} (${conflict.reason})`).join("; ")}.`;
+};
+/**
+* The design `--preset` carries, checked against the blocks the config gets: an
+* extra column needs its block in the preset or the config.
+*/
+function designFor(config, design, preset) {
+	if (design === void 0) return;
+	const resolved = resolvePreset(preset);
+	const blocks = /* @__PURE__ */ new Set([...config.blockNames, ...resolved.blocks.map((block) => block.name)]);
+	for (const module of Object.keys(design.extraColumns ?? {})) if (!blocks.has(module)) throw new TypeError(`design.extraColumns.${module}: neither the preset nor the config installs the ${module} block`);
+	designConfig(resolved, design.appTables === void 0 ? {} : { appTables: design.appTables });
+	return design;
+}
+/** Each breaking change with its expand-and-contract steps. */
+function describeBreaking(changes) {
+	return ["Breaking changes to app tables:", ...changes.flatMap((change) => [`  ${change.summary}`, ...change.steps.map((step, index) => `    ${String(index + 1)}. ${step}`)])];
+}
+/**
+* The statements that rename the tables and columns `changes` renames, in
+* order.
+*/
+function renameStatements(changes) {
+	return changes.flatMap((change) => {
+		if (change.from === void 0) return [];
+		if (change.kind === "table.renamed") return [`alter table public.${ident(change.from)} rename to ${ident(change.table)};`];
+		if (change.kind === "column.renamed" && change.column !== void 0) return [`alter table public.${ident(change.table)} rename column ${ident(change.from)} to ${ident(change.column)};`];
+		return [];
+	});
+}
+/** How to run `renames` before `upgrade` creates the new names. */
+function describeRenames(renames, renamedTables, file) {
+	return renames.length === 0 ? [] : [
+		"Run these in a migration before `better-supabase upgrade`, so the renamed tables and columns keep their rows:",
+		...renames.map((statement) => `  ${statement}`),
+		...renamedTables.length === 0 ? [] : [`Then remove ${renamedTables.join(", ")} from tables in ${file}: apply keeps the tables a design leaves out.`],
+		""
+	];
+}
+/** The config file edited for `--only`: the `preset` key, or the blocks. */
+function edited(file, source, name, preset, only) {
+	const json = file.endsWith(".json");
+	if (only === "blocks") {
+		const names = resolvePreset(preset).blocks.map((block) => block.name);
+		return json ? addBlocksToJson(source, names) : addBlocksToConfig(source, names);
+	}
+	const value = only === "conventions" ? presetSpec({
+		...preset,
+		blocks: []
+	}) : name ?? presetSpec(preset);
+	return json ? setPresetInJson(source, value) : setPresetInConfig(source, value);
+}
+/**
+* The config of the workspace package `pkg` names, relative to the root
+* config's directory, and its file; the root config without one.
+*/
+async function packageTarget(config, deps, pkg, reload) {
+	if (pkg === void 0) return {
+		config,
+		deps
+	};
+	const root = resolve(config.root, posix.normalize(pkg.replaceAll("\\", "/")));
+	const file = findConfig(root);
+	if (file === void 0) throw new CliError("config_not_found", `--package ${pkg} has no better-supabase config. Start one with \`better-supabase init --package ${pkg}\`.`);
+	return {
+		config: await reload(root, file),
+		deps: {
+			...deps,
+			configFile: file
+		}
+	};
+}
+/**
+* Applies a preset to an existing project: sets `preset` in the config (or,
+* with `--only blocks`, lists its blocks), shows the diff, then writes the
+* module files of every block the config now holds.
+*/
+async function runApply(rootConfig, args, rootDeps) {
+	const input = args.preset;
+	if (input === void 0) throw new CliError("usage", "Pass --preset with a named preset, a code from /create, its URL or a downloaded design file.");
+	const only = args.only;
+	if (only !== void 0 && only !== "blocks" && only !== "conventions") throw new CliError("usage", "--only must be \"blocks\" or \"conventions\"");
+	const flags = conventionFlags(args);
+	if (only === "blocks" && hasConventionFlags(flags)) throw new CliError("usage", "--only blocks leaves the conventions, so it takes no convention flags.");
+	const reload = rootDeps.reload ?? ((root, path) => loadConfig(root, path));
+	const { config, deps } = await packageTarget(rootConfig, rootDeps, args.package ?? createUrlParam(input, "package"), reload);
+	const file = deps.configFile;
+	if (file === void 0) throw new CliError("config_not_found", `No config file to apply the preset to. Start a project with \`better-supabase init --preset ${input}\`.`);
+	const read = await readPresetInput(input, rootConfig.root);
+	const preset = withConventions(read.preset, flags);
+	const name = isPresetName(input) && !hasConventionFlags(flags) ? input : void 0;
+	let design;
+	try {
+		design = only === "conventions" ? void 0 : designFor(config, read.design, preset);
+	} catch (error) {
+		throw new CliError("usage", error instanceof Error ? error.message : String(error));
+	}
+	const conflict = describeConflicts(only === "conventions" ? {
+		...preset,
+		blocks: []
+	} : preset);
+	if (conflict !== void 0) throw new CliError("usage", conflict);
+	const changes = design?.appTables === void 0 ? [] : diffAppTables(config.appTables, design.appTables);
+	const kept = changes.filter((change) => change.kind === "table.dropped").map((change) => change.table);
+	const renamedTables = changes.flatMap((change) => change.kind === "table.renamed" && change.from !== void 0 ? [change.from] : []);
+	const breaking = changes.filter((change) => change.breaking && change.kind !== "table.dropped");
+	const renames = renameStatements(breaking);
+	const shown = display(config.root, file);
+	if (breaking.length > 0 && args["allow-breaking"] !== true && args["dry-run"] !== true) return {
+		code: 1,
+		output: describeBreaking(breaking).join("\n"),
+		data: {
+			file: shown,
+			written: false,
+			breaking,
+			kept
+		},
+		error: `Nothing was written: the design has ${breaking.length === 1 ? "a breaking change" : `${String(breaking.length)} breaking changes`} to tables the app already has. Follow the steps above, or pass --allow-breaking to write it anyway.`
+	};
+	const source = await readFile(file, "utf-8");
+	const edit = edited(file, source, name, preset, only);
+	if (!edit.ok) return {
+		code: 1,
+		error: `${shown} wasn't changed: ${edit.reason}. Set preset: ${JSON.stringify(presetSpec(preset))} in it yourself.`
+	};
+	const withDesign = design === void 0 ? edit : writeDesign(file, edit.text, design, config);
+	if (!withDesign.ok) return {
+		code: 1,
+		error: `${shown} wasn't changed: ${withDesign.reason}. Download the config from /create and copy its tables and extraColumns yourself.`
+	};
+	const paint = deps.paint ?? plain;
+	let text = withDesign.text;
+	const lines = [
+		...breaking.length === 0 ? [] : [...describeBreaking(breaking), ""],
+		...describeRenames(renames, renamedTables, shown),
+		...kept.length === 0 ? [] : [`Kept ${kept.join(", ")}: the design doesn't name ${kept.length === 1 ? "it" : "them"}, and apply keeps the tables a design leaves out. Remove ${kept.length === 1 ? "it" : "them"} from tables in ${shown} to drop ${kept.length === 1 ? "it" : "them"}.`, ""]
+	];
+	if (createUrlParam(input, "authz") !== void 0) lines.push(AUTHZ_NOTE, "");
+	let adopted = {};
+	if (args.adopt === true) {
+		if (only === "conventions" || deps.tables === void 0) throw new CliError("usage", only === "conventions" ? "--adopt maps blocks, and --only conventions takes none." : "--adopt needs the database or a snapshot to read the tables from.");
+		const adoption = adoptBlocks(config, file, text, resolvePreset(preset).blocks.map((block) => block.name), await deps.tables());
+		if (adoption.refused.length > 0) return {
+			code: 1,
+			output: adoption.lines.join("\n"),
+			data: {
+				file: shown,
+				written: false,
+				refused: Object.fromEntries(adoption.refused.map((proposal) => [proposal.block, proposal.errors]))
+			},
+			error: `Nothing was written: ${adoption.refused.map((proposal) => proposal.block).join(", ")} ${adoption.refused.length === 1 ? "has a table" : "have tables"} under the default names that can't be adopted as they are, and the managed block would skip them. Fix what the report lists, map them with \`better-supabase add --adopt <block> --tables <schema.table>\`, or leave the block out of the preset.`
+		};
+		text = adoption.text;
+		adopted = Object.fromEntries(adoption.adopted.map((proposal) => [proposal.block, blockEntrySource(proposal.entry)]));
+		lines.push(...adoption.lines.length === 0 ? ["No existing tables to adopt: every block stays managed."] : adoption.lines, "");
+	}
+	const data = {
+		file: shown,
+		adopted,
+		contents: text,
+		kept,
+		...renames.length === 0 ? {} : { renames }
+	};
+	if (text === source) {
+		lines.push(`${shown} already holds the preset.`);
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	const plan = {
+		root: config.root,
+		regenerate: "better-supabase add",
+		files: [{
+			path: file,
+			contents: text,
+			policy: "edit"
+		}]
+	};
+	const applied = await applyPlan(plan, args, paint);
+	if (applied.mode === "check") return planResult(plan, applied, { data: {
+		...data,
+		written: false
+	} });
+	lines.push(...applied.diffs);
+	if (applied.mode === "dry-run") {
+		lines.push("", "Dry run: nothing written. Run without --dry-run to apply it.");
+		return {
+			code: 0,
+			output: lines.join("\n"),
+			data: {
+				...data,
+				written: false
+			}
+		};
+	}
+	const next = await reload(config.root, file);
+	const synced = await syncModules(next, {}, paint, deps.now);
+	lines.push("", `Updated ${shown}.`, "", synced.output ?? synced.error ?? "");
+	return {
+		code: synced.code,
+		output: lines.join("\n"),
+		data: {
+			...data,
+			written: true
+		}
+	};
+}
+//#endregion
+//#region src/cli/commands/add.ts
+const ADD_ARGS = {
+	block: {
+		type: "positional",
+		required: false,
+		variadic: true,
+		description: "Blocks to install with what they require (`better-supabase blocks list`). Without blocks or --integration, sets up the integrations in the config that have no files yet"
+	},
+	integration: {
+		type: "string",
+		description: "Adds glue for integrations instead: next, hono, orpc, edge, expo, mcp, client or react",
+		valueHint: "integration,..."
+	},
+	force: {
+		type: "boolean",
+		description: "Overwrite files that exist"
+	},
+	"allow-hook-overlap": {
+		type: "boolean",
+		description: "With blocks: write modules whose claim the authorization provider's hook already writes"
+	},
+	"tests-dir": {
+		type: "string",
+		description: "With blocks: where the pgtap module goes. Defaults to database.sql.testsDir",
+		valueHint: "dir"
+	}
+};
+/**
+* Adds blocks: lists them in `blocks`, writes their modules and what they
+* require (`add`), wires the ones with a client into `lib/blocks.ts`, and names
+* the registry glue for the project's frameworks.
+*/
+async function addBlocks(config, args, names, deps) {
+	const added = await addModules(config, {
+		...args,
+		_: ["add", ...names]
+	}, names, deps);
+	if (added.code !== 0) return added;
+	const lines = [added.output ?? ""];
+	const project = await detectProject(config.root);
+	const context = templateContextFor(project, config.output);
+	const resolved = resolvePreset({
+		...DEFAULT_CONVENTIONS,
+		blocks: [...config.blockNames, ...names]
+	});
+	const wanted = new Set(resolvePreset({
+		...DEFAULT_CONVENTIONS,
+		blocks: names
+	}).manifests.map((manifest) => manifest.name));
+	const clients = blockClients(resolved.manifests.filter((manifest) => wanted.has(manifest.name)));
+	if (clients.length > 0) {
+		const wiring = blocksWiringPath(context);
+		const path = resolve(config.root, wiring);
+		const current = await readIfExists(path);
+		const edit = current === void 0 ? void 0 : addBlocksToWiring(current, clients);
+		if (edit?.ok === true && edit.text !== current) {
+			await applyPlan({
+				root: config.root,
+				regenerate: "better-supabase add",
+				files: [{
+					path,
+					contents: edit.text,
+					policy: "edit"
+				}]
+			}, { "dry-run": args["dry-run"] });
+			lines.push("", `${args["dry-run"] === true ? "Would wire" : "Wired"} ${clients.map((client) => client.key).join(", ")} in ${wiring}.`);
+		} else if (edit?.ok !== true) lines.push("", `Wire the clients in ${wiring}${edit === void 0 ? " (it doesn't exist yet)" : ` (${edit.reason})`}:`, ...clients.map((client) => `  import { ${client.export} } from "${client.subpath}";  // ${client.key}: ${client.export}`));
+	}
+	const frameworks = PRESET_FRAMEWORKS.filter((framework) => config.integrations.some((name) => name === framework) || project.frameworks.some((name) => name === framework));
+	const installed = new Set(resolved.blocks.map((block) => block.name));
+	const glue = PRESET_CATALOG.glue.filter((item) => item.preset === void 0 && item.blocks.some((block) => names.includes(block)) && item.blocks.every((block) => installed.has(block)) && item.frameworks.some((framework) => frameworks.some((each) => each === framework)));
+	const glueLine = glue.length > 0 ? glueCommand(glue) : void 0;
+	const wiring = wiringFor([...wanted].map((name) => ({
+		name,
+		block: name
+	})));
+	const written = await wiringFiles(context, wiring, (path) => readIfExists(resolve(config.root, path)));
+	if (written.files.length > 0) {
+		const applied = await applyPlan({
+			root: config.root,
+			regenerate: "better-supabase add",
+			files: written.files
+		}, { "dry-run": args["dry-run"] });
+		lines.push("", ...changeLines(applied));
+	}
+	lines.push(...written.notes.length > 0 ? ["", ...written.notes] : []);
+	const checklist = wiringChecklist(context, wiring, glueLine);
+	if (checklist.length > 0) lines.push("", "To finish the wiring:", ...checklist);
+	else if (glueLine !== void 0) lines.push("", `Glue for ${frameworks.join(", ")}: ${glueLine}`);
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			blocks: names,
+			modules: added.data,
+			clients: clients.map((client) => client.key),
+			...glueLine === void 0 ? {} : { glue: glueLine },
+			wiring: {
+				env: wiring.env.map((entry) => entry.key),
+				providers: wiring.providers.map((entry) => `${entry.instance}.${entry.provider.option}`),
+				workers: wiring.workers.map((worker) => worker.name),
+				actions: wiring.actions.map((action) => action.kind),
+				schedules: wiring.schedules.map((schedule) => `${schedule.block}.${schedule.name}`),
+				files: written.files.map((file) => file.path)
+			}
+		},
+		...added.next === void 0 ? {} : { next: added.next }
+	};
+}
+/** The clients `lib/blocks.ts` wires for `manifests`, keyed in camelCase. */
+function blockClients(manifests) {
+	return manifests.flatMap((manifest) => manifest.client === null ? [] : [{
+		key: manifest.name.replaceAll(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase()),
+		export: manifest.client.export,
+		subpath: manifest.client.subpath
+	}]);
+}
+/** `lib/blocks.ts` next to `lib/supabase/`. */
+function blocksWiringPath(context) {
+	return join(dirname(dirname(libEntry(context))), "blocks.ts");
+}
+/**
+* How `lib/blocks.ts` imports the `blocks.generated.ts` that `gen` writes next
+* to `generated.ts`.
+*/
+function blockConfigImport(context) {
+	return importFrom(context, blocksWiringPath(context), join(dirname(context.generated), "blocks.generated.ts"));
+}
+const SYSTEM_DEPS = { now: () => /* @__PURE__ */ new Date() };
+async function runAdd(config, args, prompts, deps = SYSTEM_DEPS) {
+	if (args._.length > 0 && args.integration === void 0) return addBlocks(config, args, args._, deps);
+	if (args.integration !== void 0) return addIntegrations(config, {
+		...args,
+		_: list(args.integration)
+	}, prompts);
+	return addIntegrations(config, args, prompts);
+}
+async function addIntegrations(config, args, prompts) {
+	const project = await detectProject(config.root);
+	const templateContext = templateContextFor(project, config.output, config.blockNames.length > 0);
+	const fromConfig = args._.length === 0 && config.integrations.length > 0;
+	const missing = config.integrations.filter((name) => integrationFiles([name], templateContext).some((file) => !existsSync(resolve(config.root, file.path))));
+	if (fromConfig && missing.length === 0) return {
+		code: 0,
+		output: `Every integration in the config is set up: ${config.integrations.join(", ")}.`,
+		data: {
+			integrations: [],
+			files: [],
+			packages: [],
+			unlisted: []
+		}
+	};
+	const named = fromConfig ? missing : args._.length === 0 && prompts ? await chooseIntegrations(prompts, []) : args._;
+	if (named === void 0) return CANCELLED;
+	if (named.length === 0) throw new CliError("usage", `Name at least one integration (${INTEGRATIONS.join(", ")}), or list them in integrations in the config.`);
+	const requested = parseIntegrations(named);
+	if (typeof requested === "string") throw new CliError("usage", requested);
+	const integrations = resolveIntegrations(requested);
+	const files = integrationFiles(integrations, templateContext);
+	const force = await overwrite(config.root, files, args, prompts);
+	if (force === void 0) return CANCELLED;
+	const plan = templatePlan(config.root, files, "better-supabase add");
+	const applied = await applyPlan(plan, {
+		...args,
+		force
+	});
+	if (applied.mode === "check" && applied.drift) return planResult(plan, applied);
+	const lines = changeLines(applied);
+	const lib = libEntry(templateContext);
+	const libMissing = !existsSync(resolve(config.root, lib)) && integrations.some((name) => needsLib([name]));
+	const next = [];
+	if (libMissing) {
+		next.push({
+			command: "better-supabase init",
+			when: `${lib} is missing`
+		});
+		lines.push("", `Warning: ${lib} is missing. Run \`better-supabase init\` first.`);
+	}
+	const packages = packagesFor(project, integrations).filter((name) => name !== "better-supabase" && name !== "@supabase/supabase-js");
+	const install = packages.length > 0 ? installCommand(project.packageManager, packages) : void 0;
+	if (install !== void 0) {
+		lines.push("", `Install: ${install}`);
+		next.push({
+			command: install,
+			when: "to install the packages they need"
+		});
+	}
+	for (const name of integrations) for (const hint of TEMPLATES[name].next ?? []) lines.push(`- ${hint}`);
+	const unlisted = integrations.filter((name) => !config.integrations.includes(name));
+	if (unlisted.length > 0) lines.push("", "Add them to your config so `better-supabase add` sets them up in a fresh checkout:", `  adapters: [${[...config.integrations, ...unlisted].map((name) => `'${name}'`).join(", ")}]`);
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			integrations,
+			files: applied.changes,
+			packages,
+			unlisted
+		},
+		next
+	};
+}
+const ADD_COMMAND_ARGS = {
+	...ADD_ARGS,
+	...APPLY_ARGS,
+	tables: ADOPT_ARGS.tables,
+	...CONVENTION_ARGS,
+	...SOURCE_ARGS,
+	"dry-run": PLAN_ARGS["dry-run"],
+	check: PLAN_ARGS.check
+};
+/** The flags only `--preset` reads, and the flags only `--adopt` reads. */
+const PRESET_ONLY = [
+	"package",
+	"only",
+	"allow-breaking",
+	...Object.keys(CONVENTION_ARGS)
+];
+/** A usage error for the first flag in `flags` that `args` sets. */
+function unexpected(args, flags, needs) {
+	const flag = flags.find((name) => args[name] !== void 0);
+	if (flag !== void 0) throw new CliError("usage", `--${flag} works with ${needs}.`, { flag: `--${flag}` });
+}
+const addCommand = defineCliCommand({
+	meta: commandMeta("add"),
+	args: ADD_COMMAND_ARGS,
+	lists: ["integration", "tables"],
+	completions: {
+		...CONVENTION_COMPLETIONS,
+		block: blockNames,
+		preset: () => PRESET_NAMES,
+		only: () => ["blocks", "conventions"]
+	},
+	run: async (args, { config, configFile, env, io, log, paint, signal }) => {
+		const deps = configFile === void 0 ? {} : { configFile };
+		const tables = snapshotTables(config, env, {
+			...await sourceArgs(args, io),
+			...signal ? { signal } : {}
+		});
+		if (args.preset !== void 0) {
+			if (args._.length > 0) throw new CliError("usage", "Pass blocks or --preset, not both: a preset names its own blocks.");
+			return runApply(config, args, {
+				now: SYSTEM_DEPS.now,
+				paint,
+				tables,
+				...deps
+			});
+		}
+		unexpected(args, PRESET_ONLY, "--preset");
+		if (args.adopt === true) {
+			if (args._.length === 0) {
+				unexpected(args, ["tables"], "--adopt and one block");
+				return dataMigration(config, args, SYSTEM_DEPS.now);
+			}
+			if (args._.length > 1) throw new CliError("usage", "Adopt one block at a time.");
+			return runAdopt(config, {
+				...args,
+				block: args._[0]
+			}, {
+				paint,
+				tables: () => log.progress("Reading the schema", tables),
+				...deps
+			});
+		}
+		unexpected(args, ["tables"], "--adopt");
+		return runAdd(config, args, io.prompts, {
+			...SYSTEM_DEPS,
+			...deps
+		});
+	}
+});
+//#endregion
+export { promptConventions as C, hasConventionFlags as S, templatePlan as _, runAdd as a, conventionFlags as b, AUTHZ_NOTE as c, chooseIntegrations as d, integrationFiles as f, templateContextFor as g, parseIntegrations as h, blocksWiringPath as i, createUrlParam as l, packagesFor as m, blockClients as n, writeDesign as o, overwrite as p, blockConfigImport as r, readPresetInput as s, addCommand as t, CANCELLED as u, CONVENTION_ARGS as v, withConventions as w, defaultConventions as x, CONVENTION_COMPLETIONS as y };