better-supabase 0.8.0 → 0.10.0

package/dist/create/index.js

@@ -0,0 +1,2049 @@
+import { c as PRESET_CATALOG, i as presetOf, s as resolvePreset } from "../config-C4RQDF6t.js";
+import { a as appDefaultError, c as appReservedColumns, o as appIdentifierError, p as isAppDefault, s as appNameLengthError, x as APP_ON_DELETE_ACTIONS } from "../app-tables-BRjMcWhW.js";
+import { o as resolveConfig } from "../config-CkyahUjo.js";
+import { c as designConfig, n as diffDesigns } from "../preset-BBrL6_Ln.js";
+import { E as SQL_MODULES, i as moduleLayout, m as renderModules } from "../sql-CgTZOQZ7.js";
+//#region src/create/column-keys.ts
+/** The most options a select takes, and the longest option. */
+const MAX_OPTIONS = 100;
+const MAX_OPTION = 100;
+const AUTH_USERS$2 = "auth.users";
+/** The column types each format fits, as `appTables` checks them. */
+const FORMAT_TYPES = {
+	email: ["text"],
+	url: ["text"],
+	phone: ["text"],
+	long_text: ["text"],
+	color: ["text"],
+	rating: ["integer", "bigint"],
+	percent: ["integer", "numeric"],
+	currency: ["bigint"]
+};
+const FORMAT_LABELS = {
+	email: "email",
+	url: "url",
+	phone: "phone",
+	long_text: "long text",
+	color: "color",
+	rating: "rating",
+	percent: "percent",
+	currency: "money"
+};
+const NUMBER_TYPES = /* @__PURE__ */ new Set([
+	"integer",
+	"bigint",
+	"numeric"
+]);
+const CONTROL = /\p{Cc}/u;
+/**
+* Whether a column signed-in users can't write is required with no default,
+* which `appTables` refuses: nobody but the server could insert a row.
+*/
+function lockedWithoutDefault(column) {
+	return column.access !== void 0 && column.nullable === false && column.default === void 0 && column.identity !== true;
+}
+/** Whether `min` and `max` apply to a `type` column, as a value or a length. */
+function takesBounds(type) {
+	return type === "text" || NUMBER_TYPES.has(type);
+}
+/** Whether a bound of a `type` column has to be a whole number. */
+function wholeBounds(type) {
+	return type !== "numeric";
+}
+function fitsBound(type, value) {
+	return value !== void 0 && takesBounds(type) && (!wholeBounds(type) || Number.isInteger(value)) && (type !== "text" || value >= 0);
+}
+/**
+* A column without the keys its type can't take: a format of another type,
+* options outside text and text[], bounds that don't apply, an identity
+* outside integer and bigint, and a default an identity or the type refuses.
+*/
+function fitted(column) {
+	const { format, options, min, max, identity, default: fallback, nullable, ...rest } = column;
+	const { type } = column;
+	const counted = identity === true && (type === "integer" || type === "bigint");
+	const next = { ...rest };
+	if (nullable !== void 0 && !(counted && nullable)) next.nullable = nullable;
+	if (fallback !== void 0 && !counted && isAppDefault(type, fallback)) next.default = fallback;
+	if (format !== void 0 && FORMAT_TYPES[format].includes(type)) next.format = format;
+	if (options !== void 0 && (type === "text" || type === "text[]")) next.options = options;
+	if (fitsBound(type, min)) next.min = min;
+	if (fitsBound(type, max)) next.max = max;
+	if (counted) next.identity = true;
+	return next;
+}
+/** Why `option` can't join a select's `options`, or `undefined` when it can. */
+function optionError(options, option) {
+	if (option === "") return "Enter an option.";
+	if (option.length > MAX_OPTION) return `Use at most ${MAX_OPTION} characters.`;
+	if (CONTROL.test(option)) return "Leave out line breaks and tabs.";
+	if (options.includes(option)) return `${option} is already an option.`;
+	if (options.length >= MAX_OPTIONS) return `A select takes at most ${MAX_OPTIONS} options.`;
+}
+/** Why `value` can't be a bound of `column`, or `undefined` when it can (an empty value clears it). */
+function boundError(column, side, value) {
+	const trimmed = value.trim();
+	if (trimmed === "") return;
+	const number = Number(trimmed);
+	if (!Number.isFinite(number)) return "Enter a number.";
+	if (column.type === "text" && (!Number.isInteger(number) || number < 0)) return "A length is a whole number of 0 or more.";
+	if (wholeBounds(column.type) && !Number.isInteger(number)) return `A ${column.type} bound is a whole number.`;
+	if (side === "min" && column.max !== void 0 && number > column.max) return `Keep it at or below the largest value, ${column.max}.`;
+	if (side === "max" && column.min !== void 0 && number < column.min) return `Keep it at or above the smallest value, ${column.min}.`;
+}
+/** `column` with its bounds replaced; a bound left out is removed. */
+function withBounds(column, bounds) {
+	const { min: _min, max: _max, ...rest } = column;
+	const next = { ...rest };
+	if (bounds.min !== void 0) next.min = bounds.min;
+	if (bounds.max !== void 0) next.max = bounds.max;
+	return next;
+}
+/** What the canvas shows for a column that is more than its type, such as an email or a select. */
+function columnLabel(column) {
+	if (column.identity === true) return "autonumber";
+	if (column.options !== void 0) return column.type === "text[]" ? "multi-select" : "select";
+	if (column.references?.block === void 0 && column.references?.table === AUTH_USERS$2) return "person";
+	return column.format === void 0 ? void 0 : FORMAT_LABELS[column.format];
+}
+//#endregion
+//#region src/create/design-computed.ts
+/** The aggregates a rollup takes (`APP_ROLLUP_AGGREGATES`). */
+const ROLLUP_AGGREGATES = [
+	"count",
+	"sum",
+	"min",
+	"max",
+	"avg"
+];
+const NUMBERS = /* @__PURE__ */ new Set([
+	"integer",
+	"bigint",
+	"numeric"
+]);
+const ORDERED = /* @__PURE__ */ new Set([
+	...NUMBERS,
+	"date",
+	"timestamptz",
+	"text"
+]);
+function isRollupAggregate(value) {
+	return ROLLUP_AGGREGATES.some((each) => each === value);
+}
+/** The columns of `table` a rollup or lookup can read, with their types. */
+function readableColumns(table) {
+	return [...Object.entries(table.columns ?? {}).map(([name, column]) => [name, column.type]), ...table.timestamps === false ? [] : [["created_at", "timestamptz"], ["updated_at", "timestamptz"]]];
+}
+/** The columns `aggregate` can read: numbers for sum and avg, ordered types for min and max, none for count. */
+function rollupColumns(child, aggregate) {
+	if (aggregate === "count") return [];
+	const fits = aggregate === "sum" || aggregate === "avg" ? NUMBERS : ORDERED;
+	return readableColumns(child).filter(([, type]) => fits.has(type)).map(([name]) => name);
+}
+/** The select columns of `child` (text with options) a rollup can filter on. */
+function filterColumns(child) {
+	return Object.entries(child.columns ?? {}).flatMap(([name, column]) => column.type === "text" && column.options !== void 0 ? [[name, column.options]] : []);
+}
+/** Each app table column that references `parent`, as `{ table, via }`: what a rollup on `parent` can aggregate. */
+function rollupSources(tables, parent) {
+	return Object.entries(tables).flatMap(([table, config]) => Object.entries(config.columns ?? {}).filter(([, column]) => column.references !== void 0 && column.references.block === void 0 && column.references.table === parent).map(([via]) => ({
+		table,
+		via
+	})));
+}
+/** Each column of `name` that references another app table, with that table: what a lookup can follow. */
+function lookupSources(tables, name) {
+	return Object.entries(tables[name]?.columns ?? {}).flatMap(([via, column]) => column.references !== void 0 && column.references.block === void 0 && Object.hasOwn(tables, column.references.table) ? [{
+		via,
+		target: column.references.table
+	}] : []);
+}
+function rollupValid(tables, parent, rollup) {
+	const child = tables[rollup.table];
+	if (child === void 0 || !rollupSources(tables, parent).some((each) => each.table === rollup.table && each.via === rollup.via)) return false;
+	const column = rollup.aggregate === "count" ? rollup.column === void 0 : rollup.column !== void 0 && rollupColumns(child, rollup.aggregate).includes(rollup.column);
+	const where = rollup.where === void 0 || filterColumns(child).some(([name, options]) => name === rollup.where?.column && options.includes(rollup.where.equals));
+	return column && where;
+}
+function lookupValid(tables, name, lookup) {
+	const source = lookupSources(tables, name).find((each) => each.via === lookup.via);
+	const target = source === void 0 ? void 0 : tables[source.target];
+	return target !== void 0 && readableColumns(target).some(([column]) => column === lookup.column);
+}
+function kept(record, keep) {
+	if (record === void 0) return;
+	const entries = Object.entries(record).filter(([name, value]) => keep(name, value));
+	return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+}
+/** `table` with its rollups and lookups replaced, leaving out an empty set. */
+function withComputed(table, rollups, lookups) {
+	const { rollups: _rollups, lookups: _lookups, ...rest } = table;
+	const next = { ...rest };
+	if (rollups !== void 0 && Object.keys(rollups).length > 0) next.rollups = rollups;
+	if (lookups !== void 0 && Object.keys(lookups).length > 0) next.lookups = lookups;
+	return next;
+}
+/** `table` with a rollup or lookup set under `name`, replacing `previous` in its place. */
+function tableWithComputed(table, name, computed, previous) {
+	const placed = (record, value) => {
+		const entries = Object.entries(record ?? {});
+		const added = [name, value];
+		return Object.fromEntries(entries.some(([each]) => each === previous) ? entries.map(([each, config]) => each === previous ? added : [each, config]) : [...entries, added]);
+	};
+	return "rollup" in computed ? withComputed(table, placed(table.rollups, computed.rollup), table.lookups) : withComputed(table, table.rollups, placed(table.lookups, computed.lookup));
+}
+/** `table` without the rollup or lookup `name`. */
+function tableWithoutComputed(table, name) {
+	return withComputed(table, kept(table.rollups, (each) => each !== name), kept(table.lookups, (each) => each !== name));
+}
+/**
+* The tables with every rollup and lookup that no longer fits dropped: one
+* whose table, link or column was deleted or retyped, or whose name a
+* column now uses. `sql sync` would refuse them, and the design code would
+* not encode.
+*/
+function prunedComputed(tables) {
+	return Object.fromEntries(Object.entries(tables).map(([name, table]) => {
+		const own = new Set(Object.keys(table.columns ?? {}));
+		const rollups = kept(table.rollups, (column, rollup) => !own.has(column) && rollupValid(tables, name, rollup));
+		return [name, withComputed(table, rollups, kept(table.lookups, (column, lookup) => !own.has(column) && rollups?.[column] === void 0 && lookupValid(tables, name, lookup)))];
+	}));
+}
+/** The rollups that aggregate `from`, pointed at `to`. */
+function computedTableRenamed(tables, from, to) {
+	return Object.fromEntries(Object.entries(tables).map(([name, table]) => [name, table.rollups === void 0 ? table : {
+		...table,
+		rollups: Object.fromEntries(Object.entries(table.rollups).map(([column, rollup]) => [column, rollup.table === from ? {
+			...rollup,
+			table: to
+		} : rollup]))
+	}]));
+}
+/** The rollup fitted to a new source or aggregate: a column the aggregate can read, and a filter the child still has. */
+function fittedRollup(tables, rollup) {
+	const child = tables[rollup.table] ?? {};
+	const columns = rollupColumns(child, rollup.aggregate);
+	const aggregate = rollup.aggregate !== "count" && columns.length === 0 ? "count" : rollup.aggregate;
+	const column = aggregate === "count" ? void 0 : rollup.column !== void 0 && columns.includes(rollup.column) ? rollup.column : columns[0];
+	const where = rollup.where !== void 0 && filterColumns(child).some(([name, options]) => name === rollup.where?.column && options.includes(rollup.where.equals)) ? rollup.where : void 0;
+	const next = {
+		table: rollup.table,
+		via: rollup.via,
+		aggregate
+	};
+	if (column !== void 0) next.column = column;
+	if (where !== void 0) next.where = where;
+	return next;
+}
+function rollupRenamed(rollup, swap) {
+	const next = {
+		...rollup,
+		via: swap(rollup.via)
+	};
+	if (rollup.column !== void 0) next.column = swap(rollup.column);
+	if (rollup.where !== void 0) next.where = {
+		...rollup.where,
+		column: swap(rollup.where.column)
+	};
+	return next;
+}
+/**
+* Every rollup and lookup that reads `table.from`, reading `table.to`. The
+* tables already have the column renamed, so a lookup finds its target
+* through the renamed link.
+*/
+function computedColumnRenamed(tables, table, from, to) {
+	const swap = (column) => column === from ? to : column;
+	const lookupTarget = (owner, via) => {
+		const reference = tables[owner]?.columns?.[via]?.references;
+		return reference?.block === void 0 ? reference?.table : void 0;
+	};
+	return Object.fromEntries(Object.entries(tables).map(([name, config]) => {
+		return [name, withComputed(config, config.rollups === void 0 ? void 0 : Object.fromEntries(Object.entries(config.rollups).map(([column, rollup]) => [column, rollup.table === table ? rollupRenamed(rollup, swap) : rollup])), config.lookups === void 0 ? void 0 : Object.fromEntries(Object.entries(config.lookups).map(([column, lookup]) => {
+			const via = name === table ? swap(lookup.via) : lookup.via;
+			return [column, {
+				via,
+				column: lookupTarget(name, via) === table ? swap(lookup.column) : lookup.column
+			}];
+		})))];
+	}));
+}
+function rollupSummary(rollup) {
+	const what = rollup.aggregate === "count" ? `count of ${rollup.table}` : `${rollup.aggregate} of ${rollup.table}.${rollup.column ?? ""}`;
+	return rollup.where === void 0 ? what : `${what} where ${rollup.where.column} = ${rollup.where.equals}`;
+}
+/** The rollups and lookups of an app table, in the view's column order. */
+function computedRows(table) {
+	return [...Object.entries(table.rollups ?? {}).map(([name, rollup]) => ({
+		name,
+		kind: "rollup",
+		summary: rollupSummary(rollup),
+		label: rollup.aggregate
+	})), ...Object.entries(table.lookups ?? {}).map(([name, lookup]) => {
+		return {
+			name,
+			kind: "lookup",
+			summary: `${table.columns?.[lookup.via]?.references?.table ?? lookup.via}.${lookup.column} through ${lookup.via}`,
+			label: "lookup"
+		};
+	})];
+}
+//#endregion
+//#region src/create/design-subject.ts
+/** The columns `subject` adds: `rank` for manual order and `deleted_at` for trash. */
+function subjectColumns(subject) {
+	const columns = [];
+	if (subject?.rank !== void 0) columns.push({
+		name: "rank",
+		type: "text",
+		nullable: false,
+		default: "'V'",
+		unique: false
+	});
+	if (subject?.softDelete === true) columns.push({
+		name: "deleted_at",
+		type: "timestamptz",
+		nullable: true,
+		default: null,
+		unique: false
+	});
+	return columns;
+}
+/** The subject with the columns it names renamed or dropped by `edit`. */
+function subjectColumnsEdited(subject, edit) {
+	const { title, search, rank, versions, ...rest } = subject;
+	const next = { ...rest };
+	const [nextTitle] = title === void 0 ? [] : edit([title]);
+	if (nextTitle !== void 0) next.title = nextTitle;
+	if (search !== void 0) {
+		const nextSearch = {};
+		const [searchTitle] = search.title === void 0 ? [] : edit([search.title]);
+		const body = edit(search.body ?? []);
+		if (searchTitle !== void 0) nextSearch.title = searchTitle;
+		if (body.length > 0) nextSearch.body = body;
+		next.search = nextSearch;
+	}
+	if (versions === true) next.versions = true;
+	else if (versions !== void 0) {
+		const { columns, ...options } = versions;
+		const kept = columns === void 0 ? void 0 : edit(columns);
+		next.versions = kept === void 0 || kept.length === 0 ? options : {
+			...options,
+			columns: kept
+		};
+	}
+	if (rank === true) next.rank = true;
+	else if (rank !== void 0) {
+		const [group] = rank.group === void 0 ? [] : edit([rank.group]);
+		next.rank = group === void 0 ? true : { group };
+	}
+	return next;
+}
+const SUBJECT_TYPE = /^[a-z][a-z0-9_]*$/u;
+/** Why `type` can't be the subject type of the app table `table`, or `undefined` when it can. */
+function subjectTypeError(design, table, type) {
+	if (!SUBJECT_TYPE.test(type)) return "Use lowercase letters, digits and underscores, starting with a letter.";
+	const owner = Object.entries(design.appTables ?? {}).find(([name, each]) => name !== table && each.subject?.type === type)?.[0];
+	return owner === void 0 ? void 0 : `${owner} already has the subject type ${type}.`;
+}
+/** App table events with `edit` applied to the payload columns, dropping an empty list. */
+function eventsColumnsEdited(events, edit) {
+	if (events === true) return true;
+	const { include, ...rest } = events;
+	const kept = include === void 0 ? [] : edit(include);
+	return kept.length === 0 ? rest : {
+		...rest,
+		include: kept
+	};
+}
+//#endregion
+//#region src/create/design.ts
+const EMPTY_DESIGN = {};
+/** The schema app tables go in. */
+const APP_SCHEMA = "public";
+/** The module name app tables carry in the diagram. */
+const APP_MODULE = "app-tables";
+/** Column names every app table creates itself. */
+const IMPLICIT_COLUMNS = /* @__PURE__ */ new Set([
+	"id",
+	"created_at",
+	"updated_at"
+]);
+function appTableId(name) {
+	return `${APP_SCHEMA}.${name}`;
+}
+function isAppTable(table) {
+	return table.module === APP_MODULE;
+}
+function isEmptyDesign(design) {
+	return Object.keys(design.appTables ?? {}).length === 0 && Object.keys(design.extraColumns ?? {}).length === 0 && Object.keys(design.positions ?? {}).length === 0;
+}
+/** The column that scopes an app table's rows, or `null` for `scope: "none"` and unscoped presets. */
+function scopeColumnOf(table, preset) {
+	const scope = table.scope ?? "inherit";
+	if (scope === "none") return null;
+	if (scope === "inherit" && preset.scope === "tenant") return {
+		name: `${preset.tenantName}_id`,
+		type: preset.idType,
+		nullable: false,
+		default: null,
+		unique: false
+	};
+	if (scope === "user" || preset.scope === "user") return {
+		name: "user_id",
+		type: "uuid",
+		nullable: false,
+		default: "auth.uid()",
+		unique: false
+	};
+	return null;
+}
+/** Why `name` can't name an app table or column, by the library's rules. */
+function identifierError(name) {
+	return appIdentifierError(name);
+}
+/** The names of an app table's columns, its implicit ones included. */
+function columnNamesOf(table, preset) {
+	const scope = scopeColumnOf(table, preset);
+	return [
+		"id",
+		...scope === null ? [] : [scope.name],
+		...Object.keys(table.columns ?? {}),
+		...table.timestamps === false ? [] : ["created_at", "updated_at"],
+		...computedRows(table).map((row) => row.name)
+	];
+}
+/** Why a column can't be added to an app table, or `undefined` when it can. */
+function columnError(table, name, preset) {
+	const invalid = identifierError(name);
+	if (invalid !== void 0) return invalid;
+	if (IMPLICIT_COLUMNS.has(name) || columnNamesOf(table, preset).includes(name)) return `The table already has a ${name} column.`;
+	if (appReservedColumns(preset.tenantName).includes(name)) return `${name} is a column every app table can get from its scope. Choose another name.`;
+}
+/**
+* Why `value` can't be the default of `column` (its type, options and
+* bounds), or `undefined` when it can or is empty.
+*/
+function defaultError(column, value) {
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : appDefaultError(column, trimmed);
+}
+/** A column with its type changed, dropping the keys the new type can't take. */
+function retyped(column, type) {
+	return fitted({
+		...column,
+		type
+	});
+}
+/** A free app table name: `base`, then `base_2`, `base_3` and so on. */
+function freeTableName(design, taken, base = "items") {
+	const used = (name) => taken.has(appTableId(name)) || design.appTables?.[name] !== void 0;
+	if (!used(base)) return base;
+	let index = 2;
+	while (used(`${base}_${index}`)) index += 1;
+	return `${base}_${index}`;
+}
+function withAppTables(design, appTables) {
+	const { appTables: _drop, ...rest } = design;
+	return Object.keys(appTables).length === 0 ? rest : {
+		...rest,
+		appTables: prunedComputed(appTables)
+	};
+}
+function withPositions(design, positions) {
+	const { positions: _drop, ...rest } = design;
+	return Object.keys(positions).length === 0 ? rest : {
+		...rest,
+		positions
+	};
+}
+function omitKey(record, key) {
+	const { [key]: _drop, ...rest } = record ?? {};
+	return rest;
+}
+/** Adds an app table, placed at `position` when given. */
+function addTable(design, name, table = {}, position) {
+	const next = withAppTables(design, {
+		...design.appTables,
+		[name]: table
+	});
+	return position === void 0 ? next : withPositions(next, {
+		...next.positions,
+		[appTableId(name)]: position
+	});
+}
+/**
+* Removes an app table, every app table column that references it (and
+* those columns from key sets), and the rollups and lookups that read it.
+*/
+function deleteTable(design, name) {
+	const rest = omitKey(design.appTables, name);
+	return withPositions(withAppTables(design, Object.fromEntries(Object.entries(rest).map(([key, table]) => {
+		const dropped = new Set(Object.entries(table.columns ?? {}).filter(([, column]) => column.references?.block === void 0 && column.references?.table === name).map(([column]) => column));
+		return [key, dropped.size === 0 ? table : withKeySets({
+			...table,
+			columns: Object.fromEntries(Object.entries(table.columns ?? {}).filter(([column]) => !dropped.has(column)))
+		}, (columns) => columns.filter((column) => !dropped.has(column)))];
+	}))), omitKey(design.positions, appTableId(name)));
+}
+/** Renames an app table and the references to it. */
+function renameTable(design, from, to) {
+	if (from === to || design.appTables?.[from] === void 0) return design;
+	const appTables = Object.fromEntries(Object.entries(design.appTables).map(([key, table]) => [key === from ? to : key, {
+		...table,
+		columns: Object.fromEntries(Object.entries(table.columns ?? {}).map(([name, column]) => [name, column.references?.block === void 0 && column.references?.table === from ? {
+			...column,
+			references: {
+				...column.references,
+				table: to
+			}
+		} : column]))
+	}]));
+	const position = design.positions?.[appTableId(from)];
+	const positions = omitKey(design.positions, appTableId(from));
+	return withPositions(withAppTables(design, computedTableRenamed(appTables, from, to)), position === void 0 ? positions : {
+		...positions,
+		[appTableId(to)]: position
+	});
+}
+const TABLE_PATCH_KEYS = [
+	"scope",
+	"timestamps",
+	"id",
+	"unique",
+	"indexes",
+	"comment",
+	"subject",
+	"events"
+];
+function patchKey(next, patch, key) {
+	if (!(key in patch)) return;
+	const value = patch[key];
+	if (value === void 0) delete next[key];
+	else next[key] = value;
+}
+/** Updates an app table's options; a key set to `undefined` is removed. */
+function updateTable(design, name, patch) {
+	const table = design.appTables?.[name];
+	if (table === void 0) return design;
+	const next = { ...table };
+	for (const key of TABLE_PATCH_KEYS) patchKey(next, patch, key);
+	return withAppTables(design, {
+		...design.appTables,
+		[name]: next
+	});
+}
+/**
+* Sets an app table's id type and retypes the app table columns that
+* reference it, since a key has the type of the id it points at.
+*/
+function setTableId(design, name, id) {
+	const next = updateTable(design, name, { id: id === "uuid" ? void 0 : id });
+	return withAppTables(next, Object.fromEntries(Object.entries(next.appTables ?? {}).map(([key, table]) => [key, {
+		...table,
+		columns: Object.fromEntries(Object.entries(table.columns ?? {}).map(([column, config]) => [column, config.references?.block === void 0 && config.references?.table === name ? retyped(config, id) : config]))
+	}])));
+}
+/** A table's composite key sets with `edit` applied to each, dropping empty sets and an empty list. */
+function withKeySets(table, edit) {
+	const { unique, indexes, ...rest } = table;
+	const sets = (list) => {
+		const next = (list ?? []).map(edit).filter((columns) => columns.length > 0);
+		return next.length === 0 ? void 0 : next;
+	};
+	const next = { ...rest };
+	const nextUnique = sets(unique);
+	if (rest.subject !== void 0) next.subject = subjectColumnsEdited(rest.subject, edit);
+	if (rest.events !== void 0) next.events = eventsColumnsEdited(rest.events, edit);
+	const nextIndexes = sets(indexes);
+	if (nextUnique !== void 0) next.unique = nextUnique;
+	if (nextIndexes !== void 0) next.indexes = nextIndexes;
+	return next;
+}
+/** Sets (adds or replaces) an app table column. */
+function setColumn(design, table, name, column) {
+	const current = design.appTables?.[table];
+	return current === void 0 ? design : withAppTables(design, {
+		...design.appTables,
+		[table]: {
+			...current,
+			columns: {
+				...current.columns,
+				[name]: column
+			}
+		}
+	});
+}
+/** Renames an app table column, keeping its place. */
+function renameColumn(design, table, from, to) {
+	const current = design.appTables?.[table];
+	if (current === void 0 || from === to) return design;
+	return withAppTables(design, computedColumnRenamed({
+		...design.appTables,
+		[table]: withKeySets({
+			...current,
+			columns: Object.fromEntries(Object.entries(current.columns ?? {}).map(([name, column]) => [name === from ? to : name, column]))
+		}, (columns) => columns.map((column) => column === from ? to : column))
+	}, table, from, to));
+}
+/** Replaces an app table with `edit` applied to it, such as `tableWithComputed`. */
+function editTable(design, table, edit) {
+	const current = design.appTables?.[table];
+	return current === void 0 ? design : withAppTables(design, {
+		...design.appTables,
+		[table]: edit(current)
+	});
+}
+function deleteColumn(design, table, name) {
+	const current = design.appTables?.[table];
+	return current === void 0 ? design : withAppTables(design, {
+		...design.appTables,
+		[table]: withKeySets({
+			...current,
+			columns: omitKey(current.columns, name)
+		}, (columns) => columns.filter((column) => column !== name))
+	});
+}
+/** Sets an extra column on a block table (`blocks.<module>.options.extraColumns`). */
+function setExtraColumn(design, module, name, type) {
+	return {
+		...design,
+		extraColumns: {
+			...design.extraColumns,
+			[module]: {
+				...design.extraColumns?.[module],
+				[name]: type
+			}
+		}
+	};
+}
+function deleteExtraColumn(design, module, name) {
+	const columns = omitKey(design.extraColumns?.[module], name);
+	const { extraColumns: _drop, ...rest } = design;
+	const extraColumns = Object.keys(columns).length === 0 ? omitKey(design.extraColumns, module) : {
+		...design.extraColumns,
+		[module]: columns
+	};
+	return Object.keys(extraColumns).length === 0 ? rest : {
+		...rest,
+		extraColumns
+	};
+}
+/** Copies an app table under a free name, next to the original. */
+function duplicateTable(design, name, taken) {
+	const table = design.appTables?.[name];
+	if (table === void 0) return {
+		design,
+		name
+	};
+	const copy = freeTableName(design, taken, `${name}_copy`);
+	const position = design.positions?.[appTableId(name)];
+	return {
+		design: addTable(design, copy, table.subject === void 0 ? table : {
+			...table,
+			subject: {
+				...table.subject,
+				type: singular(copy)
+			}
+		}, position === void 0 ? void 0 : [position[0] + 40, position[1] + 40]),
+		name: copy
+	};
+}
+/** Moves tables (table id to its new top-left corner). */
+function moveTables(design, moves) {
+	return withPositions(design, {
+		...design.positions,
+		...moves
+	});
+}
+/**
+* The app table column behind a foreign key from `tableId`, when the canvas
+* added it, or `undefined` when a block or the preset owns the key.
+*/
+function userConnection(design, tableId, column) {
+	const name = Object.keys(design.appTables ?? {}).find((each) => appTableId(each) === tableId);
+	if (name === void 0 || column === null) return;
+	return design.appTables?.[name]?.columns?.[column]?.references === void 0 ? void 0 : {
+		table: name,
+		column
+	};
+}
+/** Drops every saved position, so the automatic layout places every table again. */
+function tidy(design) {
+	return withPositions(design, {});
+}
+const SINGULAR_ENDINGS = [
+	[/ies$/u, "y"],
+	[/(ss|us)$/u, "$1"],
+	[/s$/u, ""]
+];
+/** A naive English singular for a table name: `organizations` to `organization`. */
+function singular(name) {
+	for (const [ending, replacement] of SINGULAR_ENDINGS) if (ending.test(name)) return name.replace(ending, replacement);
+	return name;
+}
+const AUTH_USERS$1 = "auth.users";
+/** The column types a foreign key can point at, from the target's primary key type. */
+function referenceType(type) {
+	const normal = type.toLowerCase();
+	switch (normal) {
+		case "uuid":
+		case "text":
+		case "bigint":
+		case "integer": return normal;
+		case "int8":
+		case "bigserial": return "bigint";
+		case "int":
+		case "int4":
+		case "serial": return "integer";
+		default: return;
+	}
+}
+/**
+* Adds a foreign key column from an app table to `target`. Only app tables
+* get new columns. A self reference gets `parent_id`, and a second
+* reference to the same table gets a role name (`owner_id`, `<target>_2_id`)
+* the user can rename. A target without a single-column primary key, and
+* the tenant table the scope column already references, are refused with a
+* message.
+*/
+function connect(design, data, preset, connection) {
+	const source = data.tables.find((table) => table.id === connection.source);
+	if (source === void 0 || !isAppTable(source)) return {
+		ok: false,
+		error: "Block tables only accept connections. Drag from an app table."
+	};
+	if (design.appTables?.[source.name] === void 0) return {
+		ok: false,
+		error: `${source.name} is not in the design.`
+	};
+	if (source.tenantColumn !== null && connection.target === data.tenantTable) return {
+		ok: false,
+		error: `${source.name} already references ${connection.target} through ${source.tenantColumn}.`
+	};
+	return referenceFrom(design, data, preset, source.name, connection.target);
+}
+/** Second references to `auth.users`, in the order they are offered. */
+const USER_ROLES = [
+	"owner_id",
+	"assignee_id",
+	"reviewer_id",
+	"approver_id"
+];
+/** The first column name for a reference that the table can still take. */
+function referenceColumn(table, base, roles, preset) {
+	const stem = base.replace(/_id$/u, "");
+	return [
+		base,
+		...roles,
+		...Array.from({ length: 8 }, (_, index) => `${stem}_${index + 2}_id`)
+	].find((candidate) => columnError(table, candidate, preset) === void 0);
+}
+/**
+* Adds a key to `targetId` on the app table `name` in the design, which can
+* be a table the schema doesn't have yet: `<target>_id`, `parent_id` for a
+* self reference, or a free role name when that column is taken.
+*/
+function referenceFrom(design, data, preset, name, targetId) {
+	const table = design.appTables?.[name];
+	if (table === void 0) return {
+		ok: false,
+		error: `${name} is not in the design.`
+	};
+	const target = targetId === AUTH_USERS$1 ? void 0 : data.tables.find((each) => each.id === targetId);
+	if (targetId !== AUTH_USERS$1 && target === void 0) return {
+		ok: false,
+		error: "That table is not in the schema."
+	};
+	const keyType = target === void 0 ? "uuid" : target.primaryKey.length === 1 ? target.columns.find((column) => column.name === target.primaryKey[0])?.type : void 0;
+	const type = keyType === void 0 ? void 0 : referenceType(keyType);
+	if (type === void 0) return {
+		ok: false,
+		error: `${targetId} has no single uuid, text or integer key to reference.`
+	};
+	const references = target === void 0 ? { table: AUTH_USERS$1 } : isAppTable(target) ? { table: target.name } : data.blockTables[target.id];
+	if (references === void 0) return {
+		ok: false,
+		error: `${targetId} can't be referenced from an app table.`
+	};
+	const self = targetId === appTableId(name);
+	const user = target === void 0;
+	const column = referenceColumn(table, self ? "parent_id" : `${singular(user ? "user" : target.name)}_id`, user ? USER_ROLES : [], preset);
+	if (column === void 0) return {
+		ok: false,
+		error: `${name} already has every column name a reference to ${targetId} gets. Rename one first.`
+	};
+	return {
+		ok: true,
+		column,
+		design: setColumn(design, name, column, {
+			type,
+			nullable: true,
+			references: {
+				...references,
+				onDelete: self || user ? "set null" : "cascade"
+			}
+		})
+	};
+}
+/**
+* What would stop `sql sync` from writing the design: a table name a block
+* already uses, a reference to a table the preset no longer installs, a
+* set-null delete on a required column, a composite key on a column the
+* table doesn't have, and extra columns for a block that is gone or no
+* longer takes them.
+*/
+function designIssues(design, data, preset) {
+	const issues = [];
+	const names = new Set(data.tables.filter((table) => !isAppTable(table)).map((table) => table.name));
+	const logical = new Set(Object.values(data.blockTables).map((each) => `${each.block}.${each.table}`));
+	const modules = new Set(data.tables.filter((table) => data.extraColumns.includes(table.id)).map((table) => table.module));
+	const subjectTypes = /* @__PURE__ */ new Map();
+	for (const [name, table] of Object.entries(design.appTables ?? {})) {
+		const type = table.subject?.type;
+		if (type !== void 0 && !subjectTypes.has(type)) subjectTypes.set(type, name);
+	}
+	for (const [name, table] of Object.entries(design.appTables ?? {})) {
+		const invalid = identifierError(name);
+		if (invalid !== void 0) issues.push({
+			table: name,
+			message: `The name ${name} is invalid. ${invalid}`
+		});
+		if (names.has(name)) issues.push({
+			table: name,
+			message: `A block already creates a ${name} table. Rename this one.`
+		});
+		const long = appNameLengthError(name, table);
+		if (long !== void 0) issues.push({
+			table: name,
+			message: `${long}.`
+		});
+		const type = table.subject?.type;
+		if (type !== void 0 && subjectTypes.get(type) !== name) issues.push({
+			table: name,
+			message: `${subjectTypes.get(type)} already has the subject type ${type}. Choose another.`
+		});
+		for (const [column, config] of Object.entries(table.columns ?? {})) {
+			const fallback = config.default === void 0 ? void 0 : defaultError(config, config.default);
+			if (fallback !== void 0) issues.push({
+				table: name,
+				message: `${name}.${column}: ${fallback}`
+			});
+			if (lockedWithoutDefault(config)) issues.push({
+				table: name,
+				message: `${name}.${column} is required, and signed-in users can't write it, so give it a default.`
+			});
+		}
+		for (const column of subjectColumns(table.subject)) if (Object.hasOwn(table.columns ?? {}, column.name)) issues.push({
+			table: name,
+			message: `${name}.${column.name} clashes with the column its record features add. Rename it.`
+		});
+		const known = /* @__PURE__ */ new Set([
+			"id",
+			...Object.keys(table.columns ?? {}),
+			...table.timestamps === false ? [] : ["created_at", "updated_at"]
+		]);
+		const scope = scopeColumnOf(table, preset);
+		if (scope !== null) known.add(scope.name);
+		for (const [key, sets] of [["unique key", table.unique], ["index", table.indexes]]) for (const columns of sets ?? []) {
+			const gone = columns.filter((column) => !known.has(column));
+			if (gone.length > 0) issues.push({
+				table: name,
+				message: `The ${key} on ${columns.join(", ")} names ${gone.join(", ")}, which ${name} doesn't have.`
+			});
+		}
+		for (const [column, config] of Object.entries(table.columns ?? {})) {
+			const reference = config.references;
+			if (reference === void 0) continue;
+			if (reference.block === void 0 ? reference.table !== AUTH_USERS$1 && design.appTables?.[reference.table] === void 0 : !logical.has(`${reference.block}.${reference.table}`)) issues.push({
+				table: name,
+				message: `${name}.${column} references ${reference.block === void 0 ? reference.table : `${reference.block}.${reference.table}`}, which the preset does not install.`
+			});
+			if (reference.onDelete === "set null" && config.nullable === false) issues.push({
+				table: name,
+				message: `${name}.${column} is required, so deleting the row it references can't set it to null.`
+			});
+		}
+	}
+	for (const block of Object.keys(design.extraColumns ?? {})) if (!modules.has(block)) issues.push({
+		table: block,
+		message: `The extra columns for ${block} have no table: the block is not installed or takes no extra columns.`
+	});
+	return issues;
+}
+function appColumn(name, column) {
+	const label = columnLabel(column);
+	const schemaColumn = {
+		name,
+		type: column.type,
+		nullable: column.identity === true ? false : column.nullable ?? true,
+		default: column.identity === true ? "identity" : column.default ?? null,
+		unique: column.unique ?? false
+	};
+	return label === void 0 ? schemaColumn : {
+		...schemaColumn,
+		label
+	};
+}
+const TIMESTAMP = {
+	type: "timestamptz",
+	nullable: false,
+	default: "now()",
+	unique: false
+};
+/** The id of the table a reference points at, or `undefined` when it is not in the schema. */
+function referencedId(reference, data) {
+	if (reference.block === void 0) return reference.table === AUTH_USERS$1 ? AUTH_USERS$1 : appTableId(reference.table);
+	return Object.entries(data.blockTables).find(([, each]) => each.block === reference.block && each.table === reference.table)?.[0];
+}
+function foreignKey(column, to, onDelete = "no action") {
+	const [schema = "", target = ""] = to.split(".");
+	return {
+		columns: [column],
+		target: {
+			schema,
+			table: target,
+			columns: []
+		},
+		onDelete
+	};
+}
+/** An app table as the diagram reads it. */
+function appSchemaTable(name, table, data, preset) {
+	const scope = scopeColumnOf(table, preset);
+	const scopeTo = scope === null ? void 0 : scope.name === "user_id" ? AUTH_USERS$1 : data.tenantTable ?? void 0;
+	const columns = [
+		table.id === "bigint" ? {
+			name: "id",
+			type: "bigint",
+			nullable: false,
+			default: "identity",
+			unique: false
+		} : {
+			name: "id",
+			type: "uuid",
+			nullable: false,
+			default: "gen_random_uuid()",
+			unique: false
+		},
+		...scope === null ? [] : [scope],
+		...Object.entries(table.columns ?? {}).map(([key, column]) => appColumn(key, column)),
+		...subjectColumns(table.subject),
+		...table.timestamps === false ? [] : [{
+			name: "created_at",
+			...TIMESTAMP
+		}, {
+			name: "updated_at",
+			...TIMESTAMP
+		}]
+	];
+	const scopeKeys = scope === null || scopeTo === void 0 ? [] : [foreignKey(scope.name, scopeTo, "cascade")];
+	const columnKeys = Object.entries(table.columns ?? {}).flatMap(([key, column]) => {
+		const to = column.references === void 0 ? void 0 : referencedId(column.references, data);
+		return to === void 0 ? [] : [foreignKey(key, to, column.references?.onDelete)];
+	});
+	const schemaTable = {
+		id: appTableId(name),
+		schema: APP_SCHEMA,
+		name,
+		module: APP_MODULE,
+		primaryKey: ["id"],
+		foreignKeys: [...scopeKeys, ...columnKeys],
+		tenantColumn: scope !== null && scope.name !== "user_id" ? scope.name : null,
+		columns
+	};
+	const computed = computedRows(table);
+	return computed.length === 0 ? schemaTable : {
+		...schemaTable,
+		computed
+	};
+}
+/** The extra column names a block table got from the design. */
+function extraColumnsOf(design, table, data) {
+	return data.extraColumns.includes(table.id) ? design.extraColumns?.[table.module] ?? {} : {};
+}
+/**
+* The schema with the design applied: app tables added, extra columns
+* appended to the block tables that accept them.
+*/
+function withDesign(data, design, preset) {
+	const tables = data.tables.map((table) => {
+		const extra = extraColumnsOf(design, table, data);
+		const names = new Set(table.columns.map((column) => column.name));
+		const added = Object.entries(extra).filter(([name]) => !names.has(name)).map(([name, type]) => ({
+			name,
+			type,
+			nullable: !/\bnot\s+null\b/iu.test(type),
+			default: null,
+			unique: false
+		}));
+		return added.length === 0 ? table : {
+			...table,
+			columns: [...table.columns, ...added]
+		};
+	});
+	const appTables = Object.entries(design.appTables ?? {}).map(([name, table]) => appSchemaTable(name, table, data, preset));
+	return {
+		...data,
+		tables: [...tables, ...appTables],
+		manifests: {
+			...data.manifests,
+			...Object.fromEntries(appTables.map((table) => [table.id, APP_MODULE]))
+		}
+	};
+}
+//#endregion
+//#region src/create/column-kinds.ts
+/** The groups of the column type picker, in the order it shows them. */
+const KIND_GROUPS = [
+	"Text",
+	"Number",
+	"Date and time",
+	"Choice",
+	"Relation",
+	"Other"
+];
+const USERS$1 = "auth.users";
+/** The first options a new select gets, for the user to rename. */
+const STARTER_OPTIONS = ["Option A", "Option B"];
+const COLUMN_KINDS = [
+	{
+		id: "text",
+		label: "Text",
+		group: "Text",
+		short: "text",
+		column: { type: "text" }
+	},
+	{
+		id: "long_text",
+		label: "Long text",
+		group: "Text",
+		short: "long text",
+		column: {
+			type: "text",
+			format: "long_text"
+		}
+	},
+	{
+		id: "email",
+		label: "Email",
+		group: "Text",
+		short: "email",
+		column: {
+			type: "text",
+			format: "email"
+		}
+	},
+	{
+		id: "url",
+		label: "URL",
+		group: "Text",
+		short: "url",
+		column: {
+			type: "text",
+			format: "url"
+		}
+	},
+	{
+		id: "phone",
+		label: "Phone",
+		group: "Text",
+		short: "phone",
+		column: {
+			type: "text",
+			format: "phone"
+		}
+	},
+	{
+		id: "color",
+		label: "Color",
+		group: "Text",
+		short: "color",
+		column: {
+			type: "text",
+			format: "color"
+		}
+	},
+	{
+		id: "integer",
+		label: "Whole number",
+		group: "Number",
+		short: "integer",
+		column: { type: "integer" }
+	},
+	{
+		id: "bigint",
+		label: "Large whole number",
+		group: "Number",
+		short: "bigint",
+		column: { type: "bigint" }
+	},
+	{
+		id: "numeric",
+		label: "Decimal",
+		group: "Number",
+		short: "numeric",
+		column: { type: "numeric" }
+	},
+	{
+		id: "rating",
+		label: "Rating",
+		group: "Number",
+		short: "rating",
+		column: {
+			type: "integer",
+			format: "rating"
+		}
+	},
+	{
+		id: "percent",
+		label: "Percent",
+		group: "Number",
+		short: "percent",
+		column: {
+			type: "numeric",
+			format: "percent"
+		}
+	},
+	{
+		id: "currency",
+		label: "Currency",
+		group: "Number",
+		short: "money",
+		column: {
+			type: "bigint",
+			format: "currency"
+		}
+	},
+	{
+		id: "autonumber",
+		label: "Autonumber",
+		group: "Number",
+		short: "autonumber",
+		column: {
+			type: "bigint",
+			identity: true
+		}
+	},
+	{
+		id: "date",
+		label: "Date",
+		group: "Date and time",
+		short: "date",
+		column: { type: "date" }
+	},
+	{
+		id: "timestamptz",
+		label: "Date and time",
+		group: "Date and time",
+		short: "timestamptz",
+		column: { type: "timestamptz" }
+	},
+	{
+		id: "boolean",
+		label: "Yes or no",
+		group: "Choice",
+		short: "boolean",
+		column: { type: "boolean" }
+	},
+	{
+		id: "single_select",
+		label: "Single select",
+		group: "Choice",
+		short: "select",
+		column: {
+			type: "text",
+			options: STARTER_OPTIONS
+		}
+	},
+	{
+		id: "multi_select",
+		label: "Multi-select",
+		group: "Choice",
+		short: "multi-select",
+		column: {
+			type: "text[]",
+			options: STARTER_OPTIONS
+		}
+	},
+	{
+		id: "person",
+		label: "Person",
+		group: "Relation",
+		short: "person",
+		column: {
+			type: "uuid",
+			nullable: true,
+			references: {
+				table: USERS$1,
+				onDelete: "set null"
+			}
+		}
+	},
+	{
+		id: "reference",
+		label: "Link to a table",
+		group: "Relation",
+		short: "link",
+		column: { type: "uuid" },
+		drawn: true
+	},
+	{
+		id: "uuid",
+		label: "UUID",
+		group: "Other",
+		short: "uuid",
+		column: { type: "uuid" }
+	},
+	{
+		id: "jsonb",
+		label: "JSON",
+		group: "Other",
+		short: "jsonb",
+		column: { type: "jsonb" }
+	},
+	{
+		id: "text_list",
+		label: "List of text",
+		group: "Other",
+		short: "text[]",
+		column: { type: "text[]" }
+	}
+];
+const BY_ID = new Map(COLUMN_KINDS.map((kind) => [kind.id, kind]));
+const BY_FORMAT = new Map(COLUMN_KINDS.filter((kind) => kind.column.format !== void 0).map((kind) => [kind.column.format, kind]));
+const PLAIN = {
+	text: "text",
+	uuid: "uuid",
+	integer: "integer",
+	bigint: "bigint",
+	numeric: "numeric",
+	boolean: "boolean",
+	timestamptz: "timestamptz",
+	date: "date",
+	jsonb: "jsonb",
+	"text[]": "text_list"
+};
+function kindById(id) {
+	return BY_ID.get(id);
+}
+/** The kind a column's identity, reference or options make it, before its format and type. */
+function structuralKind(column) {
+	if (column.identity === true) return "autonumber";
+	if (column.references !== void 0) return column.references.block === void 0 && column.references.table === USERS$1 ? "person" : "reference";
+	if (column.options === void 0) return;
+	return column.type === "text[]" ? "multi_select" : "single_select";
+}
+/** The picker choice a column reads as. */
+function kindOf(column) {
+	const id = structuralKind(column);
+	return (id === void 0 ? void 0 : BY_ID.get(id)) ?? (column.format === void 0 ? void 0 : BY_FORMAT.get(column.format)) ?? BY_ID.get(PLAIN[column.type]);
+}
+/**
+* `column` as `kind`: the kind's keys, with the column's name-independent
+* settings (required, unique, comment, a default and bounds that still fit)
+* kept, and a select's options kept when it turns into the other select.
+*/
+function withKind(column, kind) {
+	const { format: _format, options, identity: _identity, references: _references, min, max, ...rest } = column;
+	const kept = kind.column.options === void 0 || options === void 0 ? kind.column : {
+		...kind.column,
+		options
+	};
+	return fitted(withBounds({
+		...rest,
+		...kept
+	}, column.type === kind.column.type ? {
+		min,
+		max
+	} : {}));
+}
+/** The money columns of `name`: `<stem>_minor` and `<stem>_currency`. */
+function moneyColumns(name) {
+	const stem = name.replace(/_minor$/u, "");
+	return {
+		minor: `${stem}_minor`,
+		currency: `${stem}_currency`
+	};
+}
+/**
+* Sets an app table column to `kind`. Currency keeps money as two columns:
+* the column becomes `<name>_minor` (unless the name is taken) and a
+* `<name>_currency` text column of 3 characters joins it. Returns the
+* column's name after the change.
+*/
+function setColumnKind(design, table, name, kind) {
+	const columns = design.appTables?.[table]?.columns ?? {};
+	const column = columns[name];
+	if (column === void 0) return {
+		design,
+		name
+	};
+	const next = withKind(column, kind);
+	if (kind.id !== "currency") return {
+		design: setColumn(design, table, name, next),
+		name
+	};
+	const { minor, currency } = moneyColumns(name);
+	const renamed = minor === name || columns[minor] === void 0 ? minor : name;
+	const moved = setColumn(renameColumn(design, table, name, renamed), table, renamed, next);
+	if (columns[currency] !== void 0) return {
+		design: moved,
+		name: renamed
+	};
+	return {
+		design: setColumn(moved, table, currency, next.nullable === false ? {
+			type: "text",
+			nullable: false,
+			min: 3,
+			max: 3
+		} : {
+			type: "text",
+			min: 3,
+			max: 3
+		}),
+		name: renamed
+	};
+}
+//#endregion
+//#region src/create/deploy.ts
+/** The name the deploy gives its migration in `supabase_migrations`. */
+const MIGRATION_NAME = "better_supabase_blocks";
+/**
+* Why this preset can't be deployed, or `undefined` when it can. With
+* `access: "provider"` the preview renders a stand-in provider whose
+* functions no real project has.
+*/
+function deployBlocker(preset) {
+	return preset.access === "provider" ? "Bring your own authorization provider: its SQL comes from the provider, so deploy it with the CLI." : void 0;
+}
+/**
+* The SQL of one migration for the rendered files: every schema file, then
+* every data file, each in render order, which is the order `sql sync` and
+* `sql data` apply them. pgTAP tests stay out.
+*/
+function deployQuery(files) {
+	const schema = files.filter((file) => file.path.includes("/schemas/"));
+	const data = files.filter((file) => file.path.includes("/better-supabase-data/"));
+	return [...schema, ...data].map((file) => `-- ${file.path}\n${file.contents.trim()}\n`).join("\n");
+}
+/** A database password for a new project: 32 base64url characters. */
+function generatePassword() {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(24));
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCodePoint(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+/** The project name the dialog suggests: the preset's name, or `my-app`. */
+function suggestedProjectName(named) {
+	return named === void 0 ? "my-app" : `my-${named}-app`;
+}
+const DASHBOARD = "https://supabase.com/dashboard";
+function dashboardUrl(ref, page = "") {
+	return `${DASHBOARD}/project/${encodeURIComponent(ref)}${page}`;
+}
+//#endregion
+//#region src/create/design-history.ts
+/** How many steps Undo can go back. */
+const HISTORY_LIMIT = 50;
+function initialHistory(value) {
+	return {
+		past: [],
+		present: value,
+		future: [],
+		dragStart: null
+	};
+}
+function record(history, previous, next) {
+	return {
+		past: [...history.past, previous].slice(-50),
+		present: next,
+		future: [],
+		dragStart: null
+	};
+}
+/**
+* An undo history. `drag` updates the value without a step while the
+* pointer moves; `commitDrag` records the whole drag as one step. `amend`
+* replaces the value in the current step, so a follow-up such as placing a
+* dropped block stays part of the step that added it. `reset` replaces the
+* value and clears the history, as loading a link does.
+*/
+function undoHistory(current, action) {
+	switch (action.type) {
+		case "apply": return action.value === current.present ? current : record(current, current.dragStart ?? current.present, action.value);
+		case "drag": return {
+			...current,
+			present: action.value,
+			dragStart: current.dragStart ?? current.present
+		};
+		case "commitDrag": return current.dragStart === null ? current : record(current, current.dragStart, current.present);
+		case "amend": return {
+			...current,
+			present: action.value
+		};
+		case "undo": {
+			const previous = current.past.at(-1);
+			return previous === void 0 ? current : {
+				past: current.past.slice(0, -1),
+				present: previous,
+				future: [current.present, ...current.future],
+				dragStart: null
+			};
+		}
+		case "redo": {
+			const [next, ...future] = current.future;
+			return next === void 0 ? current : {
+				past: [...current.past, current.present].slice(-50),
+				present: next,
+				future,
+				dragStart: null
+			};
+		}
+		case "reset": return initialHistory(action.value);
+		default: return action;
+	}
+}
+//#endregion
+//#region src/create/preview-provider.ts
+/**
+* A stand-in for the app's authorization provider, so `/create` can render
+* the SQL and the diagram for `access: "provider"`. Its templates call
+* functions in a `provider` schema that no real project has: the preview
+* says so next to the output.
+*/
+function previewAccessProvider(preset) {
+	return {
+		name: "your authorization provider",
+		scope: preset.tenantName,
+		idType: preset.idType,
+		functions: {
+			idsWith: "provider.ids_with('{scope}', {permission})",
+			idsWithFor: "provider.ids_with_for({user}, '{scope}', {permission})",
+			isPlatform: "provider.is_platform({permission})",
+			isPlatformFor: "provider.is_platform_for({user}, {permission})",
+			memberIds: "provider.member_ids('{scope}')",
+			memberIdsFor: "provider.member_ids_for({user}, '{scope}')"
+		}
+	};
+}
+/**
+* The files `sql sync` writes for a config with only this preset and its
+* `/create` design (app tables and extra columns). With
+* `access: "provider"` the access functions come from
+* `previewAccessProvider`.
+*/
+function previewFiles(code, design = {}) {
+	const preset = presetOf(code);
+	const config = resolveConfig(Object.keys(design).length === 0 ? { preset: code } : designConfig(resolvePreset(preset), design), "/");
+	const provider = preset.access === "provider" ? previewAccessProvider(preset) : void 0;
+	return renderModules(config.blockNames, moduleLayout(config, config.sql.testsDir, [], void 0, provider)).map((file) => ({
+		path: file.path,
+		module: file.module,
+		contents: file.contents
+	}));
+}
+//#endregion
+//#region src/create/sample-rows.ts
+const SAMPLE_ROW_COUNT = 8;
+/** The columns of `table` a `viewer` can't select: `access: "server"` ones for a member. */
+function hiddenColumns(table, viewer) {
+	if (viewer === "server") return [];
+	return Object.entries(table?.columns ?? {}).filter(([, column]) => column.access === "server").map(([key]) => key);
+}
+const USERS = "auth.users";
+const PEOPLE = [
+	"Ada Lovelace",
+	"Grace Hopper",
+	"Alan Turing",
+	"Katherine Johnson",
+	"Edsger Dijkstra",
+	"Barbara Liskov",
+	"Donald Knuth",
+	"Frances Allen"
+];
+const SENTENCES = [
+	"A short note that explains the row.",
+	"Longer text, such as a description or the body of a post.",
+	"Written by the team and edited later.",
+	"Kept for reference."
+];
+const COLORS = [
+	"#2563eb",
+	"#16a34a",
+	"#d97706",
+	"#dc2626",
+	"#7c3aed"
+];
+const TITLE_COLUMNS = [
+	"name",
+	"title",
+	"label",
+	"subject"
+];
+function capitalized(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`.replaceAll("_", " ");
+}
+/** The column a table's rows are named by: its subject title, then a likely name column. */
+function titleColumnOf(table) {
+	const text = new Set(Object.entries(table.columns ?? {}).filter(([, column]) => column.type === "text" && column.format === void 0).map(([key]) => key));
+	return table.subject?.title ?? TITLE_COLUMNS.find((key) => text.has(key));
+}
+/** The name of row `index` of `table`, so a reference shows the row it points at. */
+function rowTitle(table, index) {
+	return `${capitalized(singular(table))} ${String(index + 1)}`;
+}
+function pad(value) {
+	return String(value).padStart(2, "0");
+}
+/** A date `days` after 5 January 2026, as `YYYY-MM-DD`. */
+function dayAfter(days) {
+	const date = new Date(Date.UTC(2026, 0, 5 + days));
+	return `${String(date.getUTCFullYear())}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+}
+function numberIn(column, index, step) {
+	const value = (column.min ?? 0) + index * step;
+	return column.max === void 0 ? value : Math.min(value, column.max);
+}
+function formatted(column, index, slug) {
+	switch (column.format) {
+		case void 0: return;
+		case "email": return `${(PEOPLE[index % PEOPLE.length] ?? "user").split(" ")[0]?.toLowerCase() ?? "user"}@example.com`;
+		case "url": return `https://example.com/${slug}/${String(index + 1)}`;
+		case "phone": return `+1 555 01${pad(index + 10)}`;
+		case "long_text": return SENTENCES[index % SENTENCES.length] ?? "";
+		case "color": return COLORS[index % COLORS.length] ?? "#000000";
+		case "rating": {
+			const min = column.min ?? 1;
+			const max = column.max ?? 5;
+			return String(min + index % (max - min + 1));
+		}
+		case "percent": return String(index * 17 % 101);
+		case "currency": return ((index + 1) * 1250 / 100).toFixed(2);
+		default: return column.format;
+	}
+}
+function referenceValue(column, index) {
+	const reference = column.references;
+	if (reference === void 0) return;
+	if (reference.block === void 0 && reference.table === USERS) return PEOPLE[index % PEOPLE.length] ?? "";
+	return rowTitle(reference.table, index % 3);
+}
+function typedValue(column, index, slug) {
+	switch (column.type) {
+		case "text": return `${capitalized(slug)} ${String(index + 1)}`;
+		case "uuid": return `00000000-0000-4000-8000-${String(index + 1).padStart(12, "0")}`;
+		case "integer":
+		case "bigint": return String(column.identity === true ? index + 1 : numberIn(column, index, 3));
+		case "numeric": return numberIn(column, index, 2.5).toFixed(2);
+		case "boolean": return String(index % 2 === 0);
+		case "timestamptz": return `${dayAfter(index * 2)} ${pad(9 + index % 8)}:00`;
+		case "date": return dayAfter(index * 3);
+		case "jsonb": return "{}";
+		case "text[]": return "{}";
+		default: return column.type;
+	}
+}
+function cell(table, key, column, index, title) {
+	if (key === title) return rowTitle(table, index);
+	if (column.nullable !== false && index % 4 === 3) return null;
+	if (column.options !== void 0 && column.options.length > 0) return column.options[index % column.options.length] ?? null;
+	return referenceValue(column, index) ?? formatted(column, index, key) ?? typedValue(column, index, key);
+}
+/**
+* Deterministic sample rows for app table `name`, from its columns' types,
+* formats, options, bounds and references. A reference shows the name of the
+* row it points at, so rows of related tables line up. A `member` viewer
+* doesn't get the columns `hiddenColumns` lists.
+*/
+function sampleRows(design, name, count = 8, viewer = "server") {
+	const table = design.appTables?.[name];
+	if (table === void 0) return {
+		columns: [],
+		rows: []
+	};
+	const hidden = new Set(hiddenColumns(table, viewer));
+	const entries = Object.entries(table.columns ?? {}).filter(([key]) => !hidden.has(key));
+	const title = titleColumnOf(table);
+	return {
+		columns: entries.map(([key]) => key),
+		rows: Array.from({ length: count }, (_, index) => Object.fromEntries(entries.map(([key, column]) => [key, cell(name, key, column, index, title)])))
+	};
+}
+//#endregion
+//#region src/create/schema-meta.ts
+const AUTH_USERS = "auth.users";
+/** The tenant name the module defaults use, which a preset's tenant name replaces. */
+const DEFAULT_TENANT = "organization";
+/**
+* Finds the parsed table for a module's logical table by its default name,
+* or by that name with the tenant renamed (`organizations` is `workspaces`
+* for the `workspace` tenant).
+*/
+function indexTables(tables, tenantName) {
+	const byName = new Map(tables.map((table) => [`${table.module}:${table.name}`, table]));
+	return (module, name) => byName.get(`${module}:${name}`) ?? byName.get(`${module}:${name.replaceAll(DEFAULT_TENANT, tenantName)}`);
+}
+function moduleTables(module) {
+	return Object.entries(SQL_MODULES[module]?.names?.tables ?? {});
+}
+/**
+* The table the tenant columns point at: the target most foreign keys on a
+* tenant column share. `null` when no table has a tenant foreign key.
+*/
+function tenantTable(tables) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const table of tables) for (const key of table.foreignKeys) if (table.tenantColumn !== null && key.columns.length === 1 && key.columns[0] === table.tenantColumn) {
+		const to = `${key.target.schema}.${key.target.table}`;
+		counts.set(to, (counts.get(to) ?? 0) + 1);
+	}
+	let best = null;
+	let most = 0;
+	for (const [id, count] of counts) if (count > most) {
+		best = id;
+		most = count;
+	}
+	return best;
+}
+/**
+* The physical column a logical lifecycle column maps to. A tenant name
+* renames `organization_id`, so a default name the table lacks falls back to
+* the table's tenant column.
+*/
+function physicalColumn(table, name, tenant) {
+	if (name === void 0) return;
+	if (table.columns.some((column) => column.name === name)) return name;
+	return tenant && table.tenantColumn !== null ? table.tenantColumn : void 0;
+}
+function hasForeignKey(table, column) {
+	return table.foreignKeys.some((key) => key.columns.length === 1 && key.columns[0] === column);
+}
+/**
+* The soft references in the tables: lifecycle tenant and user columns
+* without a foreign key, and `regclass` columns, which name any table.
+*/
+function softReferences(tables, tenantName = DEFAULT_TENANT) {
+	const lookup = indexTables(tables, tenantName);
+	const tenantTo = tenantTable(tables);
+	const refs = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (ref) => {
+		const key = `${ref.from}.${ref.column}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			refs.push(ref);
+		}
+	};
+	for (const block of new Set(tables.map((table) => table.module))) for (const [, spec] of moduleTables(block)) {
+		const table = lookup(block, spec.name);
+		const lifecycle = spec.lifecycle;
+		if (table === void 0 || lifecycle === void 0) continue;
+		const tenant = physicalColumn(table, lifecycle.tenant === void 0 ? void 0 : spec.columns[lifecycle.tenant], true);
+		if (tenant !== void 0 && tenantTo !== null && tenantTo !== table.id && !hasForeignKey(table, tenant)) add({
+			from: table.id,
+			column: tenant,
+			to: tenantTo,
+			kind: "tenant"
+		});
+		const user = physicalColumn(table, lifecycle.user === void 0 ? void 0 : spec.columns[lifecycle.user], false);
+		if (user !== void 0 && !hasForeignKey(table, user)) add({
+			from: table.id,
+			column: user,
+			to: AUTH_USERS,
+			kind: "user"
+		});
+	}
+	for (const table of tables) for (const column of table.columns) if (column.type.toLowerCase() === "regclass") add({
+		from: table.id,
+		column: column.name,
+		to: null,
+		kind: "any"
+	});
+	return refs;
+}
+const MANIFEST_BY_MODULE = new Map(PRESET_CATALOG.blocks.map((block) => [block.name, block.manifest]));
+const EXTRA_TABLE_BY_MODULE = new Map(PRESET_CATALOG.blocks.flatMap((block) => block.extraColumns === void 0 ? [] : [[block.name, block.extraColumns]]));
+/** Each table's module and logical table name. */
+function blockTables(tables, lookup) {
+	return Object.fromEntries(tables.flatMap((table) => {
+		const logical = moduleTables(table.module).find(([, spec]) => lookup(table.module, spec.name) === table)?.[0];
+		return logical === void 0 ? [] : [[table.id, {
+			block: table.module,
+			table: logical
+		}]];
+	}));
+}
+/** The table ids `blocks.<module>.options.extraColumns` adds columns to. */
+function extraColumnTables(tables, lookup) {
+	const installed = new Set(tables.map((table) => table.module));
+	return [...EXTRA_TABLE_BY_MODULE].flatMap(([module, logical]) => {
+		const spec = SQL_MODULES[module]?.names?.tables[logical];
+		const table = !installed.has(module) || spec === void 0 ? void 0 : lookup(module, spec.name);
+		return table === void 0 ? [] : [table.id];
+	});
+}
+/** The tables plus the soft references, manifests and extra-column tables the canvas draws. */
+function schemaData(tables, tenantName = DEFAULT_TENANT) {
+	const lookup = indexTables(tables, tenantName);
+	return {
+		tables,
+		softRefs: softReferences(tables, tenantName),
+		manifests: Object.fromEntries(tables.map((table) => [table.id, MANIFEST_BY_MODULE.get(table.module) ?? table.module])),
+		extraColumns: extraColumnTables(tables, lookup),
+		blockTables: blockTables(tables, lookup),
+		tenantTable: tenantTable(tables)
+	};
+}
+//#endregion
+//#region src/create/schema.ts
+/** The columns a diagram shows before a table is expanded: keys, tenant and soft references. */
+function keyColumnsOf(table, softColumns = /* @__PURE__ */ new Set()) {
+	const keys = /* @__PURE__ */ new Set([
+		...table.primaryKey,
+		...table.foreignKeys.flatMap((key) => key.columns),
+		...table.tenantColumn === null ? [] : [table.tenantColumn],
+		...softColumns
+	]);
+	return table.columns.filter((column) => keys.has(column.name));
+}
+/** The column the tenant blocks key rows by, from the preset's tenant name; `null` without tenants. */
+function tenantColumnOf(preset) {
+	return preset.scope === "tenant" ? `${preset.tenantName}_id` : null;
+}
+/**
+* Every module's file creates this table to record the installed modules.
+* It holds no app data, so the diagram leaves it out.
+*/
+const BOOKKEEPING_TABLES = /* @__PURE__ */ new Set(["better_supabase.modules"]);
+const IDENT = String.raw`(?:"(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)`;
+const QNAME = String.raw`${IDENT}(?:\s*\.\s*${IDENT})?`;
+const CREATE_TABLE = /\bcreate\s+(?:(?:global\s+|local\s+)?(?:temp|temporary)\s+|unlogged\s+)?table\b/giu;
+const CREATE_HEAD = new RegExp(String.raw`^create\s+(?:(?:global\s+|local\s+)?(?:temp|temporary)\s+|unlogged\s+)?table\s+(?:if\s+not\s+exists\s+)?(${QNAME})\s*\(`, "iu");
+const ALTER_TABLE = new RegExp(String.raw`\balter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(${QNAME})\s+([^;]*);`, "giu");
+const REFERENCES = new RegExp(String.raw`\breferences\s+(${QNAME})\s*(?:\(([^)]*)\))?`, "iu");
+const LEADING_IDENT = new RegExp(String.raw`^(${IDENT})\s*`, "u");
+const CONSTRAINT_NAME = new RegExp(String.raw`^constraint\s+${IDENT}\s+`, "iu");
+/** Words that end a column's type in its definition. */
+const TYPE_END = /\s+(?:not\b|null\b|primary\b|references\b|default\b|generated\b|unique\b|check\b|constraint\b|collate\b)/iu;
+function unquote(ident) {
+	const trimmed = ident.trim();
+	return trimmed.startsWith("\"") ? trimmed.slice(1, -1).replaceAll("\"\"", "\"") : trimmed.toLowerCase();
+}
+function qualified(name) {
+	const [first = "", second] = (name.match(new RegExp(IDENT, "gu")) ?? []).map((each) => unquote(each));
+	return second === void 0 ? {
+		schema: "public",
+		table: first
+	} : {
+		schema: first,
+		table: second
+	};
+}
+function identList(list) {
+	return (list ?? "").split(",").map((each) => each.trim()).filter((each) => each !== "").map((each) => unquote(each));
+}
+/**
+* The SQL with comments removed and the inside of every single-quoted string
+* blanked, so a `create table` inside a string or a comment is not read and
+* the offsets still match the original text.
+*/
+function codeOnly(sql) {
+	let out = "";
+	let index = 0;
+	while (index < sql.length) {
+		const char = sql[index];
+		const next = sql[index + 1];
+		if (char === "-" && next === "-") {
+			const end = sql.indexOf("\n", index);
+			const stop = end === -1 ? sql.length : end;
+			out += " ".repeat(stop - index);
+			index = stop;
+		} else if (char === "/" && next === "*") {
+			const end = sql.indexOf("*/", index + 2);
+			const stop = end === -1 ? sql.length : end + 2;
+			out += sql.slice(index, stop).replaceAll(/[^\n]/gu, " ");
+			index = stop;
+		} else if (char === "'") {
+			let stop = index + 1;
+			while (stop < sql.length) if (sql[stop] === "'" && sql[stop + 1] === "'") stop += 2;
+			else if (sql[stop] === "'") break;
+			else stop += 1;
+			out += `'${sql.slice(index + 1, stop).replaceAll(/[^\n]/gu, " ")}'`;
+			index = stop + 1;
+		} else {
+			out += char;
+			index += 1;
+		}
+	}
+	return out;
+}
+/** The text between the `(` at `open` and its matching `)`, or undefined when it never closes. */
+function balanced(text, open) {
+	let depth = 0;
+	for (let index = open; index < text.length; index += 1) if (text[index] === "(") depth += 1;
+	else if (text[index] === ")") {
+		depth -= 1;
+		if (depth === 0) return text.slice(open + 1, index);
+	}
+}
+/** The comma-separated elements of `text` at depth 0, with `original` sliced at the same offsets. */
+function splitTopLevel(text, original = text) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	const push = (end) => {
+		const code = text.slice(start, end);
+		const lead = code.length - code.trimStart().length;
+		const trimmed = code.trim();
+		if (trimmed !== "") parts.push({
+			code: trimmed,
+			original: original.slice(start + lead, start + lead + trimmed.length)
+		});
+	};
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (char === "(") depth += 1;
+		else if (char === ")") depth -= 1;
+		else if (char === "," && depth === 0) {
+			push(index);
+			start = index + 1;
+		}
+	}
+	push(text.length);
+	return parts;
+}
+function lineOf(text, offset) {
+	return text.slice(0, offset).split("\n").length;
+}
+function target(match) {
+	const { schema, table } = qualified(match[1] ?? "");
+	return {
+		schema,
+		table,
+		columns: identList(match[2])
+	};
+}
+const ON_DELETE = /\bon\s+delete\s+(cascade|restrict|set\s+null|set\s+default|no\s+action)\b/iu;
+/** The `on delete` action of a reference, `no action` when it names none. */
+function onDeleteOf(text) {
+	return (ON_DELETE.exec(text)?.[1] ?? "no action").toLowerCase().replaceAll(/\s+/gu, " ");
+}
+/** Words that end a column's default expression at the top level. */
+const DEFAULT_END = /^(?:not\s+null|null|primary\s+key|references|unique|check|constraint|generated|collate)\b/iu;
+/**
+* The `default` expression of a column definition. `definition` is the code
+* with strings blanked and `original` the same text as written, so a keyword
+* inside a string never ends the expression.
+*/
+function defaultOf(definition, original) {
+	const start = /\bdefault\s+/iu.exec(definition);
+	if (start === null) return null;
+	const from = start.index + start[0].length;
+	let depth = 0;
+	let end = definition.length;
+	for (let index = from; index < definition.length; index += 1) {
+		const char = definition[index];
+		if (char === "(") depth += 1;
+		else if (char === ")") depth -= 1;
+		else if (depth === 0 && /\s/u.test(char ?? "") && DEFAULT_END.test(definition.slice(index).trimStart())) {
+			end = index;
+			break;
+		}
+	}
+	return original.slice(from, end).trim();
+}
+/** Adds a column definition (`"name" type ...`) to the draft. */
+function addColumn(draft, definition, original = definition) {
+	const head = definition.match(LEADING_IDENT);
+	if (head === null) return;
+	const name = unquote(head[1] ?? "");
+	const rest = definition.slice(head[0].length);
+	const typeEnd = rest.search(TYPE_END);
+	const type = (typeEnd === -1 ? rest : rest.slice(0, typeEnd)).trim();
+	if (draft.columns.some((column) => column.name === name)) return;
+	const primary = /\bprimary\s+key\b/iu.test(rest);
+	draft.columns.push({
+		name,
+		type,
+		nullable: !primary && !/\bnot\s+null\b/iu.test(rest),
+		default: defaultOf(definition, original),
+		unique: /\bunique\b/iu.test(rest)
+	});
+	if (primary) draft.primaryKey = [name];
+	const references = rest.match(REFERENCES);
+	if (references !== null) draft.foreignKeys.push({
+		columns: [name],
+		target: target(references),
+		onDelete: onDeleteOf(rest)
+	});
+}
+/**
+* Adds a table constraint (`primary key (...)`, `foreign key (...)
+* references ...`). Returns false when the element is not a constraint.
+*/
+function addConstraint(draft, element) {
+	const body = element.replace(CONSTRAINT_NAME, "");
+	const named = body !== element;
+	const primary = /^primary\s+key\s*\(([^)]*)\)/iu.exec(body);
+	if (primary !== null) {
+		draft.primaryKey = identList(primary[1]);
+		return true;
+	}
+	const foreign = /^foreign\s+key\s*\(([^)]*)\)\s*([\s\S]*)$/iu.exec(body);
+	if (foreign !== null) {
+		const references = (foreign[2] ?? "").match(REFERENCES);
+		if (references !== null) draft.foreignKeys.push({
+			columns: identList(foreign[1]),
+			target: target(references),
+			onDelete: onDeleteOf(foreign[2] ?? "")
+		});
+		return true;
+	}
+	return named || /^(?:unique|check|exclude)\b/iu.test(body);
+}
+function finish(draft, tenantColumn) {
+	const tenant = tenantColumn !== null && draft.columns.some((column) => column.name === tenantColumn) ? tenantColumn : null;
+	const primary = new Set(draft.primaryKey);
+	return {
+		id: `${draft.schema}.${draft.name}`,
+		schema: draft.schema,
+		name: draft.name,
+		module: draft.module,
+		primaryKey: draft.primaryKey,
+		foreignKeys: draft.foreignKeys,
+		tenantColumn: tenant,
+		columns: draft.columns.map((column) => primary.has(column.name) ? {
+			...column,
+			nullable: false
+		} : column)
+	};
+}
+/**
+* The tables in rendered module SQL: every `create table`, plus the columns
+* and foreign keys later `alter table ... add` statements give them. A
+* `create table` it can't read throws with the file and line, so a new SQL
+* shape fails the tests instead of dropping a table from the diagram.
+*/
+function parseSchema(files, options = {}) {
+	const drafts = /* @__PURE__ */ new Map();
+	const code = files.map((file) => ({
+		file,
+		text: codeOnly(file.contents)
+	}));
+	for (const { file, text } of code) for (const match of text.matchAll(CREATE_TABLE)) {
+		const offset = match.index;
+		const head = text.slice(offset).match(CREATE_HEAD);
+		const open = head === null ? -1 : offset + head[0].length - 1;
+		const body = open === -1 ? void 0 : balanced(text, open);
+		const original = body === void 0 ? "" : file.contents.slice(open + 1, open + 1 + body.length);
+		if (head === null || body === void 0) throw new Error(`parseSchema can't read the create table at ${file.path}:${lineOf(text, offset)}.`);
+		const { schema, table } = qualified(head[1] ?? "");
+		const id = `${schema}.${table}`;
+		if (drafts.has(id)) continue;
+		const draft = {
+			schema,
+			name: table,
+			module: file.module,
+			columns: [],
+			primaryKey: [],
+			foreignKeys: []
+		};
+		for (const element of splitTopLevel(body, original)) if (!addConstraint(draft, element.code)) addColumn(draft, element.code, element.original);
+		drafts.set(id, draft);
+	}
+	for (const { file, text } of code) for (const match of text.matchAll(ALTER_TABLE)) {
+		const { schema, table } = qualified(match[1] ?? "");
+		const draft = drafts.get(`${schema}.${table}`);
+		if (draft === void 0) continue;
+		const actions = match[2] ?? "";
+		const start = match.index + match[0].lastIndexOf(actions);
+		const original = file.contents.slice(start, start + actions.length);
+		for (const action of splitTopLevel(actions, original)) {
+			const column = /^add\s+column\s+(?:if\s+not\s+exists\s+)?/iu.exec(action.code);
+			if (column !== null) addColumn(draft, action.code.slice(column[0].length), action.original.slice(column[0].length));
+			else if (/^add\s+/iu.test(action.code)) addConstraint(draft, action.code.replace(/^add\s+/iu, ""));
+		}
+	}
+	const tenantColumn = options.tenantColumn ?? null;
+	return [...drafts.entries()].filter(([id]) => !BOOKKEEPING_TABLES.has(id)).map(([, draft]) => finish(draft, tenantColumn));
+}
+/**
+* The statements that shape one table, as written: its `create table` and
+* the `alter table` statements after it. Empty when no file creates it.
+*/
+function tableStatements(files, id) {
+	const statements = [];
+	for (const file of files) {
+		const text = codeOnly(file.contents);
+		for (const match of text.matchAll(CREATE_TABLE)) {
+			const head = text.slice(match.index).match(CREATE_HEAD);
+			if (head === null) continue;
+			const { schema, table } = qualified(head[1] ?? "");
+			const open = match.index + head[0].length - 1;
+			const body = balanced(text, open);
+			if (`${schema}.${table}` !== id || body === void 0) continue;
+			const end = text.indexOf(";", open + body.length + 1);
+			statements.push(file.contents.slice(match.index, end === -1 ? text.length : end + 1));
+		}
+		for (const match of text.matchAll(ALTER_TABLE)) {
+			const { schema, table } = qualified(match[1] ?? "");
+			if (`${schema}.${table}` === id) statements.push(file.contents.slice(match.index, match.index + match[0].length));
+		}
+	}
+	return statements;
+}
+/** The foreign keys between tables, one per pair, with the targets outside the schema named by id. */
+function schemaRelations(tables) {
+	const seen = /* @__PURE__ */ new Set();
+	return tables.flatMap((table) => table.foreignKeys.flatMap((key) => {
+		const to = `${key.target.schema}.${key.target.table}`;
+		const pair = `${table.id}>${to}`;
+		if (to === table.id || seen.has(pair)) return [];
+		seen.add(pair);
+		return [{
+			from: table.id,
+			to
+		}];
+	}));
+}
+//#endregion
+//#region src/create/migration.ts
+/** The module whose file holds the app's own tables. */
+const APP_TABLES_MODULE = "app-tables";
+/**
+* The migration that takes a project deployed from `base` to `next`, for
+* added tables and added columns only. The rendered app-table SQL is
+* idempotent (`create table if not exists`, `add column if not exists`,
+* `drop policy if exists`), so the migration is the re-rendered file.
+* Anything else, such as a rename, a retype, a changed default or a change
+* outside `appTables`, is refused so a deploy never guesses.
+*/
+function migrationBetween(code, base, next) {
+	const changes = diffDesigns(base, next);
+	const breaking = changes.filter((change) => change.breaking);
+	if (breaking.length > 0) return {
+		ok: false,
+		reason: "breaking",
+		changes: breaking
+	};
+	const unsupported = changes.filter((change) => change.kind !== "table.added" && change.kind !== "column.added");
+	if (unsupported.length > 0) return {
+		ok: false,
+		reason: "unsupported",
+		changes: unsupported
+	};
+	const before = new Map(previewFiles(code, base).map((file) => [file.path, file.contents]));
+	const differing = previewFiles(code, next).filter((file) => before.get(file.path) !== file.contents);
+	if (differing.some((file) => file.module !== APP_TABLES_MODULE)) return {
+		ok: false,
+		reason: "unsupported",
+		changes
+	};
+	return {
+		ok: true,
+		sql: differing.map((file) => `-- ${file.path}\n${file.contents.trim()}\n`).join("\n"),
+		changes
+	};
+}
+//#endregion
+export { APP_MODULE, COLUMN_KINDS, EMPTY_DESIGN, HISTORY_LIMIT, KIND_GROUPS, MIGRATION_NAME, APP_ON_DELETE_ACTIONS as ON_DELETE_ACTIONS, ROLLUP_AGGREGATES, SAMPLE_ROW_COUNT, addTable, appTableId, boundError, columnError, columnLabel, computedColumnRenamed, computedRows, computedTableRenamed, connect, dashboardUrl, defaultError, deleteColumn, deleteExtraColumn, deleteTable, deployBlocker, deployQuery, designIssues, duplicateTable, editTable, eventsColumnsEdited, filterColumns, fitted, fittedRollup, freeTableName, generatePassword, hiddenColumns, identifierError, initialHistory, isAppTable, isEmptyDesign, isRollupAggregate, keyColumnsOf, kindById, kindOf, lockedWithoutDefault, lookupSources, migrationBetween, moveTables, optionError, parseSchema, previewAccessProvider, previewFiles, prunedComputed, readableColumns, referenceFrom, renameColumn, renameTable, rollupColumns, rollupSources, sampleRows, schemaData, schemaRelations, setColumn, setColumnKind, setExtraColumn, setTableId, singular, subjectColumns, subjectColumnsEdited, subjectTypeError, suggestedProjectName, tableStatements, tableWithComputed, tableWithoutComputed, takesBounds, tenantColumnOf, tidy, undoHistory, updateTable, userConnection, withBounds, withDesign, withKind };