better-supabase 0.12.0 → 0.14.0

package/dist/preset-DzcQ5CQM.js

@@ -0,0 +1,841 @@
+import { c as PRESET_CATALOG, i as presetOf, r as presetConfig, v as encodePreset } from "./config-Dh4D8lBa.js";
+import { O as asBlocksConfig, d as appTablesOf } from "./app-tables-C5aoI5rZ.js";
+import { r as FIELD_FORMATS } from "./field-formats-C6QKA3UR.js";
+//#region src/preset/render.ts
+const CREATE_URL = "https://app.bettersupabase.com/create";
+/** The comment a config with the provider access model gets above `blocks`. */
+const PROVIDER_COMMENT = ["  // The provider access model reads roles from your authorization", "  // library: set `authorization` to its adapter."];
+const key = (name) => /^[a-z_$][a-z0-9_$]*$/i.test(name) ? name : JSON.stringify(name);
+const camel = (name) => name.replaceAll(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+/** A JSON value as a TypeScript literal, one line. */
+function literal(value) {
+	if (Array.isArray(value)) return `[${value.map(literal).join(", ")}]`;
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		return `{ ${entries.map(([name, each]) => `${key(name)}: ${literal(each)}`).join(", ")} }`;
+	}
+	return JSON.stringify(value);
+}
+/** The `/create` URL of a preset, with `&design=` when `designCode` isn't empty. */
+function createUrl(resolved, designCode = "") {
+	const preset = `${CREATE_URL}?preset=${encodePreset(resolved.preset)}`;
+	return designCode === "" ? preset : `${preset}&design=${designCode}`;
+}
+/**
+* `better-supabase.config.ts` with these keys: every block with its reason, the
+* conventions, and the app tables, under a comment with the `/create` URL.
+*/
+function configSource(resolved, config, url) {
+	const lines = [
+		"import { defineConfig } from \"better-supabase/config\";",
+		"",
+		`// ${url}`,
+		"export default defineConfig({"
+	];
+	if (config.casing !== void 0) lines.push(`  casing: ${literal(config.casing)},`);
+	if (config.sql !== void 0) lines.push(`  sql: ${literal(config.sql)},`);
+	if (config.integrations !== void 0) lines.push(`  integrations: ${literal(config.integrations)},`);
+	if (resolved.preset.access === "provider") lines.push(...PROVIDER_COMMENT);
+	lines.push("  blocks: {");
+	const entries = Object.entries(config.blocks);
+	for (const block of resolved.blocks) {
+		const entry = entries.find(([name]) => name === block.name)?.[1] ?? {};
+		const note = block.selected ? "" : ` // ${block.reason}`;
+		lines.push(`    ${key(block.name)}: ${literal(entry)},${note}`);
+	}
+	lines.push("  },");
+	if (config.appTables !== void 0) {
+		lines.push("  appTables: {");
+		for (const [name, table] of Object.entries(config.appTables)) lines.push(`    ${key(name)}: ${literal(table)},`);
+		lines.push("  },");
+	}
+	lines.push("});", "");
+	return lines.join("\n");
+}
+/**
+* `better-supabase.config.ts` for a resolved preset: every block with its
+* reason, and the conventions that differ from the defaults.
+*/
+function presetConfigSource(resolved) {
+	return configSource(resolved, presetConfig(resolved), createUrl(resolved));
+}
+/**
+* `lib/blocks.ts`: the blocks with a TypeScript client, wired with
+* `defineBlocks` over the Data API as the caller. Each block's schema (the API
+* schema when `sql.api` is set) and shared options come from `blockConfig`,
+* which `better-supabase gen` writes to `blocks.generated.ts`;
+* `blockConfigImport` is its import path.
+*/
+function presetBlocksSource(resolved, blockConfigImport = "./supabase/blocks.generated") {
+	const clients = resolved.manifests.flatMap((manifest) => manifest.client === null ? [] : [{
+		name: manifest.name,
+		...manifest.client
+	}]);
+	return [
+		"import {",
+		"  type RpcClient,",
+		"  defineBlocks,",
+		"  rpcTransport,",
+		"} from \"better-supabase/blocks\";",
+		...clients.map((client) => `import { ${client.export} } from "${client.subpath}";`),
+		"",
+		`import { blockConfig } from ${JSON.stringify(blockConfigImport)};`,
+		"",
+		"/** The installed blocks, with the settings `better-supabase gen` writes from the config. */",
+		"export const blockSet = defineBlocks(blockConfig, {",
+		...clients.map((client) => `  ${camel(client.name)}: ${client.export},`),
+		"});",
+		"",
+		"/**",
+		" * The blocks as typed clients, acting as the caller of `supabase`: its",
+		" * token, so RLS and each function's checks apply.",
+		" */",
+		"export function blocks(supabase: RpcClient) {",
+		"  return blockSet.create({ transport: rpcTransport(supabase) });",
+		"}",
+		""
+	].join("\n");
+}
+/** Where `presetBlocksSource` goes, as a shadcn target. */
+const WIRING_TARGET = "@lib/blocks.ts";
+/**
+* The registry glue for the preset's framework and platforms: each item whose
+* blocks are all installed, except bundles and items that write
+* `lib/blocks.ts`, which the preset writes itself.
+*/
+function presetGlue(resolved, catalog = PRESET_CATALOG) {
+	const { preset } = resolved;
+	const platforms = preset.platforms === "both" ? ["web", "native"] : [preset.platforms];
+	const installed = new Set(resolved.blocks.map((block) => block.name));
+	return catalog.glue.filter((item) => item.preset === void 0 && !item.targets.includes(WIRING_TARGET) && item.frameworks.includes(preset.framework) && item.platforms.some((platform) => platforms.includes(platform)) && item.blocks.every((block) => installed.has(block)));
+}
+/** The shadcn command that copies glue items into the app. */
+function glueCommand(items) {
+	return `npx shadcn@latest add ${items.map((item) => `@better-supabase/${item.name}`).join(" ")}`;
+}
+/** The command that starts a project from the preset. */
+function presetInstallCommand(resolved) {
+	return `npx better-supabase init --preset ${encodePreset(resolved.preset)}`;
+}
+/** The command that applies the preset to an existing project. */
+function presetApplyCommand(resolved) {
+	return `npx better-supabase apply --preset ${encodePreset(resolved.preset)}`;
+}
+//#endregion
+//#region src/preset/design.ts
+/**
+* The first character of a design code: how it is encoded. `0` is deflate-raw
+* compressed JSON in base64url. Preset codes never start with `0` (their first
+* character is the preset version, from 1), and preset names never start with a
+* digit. The JSON's own format is `DESIGN_FORMAT`.
+*/
+const DESIGN_VERSION = "0";
+/**
+* The newest format of the design JSON, in its `version` key (ADR 0042). A code
+* carries the lowest format that reads it, and none for format 0, so a design
+* without format 1 keys still opens in an older release. Format 1 adds column
+* `format`, `options`, `min`, `max`, `comment` and `identity`, and table `id`,
+* `unique`, `indexes` and `comment`. Format 2 adds table `subject` (ADR 0043).
+* Format 3 adds table `rollups` and `lookups` (ADR 0044). Format 4 adds table
+* `events` (ADR 0048) and subject `versions`. Format 5 adds column `access`
+* (ADR 0051). Format 6 adds column `encrypted` and table `auditReads` (ADR
+* 0087).
+*/
+const DESIGN_FORMAT = 6;
+const FORMAT_1_TABLE_KEYS = [
+	"id",
+	"unique",
+	"indexes",
+	"comment"
+];
+const FORMAT_1_COLUMN_KEYS = [
+	"format",
+	"options",
+	"min",
+	"max",
+	"comment",
+	"identity"
+];
+/** The lowest design format that reads `design`. */
+function designFormat(design) {
+	const tables = Object.values(design.appTables ?? {});
+	if (tables.some((table) => table.auditReads !== void 0 || Object.values(table.columns ?? {}).some((column) => column.encrypted !== void 0))) return 6;
+	if (tables.some((table) => Object.values(table.columns ?? {}).some((column) => column.access !== void 0))) return 5;
+	if (tables.some((table) => table.events !== void 0 || table.subject?.versions !== void 0)) return 4;
+	if (tables.some((table) => table.rollups !== void 0 || table.lookups !== void 0)) return 3;
+	if (tables.some((table) => table.subject !== void 0)) return 2;
+	return tables.some((table) => FORMAT_1_TABLE_KEYS.some((key) => table[key] !== void 0) || Object.values(table.columns ?? {}).some((column) => FORMAT_1_COLUMN_KEYS.some((key) => column[key] !== void 0))) ? 1 : 0;
+}
+/** The longest design code, so a `/create` URL stays under common limits. */
+const MAX_DESIGN_CODE_LENGTH = 6e3;
+/** The name Create gives the design file it downloads. */
+const DESIGN_FILE = "better-supabase.design.json";
+/**
+* What `parseDesign`, `decodeDesign`, `designFileSource` and `readDesignFile`
+* throw.
+*/
+var DesignParseError = class extends TypeError {
+	code;
+	path;
+	constructor(code, path, message, options) {
+		super(message, options);
+		this.name = "DesignParseError";
+		this.code = code;
+		this.path = path;
+	}
+	/** The issue as a plain, serializable object. */
+	toJSON() {
+		return {
+			code: this.code,
+			path: this.path,
+			message: this.message
+		};
+	}
+};
+/** The JSON Pointer to `segments`, escaping `~` and `/`. */
+const jsonPointer = (...segments) => segments.map((segment) => `/${String(segment).replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+/**
+* What `encodeDesign` throws when a valid design is too long for a URL, so a
+* caller can offer the config download instead of a fix.
+*/
+var DesignTooLongError = class extends DesignParseError {
+	/** The length the code would have. */
+	length;
+	constructor(length) {
+		super("too_long", "", `design: the code is ${String(length)} characters; the most a URL carries is ${String(MAX_DESIGN_CODE_LENGTH)}. Download the design file instead, then run \`better-supabase init --preset ./${DESIGN_FILE}\`.`);
+		this.name = "DesignTooLongError";
+		this.length = length;
+	}
+};
+/** The most bytes a design code inflates to; a longer one is rejected. */
+const MAX_DESIGN_BYTES = 262144;
+const MAX_TABLES = 100;
+const MAX_EXTRA_COLUMNS = 64;
+const MAX_POSITIONS = 1e3;
+const MAX_COORDINATE = 1e6;
+const DESIGN_CODE = /^0[A-Za-z0-9_-]+$/;
+const COLUMN = /^[a-z_][a-z0-9_]{0,62}$/;
+const SQL_TYPE = /^[a-z][a-z0-9_ (),.'[\]-]*$/i;
+const QUALIFIED = /^[a-z_][a-z0-9_]{0,62}\.[a-z_][a-z0-9_]{0,62}$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether `value` has the shape of a design code. It may still fail to decode. */
+function isDesignCode(value) {
+	return value.length <= 6e3 && DESIGN_CODE.test(value);
+}
+function extraColumnsOf(value, catalog) {
+	if (!isRecord(value)) throw new DesignParseError("invalid_design", "/extraColumns", "design.extraColumns must be an object");
+	return Object.fromEntries(Object.entries(value).map(([module, columns]) => {
+		const at = `design.extraColumns.${module}`;
+		const path = jsonPointer("extraColumns", module);
+		const block = catalog.blocks.find((each) => each.name === module);
+		if (block === void 0) throw new DesignParseError("unknown_block", path, `${at}: "${module}" is not a block`);
+		if (block.extraColumns === void 0) throw new DesignParseError("no_extra_columns", path, `${at}: the ${module} block takes no extra columns`);
+		if (!isRecord(columns)) throw new DesignParseError("invalid_design", path, `${at} must be an object of column name to SQL type`);
+		const entries = Object.entries(columns);
+		if (entries.length > MAX_EXTRA_COLUMNS) throw new DesignParseError("too_large", path, `${at} has ${String(entries.length)} columns; the most is ${String(MAX_EXTRA_COLUMNS)}`);
+		const checked = {};
+		for (const [name, type] of entries) {
+			if (!COLUMN.test(name)) throw new DesignParseError("invalid_name", jsonPointer("extraColumns", module, name), `${at}: "${name}" is not a valid column name`);
+			if (typeof type !== "string" || !SQL_TYPE.test(type) || type.includes("--")) throw new DesignParseError("invalid_type", jsonPointer("extraColumns", module, name), `${at}.${name} must be a SQL type such as "text not null default ''"`);
+			checked[name] = type;
+		}
+		return [module, checked];
+	}));
+}
+function coordinate(value) {
+	return typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= MAX_COORDINATE;
+}
+function pairOf(value) {
+	if (!Array.isArray(value) || value.length !== 2) return;
+	const x = value[0];
+	const y = value[1];
+	return coordinate(x) && coordinate(y) ? [x, y] : void 0;
+}
+function positionsOf(value) {
+	if (!isRecord(value)) throw new DesignParseError("invalid_design", "/positions", "design.positions must be an object");
+	const entries = Object.entries(value);
+	if (entries.length > MAX_POSITIONS) throw new DesignParseError("too_large", "/positions", `design.positions has ${String(entries.length)} entries; the most is ${String(MAX_POSITIONS)}`);
+	return Object.fromEntries(entries.map(([table, position]) => {
+		if (!QUALIFIED.test(table)) throw new DesignParseError("invalid_name", jsonPointer("positions", table), `design.positions: "${table}" is not a schema.table name`);
+		const pair = pairOf(position);
+		if (pair === void 0) throw new DesignParseError("invalid_position", jsonPointer("positions", table), `design.positions.${table} must be [x, y], two finite numbers`);
+		return [table, pair];
+	}));
+}
+/**
+* Checks a design object, such as one from storage or a request body, and drops
+* its empty parts. It runs the same checks as `decodeDesign`, without the code.
+* Throws a `DesignParseError` naming the first problem; `safeParseDesign`
+* returns it instead.
+*/
+function parseDesign(value) {
+	return designOfValue(value);
+}
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+function issuesOf(error) {
+	return [error instanceof DesignParseError ? error.toJSON() : {
+		code: "invalid_design",
+		path: "",
+		message: messageOf(error)
+	}];
+}
+/**
+* `parseDesign` without the throw: the design, or the issue that stopped it,
+* with a stable `code` and a JSON Pointer `path`.
+*/
+function safeParseDesign(value) {
+	try {
+		return {
+			ok: true,
+			design: designOfValue(value)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			issues: issuesOf(error)
+		};
+	}
+}
+/** The keys of a JSON Pointer, unescaped. */
+const pointerKeys = (path) => path === "" ? [] : path.slice(1).split("/").map((key) => key.replaceAll("~1", "/").replaceAll("~0", "~"));
+/**
+* A Standard Schema (v1) for a design, so a form library, a router or an AI SDK
+* tool can validate one with the same rules as `parseDesign`. The output drops
+* the empty parts; each issue's `path` lists the keys of its JSON Pointer.
+* `schemas/design-v1.json` is the JSON Schema of its shape.
+*/
+const designSchema = { "~standard": {
+	version: 1,
+	vendor: "better-supabase",
+	validate(value) {
+		const result = safeParseDesign(value);
+		return result.ok ? { value: result.design } : { issues: result.issues.map((issue) => ({
+			message: issue.message,
+			path: pointerKeys(issue.path)
+		})) };
+	}
+} };
+const SEGMENT_CHAR = /[A-Za-z0-9_]/;
+const INDEX_SEGMENT = /^\[(\d+)\]/;
+const TRAILING_KEY = /^\.([A-Za-z0-9_]+)(?=[\s:]|$)/;
+/** The longest key of `node` that `rest` starts with, after a dot. */
+function keyAt(node, rest) {
+	return Object.keys(node).filter((each) => rest.startsWith(`.${each}`) && !SEGMENT_CHAR.test(rest.charAt(each.length + 1))).toSorted((a, b) => b.length - a.length)[0];
+}
+/**
+* The JSON Pointer for an `appTablesOf` message, which starts with the dotted
+* path it rejects (`appTables.tasks.columns.title must be...`). It walks
+* `value` so a key with a dot or a space still resolves.
+*/
+function appTablesPointer(message, value) {
+	const segments = ["appTables"];
+	let rest = message.startsWith("appTables") ? message.slice(9) : "";
+	let current = value;
+	for (;;) {
+		const index = INDEX_SEGMENT.exec(rest);
+		if (index !== null && Array.isArray(current)) {
+			const at = Number(index[1]);
+			segments.push(at);
+			current = current[at];
+			rest = rest.slice(index[0].length);
+			continue;
+		}
+		const node = current;
+		const key = isRecord(node) ? keyAt(node, rest) : void 0;
+		if (key === void 0 || !isRecord(node)) break;
+		segments.push(key);
+		current = node[key];
+		rest = rest.slice(key.length + 1);
+	}
+	const trailing = TRAILING_KEY.exec(rest);
+	if (trailing?.[1] !== void 0) segments.push(trailing[1]);
+	return jsonPointer(...segments);
+}
+function checkedAppTables(value, tenantName) {
+	try {
+		return appTablesOf(value, tenantName);
+	} catch (error) {
+		if (!(error instanceof TypeError) || error instanceof DesignParseError) throw error;
+		throw new DesignParseError("invalid_app_table", appTablesPointer(error.message, value), error.message, { cause: error });
+	}
+}
+function designOfValue(value, catalog = PRESET_CATALOG) {
+	if (!isRecord(value)) throw new DesignParseError("invalid_design", "", "design must be an object");
+	const unknownKey = Object.keys(value).find((name) => name !== "appTables" && name !== "extraColumns" && name !== "positions" && name !== "version");
+	if (unknownKey !== void 0) throw new DesignParseError("unknown_key", jsonPointer(unknownKey), `design: unknown key "${unknownKey}"; a design has appTables, extraColumns and positions`);
+	const version = value["version"] ?? 0;
+	if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 0) throw new DesignParseError("invalid_design", "/version", "design.version must be a whole number");
+	if (version > 6) throw new DesignParseError("unsupported_format", "/version", `design: the code needs format ${String(version)}, and this better-supabase reads up to ${String(6)}; update better-supabase`);
+	const appTables = value["appTables"] === void 0 ? {} : checkedAppTables(value["appTables"]);
+	if (Object.keys(appTables).length > MAX_TABLES) throw new DesignParseError("too_large", "/appTables", `design.appTables has ${String(Object.keys(appTables).length)} tables; the most is ${String(MAX_TABLES)}`);
+	const extraColumns = value["extraColumns"] === void 0 ? {} : extraColumnsOf(value["extraColumns"], catalog) ?? {};
+	const positions = value["positions"] === void 0 ? {} : positionsOf(value["positions"]) ?? {};
+	const filled = Object.fromEntries(Object.entries(extraColumns).filter(([, columns]) => Object.keys(columns).length > 0));
+	return {
+		...Object.keys(appTables).length === 0 ? {} : { appTables },
+		...Object.keys(filled).length === 0 ? {} : { extraColumns: filled },
+		...Object.keys(positions).length === 0 ? {} : { positions }
+	};
+}
+async function pipe(bytes, transform, limit) {
+	const reader = new Blob([bytes]).stream().pipeThrough(transform).getReader();
+	const chunks = [];
+	let length = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		length += value.byteLength;
+		if (length > limit) {
+			await reader.cancel();
+			throw new DesignParseError("invalid_code", "", `design: the code inflates past ${String(limit)} bytes`);
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+function toBase64Url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCodePoint(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/[=]+$/, "");
+}
+function fromBase64Url(text) {
+	const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+	return Uint8Array.from(binary, (char) => char.codePointAt(0) ?? 0);
+}
+/**
+* The design as a code for the `&design=` parameter: `0`, then its JSON (with
+* `version` set to `designFormat` when it is above 0) compressed with
+* deflate-raw, in base64url. An empty design is `""`. Throws a
+* `DesignParseError` when the design is invalid, and a `DesignTooLongError`
+* when the code would be longer than `MAX_DESIGN_CODE_LENGTH`.
+*/
+async function encodeDesign(design) {
+	const checked = designOfValue(design);
+	if (Object.keys(checked).length === 0) return "";
+	const format = designFormat(checked);
+	const json = new TextEncoder().encode(JSON.stringify(format === 0 ? checked : {
+		version: format,
+		...checked
+	}));
+	const code = `${DESIGN_VERSION}${toBase64Url(await pipe(json, new CompressionStream("deflate-raw"), MAX_DESIGN_BYTES))}`;
+	if (code.length > 6e3) throw new DesignTooLongError(code.length);
+	return code;
+}
+/** Reads a design code. Throws a `DesignParseError` when it isn't a valid one. */
+async function decodeDesign(code) {
+	if (code === "") return {};
+	if (!isDesignCode(code)) throw new DesignParseError("invalid_code", "", code.length > 6e3 ? `design: the code is longer than ${String(MAX_DESIGN_CODE_LENGTH)} characters` : `design: "${code.slice(0, 40)}" is not a design code`);
+	let json;
+	try {
+		const bytes = await pipe(fromBase64Url(code.slice(1)), new DecompressionStream("deflate-raw"), MAX_DESIGN_BYTES);
+		json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch (error) {
+		if (error instanceof DesignParseError) throw error;
+		throw new DesignParseError("invalid_code", "", "design: the code is damaged; copy it again from /create", { cause: error });
+	}
+	return designOfValue(json);
+}
+/**
+* The design in a `/create` URL's `&design=` parameter, or in a bare design
+* code; `undefined` when `input` has neither.
+*/
+async function designOf(input) {
+	const parameter = /[?&]design=([^&#]*)/.exec(input)?.[1];
+	if (parameter !== void 0) return decodeDesign(decodeURIComponent(parameter));
+	return isDesignCode(input) ? decodeDesign(input) : void 0;
+}
+/**
+* The config keys a preset with a design sets: `presetConfig`, with each
+* block's `options.extraColumns` and `appTables`. Throws a `DesignParseError`
+* when the design adds columns to a block the preset doesn't install.
+*/
+function designConfig(resolved, design) {
+	const base = presetConfig(resolved);
+	const blocks = { ...base.blocks };
+	for (const [module, columns] of Object.entries(design.extraColumns ?? {})) {
+		const entry = blocks[module];
+		if (entry === void 0) throw new DesignParseError("block_not_installed", jsonPointer("extraColumns", module), `design.extraColumns.${module}: the preset doesn't install the ${module} block`);
+		blocks[module] = {
+			...entry,
+			options: {
+				...entry.options,
+				extraColumns: columns
+			}
+		};
+	}
+	const appTables = design.appTables === void 0 ? {} : checkedAppTables(design.appTables, resolved.preset.tenantName);
+	return {
+		...base,
+		blocks: asBlocksConfig(blocks),
+		...Object.keys(appTables).length === 0 ? {} : { appTables }
+	};
+}
+/**
+* `better-supabase.config.ts` for a preset with a design. `designCode`, the
+* design's `encodeDesign`, goes into the `/create` URL in the comment, so the
+* canvas reopens with its positions.
+*/
+function designConfigSource(resolved, design, designCode = "") {
+	return configSource(resolved, designConfig(resolved, design), createUrl(resolved, designCode));
+}
+/**
+* The command that starts a project from the preset and design: `init` with the
+* quoted `/create` URL, or `presetInstallCommand` when `designCode` is empty.
+*/
+function designInstallCommand(resolved, designCode) {
+	return designCode === "" ? presetInstallCommand(resolved) : `npx better-supabase init --preset "${createUrl(resolved, designCode)}"`;
+}
+/**
+* The design file for a preset and design, as JSON text. Throws a
+* `DesignParseError` when the design is invalid; `safeDesignFileSource` returns
+* it instead. It has no length limit.
+*/
+function designFileSource(resolved, design) {
+	const checked = designOfValue(design);
+	const format = designFormat(checked);
+	const file = {
+		preset: encodePreset(resolved.preset),
+		design: format === 0 ? checked : {
+			version: format,
+			...checked
+		}
+	};
+	return `${JSON.stringify(file, null, 2)}\n`;
+}
+/**
+* `designFileSource` without the throw: the file text, or the issue that
+* stopped it. Each `path` points into the design.
+*/
+function safeDesignFileSource(resolved, design) {
+	try {
+		return {
+			ok: true,
+			source: designFileSource(resolved, design)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			issues: issuesOf(error)
+		};
+	}
+}
+/**
+* Reads a design file's text. Each `DesignParseError` path points into the
+* file, so a design problem starts with `/design`. Throws one naming the first
+* problem: text that isn't JSON, a missing or invalid preset, or an invalid
+* design.
+*/
+function readDesignFile(text) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch (error) {
+		throw new DesignParseError("invalid_file", "", "design file: the text is not JSON", { cause: error });
+	}
+	if (!isRecord(value)) throw new DesignParseError("invalid_file", "", "design file: expected an object with preset and design");
+	const unknownKey = Object.keys(value).find((name) => name !== "preset" && name !== "design");
+	if (unknownKey !== void 0) throw new DesignParseError("unknown_key", jsonPointer(unknownKey), `design file: unknown key "${unknownKey}"; a design file has preset and design`);
+	const preset = value["preset"];
+	if (typeof preset !== "string" || preset === "") throw new DesignParseError("invalid_preset", "/preset", "design file: preset must be a preset name or code from /create");
+	let parsed;
+	try {
+		parsed = presetOf(preset);
+	} catch (error) {
+		throw new DesignParseError("invalid_preset", "/preset", messageOf(error), { cause: error });
+	}
+	try {
+		return {
+			preset: parsed,
+			design: designOfValue(value["design"] ?? {})
+		};
+	} catch (error) {
+		if (error instanceof DesignParseError) throw new DesignParseError(error.code, `/design${error.path}`, error.message, { cause: error });
+		throw error;
+	}
+}
+/** The command that applies the preset and design to an existing project. */
+function designApplyCommand(resolved, designCode) {
+	return designCode === "" ? presetApplyCommand(resolved) : `npx better-supabase apply --preset "${createUrl(resolved, designCode)}"`;
+}
+//#endregion
+//#region src/preset/design-diff.ts
+/** `value` as JSON with sorted keys, so two configs compare by content. */
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.entries(value).filter(([, each]) => each !== void 0).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, each]) => `${JSON.stringify(key)}:${canonical(each)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+const same = (a, b) => canonical(a) === canonical(b);
+const isRequired = (column) => column.nullable === false;
+const lacksDefault = (column) => column.default === void 0 && column.identity !== true;
+const safe = (kind, table, summary, column) => ({
+	kind,
+	table,
+	...column === void 0 ? {} : { column },
+	breaking: false,
+	summary,
+	steps: []
+});
+const breakingChange = (kind, table, summary, steps, column) => ({
+	kind,
+	table,
+	...column === void 0 ? {} : { column },
+	breaking: true,
+	summary,
+	steps
+});
+/**
+* The steps that make a new check or constraint safe on rows that may not pass
+* it.
+*/
+const checkSteps = (target, rule) => [
+	`Find the rows where ${target} doesn't ${rule}, and fix them in a migration.`,
+	`Make the app write only values that ${rule}, then deploy.`,
+	`Add the constraint.`
+];
+const targetOf = (reference) => reference === void 0 ? "" : "block" in reference ? `${reference.block}.${reference.table}` : reference.table;
+/** How closed a column's access is: none, then `read`, then `server`. */
+const ACCESS_RANK = {
+	read: 1,
+	server: 2
+};
+const accessRank = (column) => column.access === void 0 ? 0 : ACCESS_RANK[column.access];
+/**
+* The changes to one column whose name and type stay: each new or tighter
+* constraint is breaking, because rows already in the table may not pass it;
+* anything else (a comment, a default, `onDelete`, a looser rule) is safe.
+*/
+function constraintChanges(table, name, before, after) {
+	const at = `${table}.${name}`;
+	const changes = [];
+	if (before.unique !== true && after.unique === true) changes.push(breakingChange("column.unique", table, `Makes ${at} unique, which fails while two rows share a value.`, checkSteps(at, "repeat a value"), name));
+	const removed = after.options === void 0 ? [] : before.options === void 0 ? after.options : before.options.filter((option) => !after.options?.includes(option));
+	if (after.options !== void 0 && removed.length > 0) changes.push(breakingChange("column.options", table, before.options === void 0 ? `Limits ${at} to ${after.options.join(", ")}.` : `Removes ${removed.join(", ")} from the options of ${at}.`, checkSteps(at, `hold one of ${after.options.join(", ")}`), name));
+	const raised = after.min !== void 0 && (before.min === void 0 || after.min > before.min);
+	const lowered = after.max !== void 0 && (before.max === void 0 || after.max < before.max);
+	if (raised || lowered) changes.push(breakingChange("column.bounds", table, `Narrows the bounds of ${at}${after.min === void 0 ? "" : ` to at least ${String(after.min)}`}${after.max === void 0 ? "" : `${after.min === void 0 ? " to" : " and"} at most ${String(after.max)}`}.`, checkSteps(at, "fit the new bounds"), name));
+	const checks = (format) => {
+		const rule = format === void 0 ? void 0 : FIELD_FORMATS[format];
+		return rule?.pattern !== void 0 || rule?.bounds !== void 0;
+	};
+	if (after.format !== void 0 && after.format !== before.format && checks(after.format)) changes.push(breakingChange("column.format", table, `Checks ${at} as ${after.format}.`, checkSteps(at, `hold a valid ${after.format}`), name));
+	if (after.references !== void 0 && targetOf(before.references) !== targetOf(after.references)) changes.push(breakingChange("column.reference", table, `Points ${at} at ${targetOf(after.references)}, which fails for values that row doesn't have.`, checkSteps(at, `match a row of ${targetOf(after.references)}`), name));
+	if (accessRank(after) > accessRank(before)) changes.push(breakingChange("column.access", table, after.access === "server" ? `Hides ${at} from signed-in users, so client reads and writes of it fail.` : `Makes ${at} read-only for signed-in users, so client writes of it fail.`, [`Move every client ${after.access === "server" ? "read and write" : "write"} of ${at} to server code that uses the service role, then deploy.`, `Change the access of ${at}.`], name));
+	if (before.encrypted === true !== (after.encrypted === true)) changes.push(breakingChange("column.encrypted", table, after.encrypted === true ? `Encrypts ${at}, so client reads of it fail; they go through ${table}_reveal instead.` : `Stops encrypting ${at}, which still holds ciphertext.`, after.encrypted === true ? [`Move every client read of ${at} to ${table}_reveal, then deploy.`, `Encrypt ${at}, then run update ${table} set ${name} = ${name} to encrypt the rows it already has.`] : [`Reveal ${at} with the service role and write each value to a new column.`, `Move app code to the new column, then drop ${at}.`], name));
+	if (changes.length === 0 && !same(before, after)) changes.push(safe("column.changed", table, `Changes ${at}.`, name));
+	return changes;
+}
+/**
+* The changes to a table's own keys: a new scope, unique set, or a removed
+* `timestamps`, `rank` or `softDelete` breaks what exists; the rest (indexes,
+* the comment, other subject keys) is safe.
+*/
+function tableChanges(name, before, after) {
+	const changes = [];
+	if ((before.scope ?? "inherit") !== (after.scope ?? "inherit")) changes.push(breakingChange("table.scope", name, `Changes the scope of ${name} from ${before.scope ?? "inherit"} to ${after.scope ?? "inherit"}, which changes its scope column and policies.`, [
+		`Add the new scope column as nullable and fill it for every row in a migration.`,
+		`Move the app to the new scope, then deploy.`,
+		`Change the scope and drop the old column in a later migration.`
+	]));
+	const sets = (table) => new Set((table.unique ?? []).map((set) => set.join(",")));
+	const oldSets = sets(before);
+	const added = [...sets(after)].filter((set) => !oldSets.has(set));
+	if (added.length > 0) changes.push(breakingChange("table.unique", name, `Adds unique (${added.join("), (")}) to ${name}, which fails while two rows share those values.`, checkSteps(`(${added.join("), (")})`, "repeat across rows")));
+	const dropped = [
+		before.timestamps !== false && after.timestamps === false ? "timestamps" : void 0,
+		before.subject?.rank !== void 0 && after.subject?.rank === void 0 ? "rank" : void 0,
+		before.subject?.softDelete === true && after.subject?.softDelete !== true ? "softDelete" : void 0
+	].filter((each) => each !== void 0);
+	if (dropped.length > 0) changes.push(breakingChange("table.columns", name, `Removes ${dropped.join(", ")} from ${name}, which drops the columns ${dropped.length === 1 ? "it adds" : "they add"} and their values.`, [
+		`Stop reading ${dropped.join(", ")} in the app, then deploy.`,
+		`Export the values first if you need them.`,
+		`Remove the key and generate the migration that drops the columns.`
+	]));
+	const rest = (config) => ({
+		...config,
+		columns: void 0,
+		id: void 0,
+		rollups: void 0,
+		lookups: void 0,
+		events: void 0,
+		subject: config.subject === void 0 ? void 0 : {
+			...config.subject,
+			versions: void 0
+		}
+	});
+	if (!same(before.events, after.events)) changes.push(safe("table.events", name, `Changes the outbox events ${name} emits, which replaces its events trigger.`));
+	if (!same(before.subject?.versions, after.subject?.versions)) changes.push(safe("table.versions", name, `Changes the versions ${name} keeps, which replaces its snapshot trigger; existing versions stay.`));
+	if (changes.every((change) => change.kind === "table.events" || change.kind === "table.versions") && !same(rest(before), rest(after))) changes.push(safe("table.changed", name, `Changes table ${name}.`));
+	return changes;
+}
+const columnsOf = (table) => table.columns ?? {};
+/**
+* Pairs each name only in `before` with a name only in `after` whose value is
+* the same: a rename, as far as a config can tell.
+*/
+function renames(before, after) {
+	const added = Object.keys(after).filter((name) => !(name in before));
+	const paired = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(before)) {
+		if (name in after) continue;
+		const match = added.find((candidate) => ![...paired.values()].includes(candidate) && same(value, after[candidate]));
+		if (match !== void 0) paired.set(name, match);
+	}
+	return paired;
+}
+function columnChanges(table, before, after) {
+	const old = columnsOf(before);
+	const next = columnsOf(after);
+	const renamed = renames(old, next);
+	const renamedTo = new Set(renamed.values());
+	const changes = [];
+	for (const [name, column] of Object.entries(old)) {
+		const to = renamed.get(name);
+		const now = next[name];
+		if (to !== void 0) changes.push({
+			kind: "column.renamed",
+			table,
+			column: to,
+			from: name,
+			breaking: true,
+			summary: `Renames ${table}.${name} to ${to}.`,
+			steps: [
+				`Add ${to} as a nullable column and copy ${name} into it in a migration.`,
+				`Write both columns and move reads to ${to}, then deploy.`,
+				`Drop ${name} in a later migration${isRequired(column) ? `, then make ${to} required` : ""}.`
+			]
+		});
+		else if (now === void 0) changes.push({
+			kind: "column.dropped",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Drops ${table}.${name} and its values.`,
+			steps: [
+				`Stop reading and writing ${table}.${name} in the app, then deploy.`,
+				`Export the values first if you need them.`,
+				`Remove the column and generate the migration that drops it.`
+			]
+		});
+		else if (now.type !== column.type) changes.push({
+			kind: "column.type",
+			table,
+			column: name,
+			from: column.type,
+			to: now.type,
+			breaking: true,
+			summary: `Changes ${table}.${name} from ${column.type} to ${now.type}.`,
+			steps: [
+				`Add a ${now.type} column next to ${name}.`,
+				`Fill it from ${name} with a cast in a migration, and write both columns.`,
+				`Move reads to the new column, drop ${name} in a later migration and rename the new one if you need the name.`
+			]
+		});
+		else if (!isRequired(column) && isRequired(now) && lacksDefault(now)) changes.push({
+			kind: "column.required",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Makes ${table}.${name} required without a default.`,
+			steps: [
+				`Fill ${table}.${name} in every row where it is null, in a migration.`,
+				`Make the app always write it, or give it a default, then deploy.`,
+				`Make the column required.`
+			]
+		});
+		else changes.push(...constraintChanges(table, name, column, now));
+	}
+	for (const [name, column] of Object.entries(next)) {
+		if (name in old || renamedTo.has(name)) continue;
+		changes.push(isRequired(column) && lacksDefault(column) ? {
+			kind: "column.added",
+			table,
+			column: name,
+			breaking: true,
+			summary: `Adds ${table}.${name} as required without a default, which rows already in the table don't have.`,
+			steps: [
+				`Add ${name} as a nullable column.`,
+				`Fill it in every existing row, and make the app always write it, then deploy.`,
+				`Make the column required.`
+			]
+		} : safe("column.added", table, `Adds ${table}.${name}.`, name));
+	}
+	return changes;
+}
+/**
+* What changes from `before` to `after`: each added, dropped, renamed or
+* changed table and column, with the breaking ones marked and their
+* expand-and-contract steps. A rename is a dropped name and an added one with
+* the same definition.
+*/
+function diffAppTables(before, after, options = {}) {
+	const old = options.keepMissing === true ? Object.fromEntries(Object.entries(before).filter(([name]) => name in after)) : before;
+	const renamed = renames(old, after);
+	const renamedTo = new Set(renamed.values());
+	const changes = [];
+	for (const [name, table] of Object.entries(old)) {
+		const to = renamed.get(name);
+		const now = after[name];
+		if (to !== void 0) changes.push({
+			kind: "table.renamed",
+			table: to,
+			from: name,
+			breaking: true,
+			summary: `Renames table ${name} to ${to}.`,
+			steps: [
+				`Add ${to} next to ${name} and copy the rows in a migration.`,
+				`Write to both tables and move reads to ${to}, then deploy.`,
+				`Stop using ${name}, then drop it in a later migration.`
+			]
+		});
+		else if (now === void 0) changes.push({
+			kind: "table.dropped",
+			table: name,
+			breaking: true,
+			summary: `Drops table ${name} and its rows.`,
+			steps: [
+				`Stop reading and writing ${name} in the app, then deploy.`,
+				`Export the rows first if you need them.`,
+				`Remove the table and generate the migration that drops it.`
+			]
+		});
+		else {
+			const from = table.id ?? "uuid";
+			const toId = now.id ?? "uuid";
+			if (from !== toId) changes.push({
+				kind: "table.id",
+				table: name,
+				from,
+				to: toId,
+				breaking: true,
+				summary: `Changes the id of ${name} from ${from} to ${toId}.`,
+				steps: [
+					`Add a table with the ${toId} id and copy the rows, keeping a map from old ids to new ones.`,
+					`Point the columns that reference ${name} at the new ids, then move the app to the new table.`,
+					`Drop the old table in a later migration.`
+				]
+			});
+			changes.push(...tableChanges(name, table, now), ...columnChanges(name, table, now));
+			const computed = (config) => ({
+				rollups: config.rollups,
+				lookups: config.lookups
+			});
+			if (!same(computed(table), computed(now))) changes.push(safe("table.computed", name, `Changes the rollups and lookups of ${name}, read through ${name}_view.`));
+		}
+	}
+	for (const name of Object.keys(after)) if (!(name in old) && !renamedTo.has(name)) changes.push(safe("table.added", name, `Adds table ${name}.`));
+	return changes;
+}
+/** `diffAppTables` over the app tables of two `/create` designs. */
+function diffDesigns(before, after) {
+	return diffAppTables(before.appTables ?? {}, after.appTables ?? {});
+}
+//#endregion
+export { presetInstallCommand as A, safeParseDesign as C, presetBlocksSource as D, presetApplyCommand as E, presetConfigSource as O, safeDesignFileSource as S, glueCommand as T, encodeDesign as _, DesignParseError as a, parseDesign as b, decodeDesign as c, designConfigSource as d, designFileSource as f, designSchema as g, designOf as h, DESIGN_FORMAT as i, presetGlue as k, designApplyCommand as l, designInstallCommand as m, diffDesigns as n, DesignTooLongError as o, designFormat as p, DESIGN_FILE as r, MAX_DESIGN_CODE_LENGTH as s, diffAppTables as t, designConfig as u, isDesignCode as v, PROVIDER_COMMENT as w, readDesignFile as x, jsonPointer as y };