better-supabase 0.13.0 → 0.15.0

package/dist/preset-HNFqCWaD.js

@@ -1,838 +0,0 @@
-import { c as PRESET_CATALOG, i as presetOf, r as presetConfig, v as encodePreset } from "./config-V6HMvce5.js";
-import { r as FIELD_FORMATS } from "./field-formats-C6QKA3UR.js";
-import { f as appTablesOf } from "./app-tables-0YZ9IskE.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).
-*/
-const DESIGN_FORMAT = 5;
-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) => 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 > 5) throw new DesignParseError("unsupported_format", "/version", `design: the code needs format ${String(version)}, and this better-supabase reads up to ${String(5)}; 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,
-		...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 (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 };