better-supabase 0.14.0 → 0.15.0

package/dist/cli/render-ucJmUyuM.js

@@ -0,0 +1,2170 @@
+import { n as CliError, r as errorText } from "./errors-BTe6A15O.js";
+import { n as importPath } from "./io-DH1kcmmP.js";
+import { i as cachedTypesModule, n as cachedDatabaseTypes, s as typesModuleKey } from "./cache-CXgR_Ahi.js";
+import { t as byCodePoint } from "./compare-BmIWVEui.js";
+import { f as generateDatabaseTypes, h as restrictSchemas, p as oxfmtInstalled, v as tsTypeOf } from "./snapshot-C8MVPyO8.js";
+import { t as isRecord$1 } from "./guards-CUlDNYZs.js";
+import { a as toCatalog } from "./source-DANaJJVc.js";
+import { basename, dirname, isAbsolute, join, posix, relative, resolve } from "node:path";
+import { entityNames } from "better-supabase/blocks";
+import { DEFAULT_CLAIMS, blockEntities, blockEntityRenames, blockSubjectTypes, tenantClaimPaths, tenantNameOf } from "better-supabase/config";
+import { PRESET_CATALOG } from "better-supabase/preset";
+import { BLOCK_OPTION_SCHEMAS, DEFAULT_ROLES, appTableEventTypes, instanceFunctions, modulePermissionKeys, resolveBlock, resolveBlocks, resolveProviderSql } from "better-supabase/sql";
+import { toCamel } from "better-supabase";
+//#region src/cli/gen/model-types.ts
+const applyCasing = (name, casing) => casing === "camel" ? toCamel(name) : name;
+/** The Postgres type name of each app column type, as introspection reports it. */
+const APP_COLUMN_UDT = {
+	text: "text",
+	integer: "int4",
+	bigint: "int8",
+	numeric: "numeric",
+	boolean: "bool",
+	uuid: "uuid",
+	timestamptz: "timestamptz",
+	date: "date",
+	jsonb: "jsonb",
+	"text[]": "_text"
+};
+const CODEC_TYPE = {
+	instant: "Temporal.Instant",
+	plainDateTime: "Temporal.PlainDateTime",
+	bigint: "bigint",
+	string: "string",
+	utcString: "string"
+};
+function codecFor(udt, config) {
+	const { codecs } = config;
+	if (codecs.timestamptz === "utc" && udt === "timestamptz") return "utcString";
+	if (codecs.timestamptz === "instant") {
+		if (udt === "timestamptz") return "instant";
+		if (udt === "timestamp") return "plainDateTime";
+	}
+	if (udt === "int8" && codecs.int8 !== "number") return codecs.int8;
+	if (udt === "numeric" && codecs.numeric === "string") return "string";
+}
+function enumType(values) {
+	return values.map((value) => JSON.stringify(value)).join(" | ");
+}
+//#endregion
+//#region src/cli/gen/shared.ts
+const q = (value) => JSON.stringify(value);
+/**
+* The import path of a runtime subpath: `better-supabase/blocks/trash`, or
+* `../src/blocks/trash/index.ts` when the runtime is imported from source.
+*/
+const runtimeSubpath = (runtime, subpath) => runtime.endsWith("/index.ts") ? `${runtime.slice(0, -8)}${subpath}/index.ts` : `${runtime}/${subpath}`;
+/** A property key: bare when it is a valid identifier, quoted otherwise. */
+function prop(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) ? name : q(name);
+}
+function nullable(type, isNullable) {
+	return isNullable ? `${type} | null` : type;
+}
+/** `T[]`, parenthesized when `T` is a union or other compound type. */
+function arrayOf(type) {
+	return /^[\w.$]+$/.test(type) ? `${type}[]` : `(${type})[]`;
+}
+function indent(lines, depth) {
+	const pad = "  ".repeat(depth);
+	return lines.flatMap((line) => line.split("\n")).map((line) => line === "" ? line : pad + line);
+}
+/** `name: {` + indented children + `};`, or an inline empty type. */
+function block(name, children, empty = "{ [_ in never]: never }") {
+	if (children.length === 0) return [`${name}: ${empty};`];
+	return [
+		`${name}: {`,
+		...indent(children, 1),
+		"};"
+	];
+}
+function sameColumns(left, right) {
+	return left.length === right.length && left.every((column) => right.includes(column));
+}
+function singular(name) {
+	if (name.endsWith("ies")) return `${name.slice(0, -3)}y`;
+	if (name.endsWith("sses")) return name.slice(0, -2);
+	if (name.endsWith("s") && !name.endsWith("ss")) return name.slice(0, -1);
+	return name;
+}
+function pascal$2(name) {
+	return name.replaceAll(/(^|[_-]+)([a-z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/^[a-z]/, (char) => char.toUpperCase());
+}
+/**
+* A valid TypeScript identifier: other characters become `_`, a leading digit
+* gets one.
+*/
+function identifier(name) {
+	const safe = name.replaceAll(/[^\w$]/g, "_");
+	return /^\d/.test(safe) ? `_${safe}` : safe;
+}
+/**
+* The config entry for a database object, keyed `schema.name` or `name`. The
+* qualified key wins.
+*/
+function configFor(entries, schema, name) {
+	return entries[`${schema}.${name}`] ?? entries[name];
+}
+function isJsonUdt(udt) {
+	return udt === "json" || udt === "jsonb";
+}
+const CHECK_ANY = /^CHECK \(\(\(?"?(\w+)"?\)?(?:::\w+)? = ANY \(\(?ARRAY\[(.+)\]\)?(?:::\w+\[\])?\)\)\)$/;
+const CHECK_OR = /^CHECK \(\((.+)\)\)$/;
+const OR_TERM = /^\(?"?(\w+)"?\)?(?:::\w+)? = '((?:[^']|'')*)'(?:::\w+)?\)?$/;
+const LITERAL = /'((?:[^']|'')*)'(?:::[\w ]+)?/g;
+/**
+* Extracts `column in ('a', 'b')` CHECK constraints, which Postgres stores as
+* `CHECK ((col = ANY (ARRAY['a'::text, 'b'::text])))` or an OR chain.
+*/
+function parseCheckUnion(definition) {
+	const any = CHECK_ANY.exec(definition);
+	if (any?.[1] && any[2]) {
+		const values = [...any[2].matchAll(LITERAL)].map((match) => (match[1] ?? "").replaceAll("''", "'"));
+		return values.length > 0 ? {
+			column: any[1],
+			values
+		} : void 0;
+	}
+	const chain = CHECK_OR.exec(definition);
+	if (chain?.[1]) {
+		const terms = chain[1].split(/\) OR \(|\s+OR\s+/);
+		let column;
+		const values = [];
+		for (const term of terms) {
+			const match = OR_TERM.exec(term.trim());
+			if (!match?.[1]) return;
+			if (column && column !== match[1]) return;
+			column = match[1];
+			values.push((match[2] ?? "").replaceAll("''", "'"));
+		}
+		return column && values.length > 1 ? {
+			column,
+			values
+		} : void 0;
+	}
+}
+/** The text inside one pair of parentheses that wraps all of `text`, if any. */
+function unwrap(text) {
+	let current = text.trim();
+	while (current.startsWith("(") && current.endsWith(")")) {
+		let depth = 0;
+		let wraps = true;
+		for (let index = 0; index < current.length; index += 1) {
+			const char = current[index];
+			if (char === "(") depth += 1;
+			else if (char === ")") depth -= 1;
+			if (depth === 0 && index < current.length - 1) {
+				wraps = false;
+				break;
+			}
+		}
+		if (!wraps) break;
+		current = current.slice(1, -1).trim();
+	}
+	return current;
+}
+/** Splits `text` on a keyword outside parentheses and quotes. */
+function splitTopLevel(text, keyword) {
+	const parts = [];
+	let depth = 0;
+	let quote;
+	let start = 0;
+	const separator = ` ${keyword} `;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "'" || char === "\"") quote = char;
+		else if (char === "(") depth += 1;
+		else if (char === ")") depth -= 1;
+		else if (depth === 0 && text.slice(index, index + separator.length).toUpperCase() === separator) {
+			parts.push(text.slice(start, index));
+			start = index + separator.length;
+			index += separator.length - 1;
+		}
+	}
+	parts.push(text.slice(start));
+	return parts.map((part) => part.trim());
+}
+const IS_NOT_NULL = /^(?:"((?:[^"]|"")+)"|([\w$]+)) IS NOT NULL$/i;
+/**
+* Columns a CHECK constraint makes not null: `CHECK ((slug IS NOT NULL))` and
+* the `IS NOT NULL` terms of a top-level `AND`. A term under `OR`, `NOT` or any
+* other expression narrows nothing, and neither does a `NOT VALID` one.
+*/
+function parseCheckNotNull(definition) {
+	const text = definition.trim();
+	if (/\bNOT VALID$/i.test(text)) return [];
+	const body = /^CHECK\s*(.*)$/is.exec(text)?.[1];
+	if (!body) return [];
+	const expression = unwrap(body);
+	if (splitTopLevel(expression, "OR").length > 1) return [];
+	return splitTopLevel(expression, "AND").flatMap((term) => {
+		const match = IS_NOT_NULL.exec(unwrap(term));
+		if (!match) return [];
+		return [match[1]?.replaceAll("\"\"", "\"") ?? match[2] ?? ""];
+	});
+}
+//#endregion
+//#region src/cli/gen/block-names.ts
+const PLACEHOLDER = /\{(\.\.\.)?([A-Za-z_][\w]*)\}/g;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function camel$1(name) {
+	return name.replaceAll(/[-_]([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascal$1(name) {
+	const camelled = camel$1(name);
+	return camelled.charAt(0).toUpperCase() + camelled.slice(1);
+}
+function union(values) {
+	return [...new Set(values)].toSorted().map((value) => q(value)).join(" | ");
+}
+/**
+* A template with `{placeholders}` as an arrow function over their values: `(v:
+* { readonly userId: string }) => \`notifications:${v.userId}\``. `rename` maps
+* a placeholder to the property the caller passes.
+*/
+function templateFunction(template, rename = (name) => name, value = "string") {
+	const names = [];
+	let body = "";
+	let last = 0;
+	for (const match of template.matchAll(PLACEHOLDER)) {
+		const name = rename(match[2] ?? "");
+		if (!names.includes(name)) names.push(name);
+		body += `${literalPart(template.slice(last, match.index))}\${String(v.${name})}`;
+		last = match.index + match[0].length;
+	}
+	body += literalPart(template.slice(last));
+	if (names.length === 0) return `() => ${q(template)}`;
+	return `(v: { ${names.map((name) => `readonly ${name}: ${value}`).join("; ")} }) => \`${body}\``;
+}
+function literalPart(text) {
+	return text.replaceAll(/[`\\]|\$\{/g, (match) => `\\${match}`);
+}
+/** Permission keys by owner (block, subject or app table), then action. */
+function permissionGroups(config) {
+	const groups = {};
+	for (const entry of modulePermissionKeys(config.blocks, config.blockNames)) groups[entry.module] = {
+		...groups[entry.module],
+		[entry.action]: entry.key
+	};
+	for (const [name, subject] of Object.entries(config.subjects)) if (subject.permissions) groups[name] = {
+		...groups[name],
+		...subject.permissions
+	};
+	for (const table of Object.values(config.appTables)) {
+		const subject = table.subject;
+		if (subject?.permissions) groups[subject.type] = {
+			...groups[subject.type],
+			...subject.permissions
+		};
+	}
+	return groups;
+}
+/** Whether `blocks.generated.ts` exports `permissions`. */
+function hasPermissionConstants(config) {
+	return Object.values(permissionGroups(config)).some((group) => Object.keys(group).length > 0);
+}
+function permissionLines(config) {
+	const groups = permissionGroups(config);
+	const keys = Object.values(groups).flatMap((group) => Object.values(group));
+	if (keys.length === 0) return [];
+	return [
+		"",
+		"/**",
+		" * The permission keys the installed blocks, subjects and app tables check,",
+		" * by owner and action.",
+		" * @public",
+		" */",
+		"export const permissions = {",
+		...Object.entries(groups).toSorted(([a], [b]) => a.localeCompare(b)).flatMap(([owner, actions]) => [
+			`  ${prop(owner)}: {`,
+			...Object.entries(actions).map(([action, key]) => `    ${prop(action)}: ${q(key)},`),
+			"  },"
+		]),
+		"} as const;",
+		"",
+		"/**",
+		" * Every permission key, for `defineAuthorizer<PermissionKey>()` and",
+		" * the `permission` of actions and routes.",
+		" * @public",
+		" */",
+		`export type PermissionKey = ${union(keys)};`
+	];
+}
+function roleLines(config, entries) {
+	if (entries["permissions"] === void 0) return [];
+	const access = config.blocks.permissions;
+	const settings = typeof access === "object" ? access : void 0;
+	if ((settings?.model ?? "roles") !== "roles") return [];
+	const roles = settings?.roles ?? DEFAULT_ROLES;
+	return [
+		"",
+		"/** The roles `blocks.permissions.roles` defines. @public */",
+		`export type RoleName = ${union(Object.keys(roles))};`
+	];
+}
+function blockEventLists(entries) {
+	return PRESET_CATALOG.manifests.flatMap((manifest) => {
+		const events = manifest.events;
+		const client = manifest.client;
+		if (events === void 0 || !client) return [];
+		const lists = Object.entries(entries).filter(([key, entry]) => (entry.block ?? key) === manifest.name).map(([key, entry]) => {
+			const renames = entry.names?.entities ?? [];
+			const names = entityNames(renames);
+			const type = renames.length === 0 ? events.type : key === manifest.name ? names.rename(events.type) : `${pascalOf(key)}Events`;
+			return {
+				specifier: renames.length === 0 ? `import type { ${events.type} } from ${q(client.subpath)};` : "",
+				type,
+				types: events.types.map((each) => names.rename(each))
+			};
+		});
+		return lists.filter((list, index) => lists.findIndex((other) => other.type === list.type) === index);
+	});
+}
+function pascalOf(instance) {
+	const camel = instance.replaceAll(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function eventLines(entries) {
+	const lists = blockEventLists(entries);
+	if (lists.length === 0) return {
+		specifiers: [],
+		imports: [],
+		lines: []
+	};
+	const types = [...new Set(lists.flatMap((list) => list.types))].toSorted();
+	return {
+		specifiers: ["type Events"],
+		imports: lists.flatMap((list) => list.specifier === "" ? [] : [list.specifier]),
+		lines: [
+			"",
+			"/** Every installed block's events: type to data. @public */",
+			`export type BlockEvents = ${lists.map((list) => list.type).join(" & ")};`,
+			"",
+			"/**",
+			" * The installed blocks' event types under the configured names, for",
+			" * `onBlockEvent` and the sinks.",
+			" * @public",
+			" */",
+			"export const blockEvents: Events<BlockEvents> = {",
+			"  types: [",
+			...types.map((type) => `    ${q(type)},`),
+			"  ],",
+			"};",
+			"",
+			"/**",
+			" * The block events with an open payload, for AsyncAPI's `cloudEvents.blocks`.",
+			" * @public",
+			" */",
+			"export const blockEventSchemas = {",
+			...types.map((type) => `  ${q(type)}: true,`),
+			"} as const;"
+		]
+	};
+}
+function urlLines(config, entries) {
+	const templates = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(entries)) for (const entity of blockEntities(name, config.blocks)) if (entity.url !== void 0) templates.set(camel$1(entity.to.singular), entity.url);
+	for (const [type, subject] of Object.entries(config.subjects)) {
+		const key = camel$1(type);
+		if (subject.url !== void 0 && !templates.has(key)) templates.set(key, subject.url);
+	}
+	const urls = [...templates].map(([key, template]) => `  ${prop(key)}: ${templateFunction(template, (column) => applyCasing(column, config.casing), "string | number")},`);
+	return urls.length === 0 ? [] : [
+		"",
+		"/**",
+		" * The path of each subject type with a `url`: block entities, `records`",
+		" * and `tables` subjects.",
+		" * @public",
+		" */",
+		"export const urls = {",
+		...urls,
+		"} as const;"
+	];
+}
+function topicLines(entries) {
+	const topics = Object.entries(entries).flatMap(([name, entry]) => Object.entries(entry.options).flatMap(([option, value]) => {
+		if (!/^(?:topic|[a-z]+Topic)$/.test(option) || typeof value !== "string") return [];
+		return [`  ${prop(option === "topic" ? camel$1(name) : `${camel$1(name)}${pascal$1(option.replace(/Topic$/, ""))}`)}: ${templateFunction(value)},`];
+	}));
+	return topics.length === 0 ? [] : [
+		"",
+		"/** The realtime topics the blocks broadcast on, with their placeholders filled. @public */",
+		"export const topics = {",
+		...topics,
+		"} as const;"
+	];
+}
+function pathLines(config) {
+	const paths = Object.entries(config.buckets).map(([name, bucket]) => {
+		const key = prop(camel$1(name));
+		return typeof bucket.path === "string" ? `  ${key}: ${templateFunction(bucket.path)},` : `  ${key}: [${bucket.path.map((path) => templateFunction(path)).join(", ")}],`;
+	});
+	return paths.length === 0 ? [] : [
+		"",
+		"/** Object paths in each bucket, from `buckets.<name>.path`. @public */",
+		"export const paths = {",
+		...paths,
+		"} as const;"
+	];
+}
+function optionOf(config, module, option) {
+	return config.blockNames.includes(module) || config.blocks[module] !== void 0 ? resolveBlock(config.blocks[module]).options[option] : void 0;
+}
+function settingKeys(config) {
+	const option = optionOf(config, "settings", "schemas");
+	const schemas = isRecord(option) && isRecord(option["schemas"]) ? option["schemas"] : option;
+	if (!isRecord(schemas)) return [];
+	return [
+		"user",
+		"organization",
+		"platform"
+	].flatMap((scope) => {
+		const keys = schemas[scope];
+		return isRecord(keys) ? Object.keys(keys) : [];
+	});
+}
+function meterNames(config) {
+	const option = optionOf(config, "usage", "meters");
+	return isRecord(option) && typeof option["table"] !== "string" ? Object.keys(option) : [];
+}
+function keyUnionLines(config) {
+	return [[
+		"SettingKey",
+		"`blocks.settings.options.schemas`",
+		settingKeys(config)
+	], [
+		"MeterName",
+		"`blocks.usage.options.meters`",
+		meterNames(config)
+	]].flatMap(([name, source, keys]) => keys.length === 0 ? [] : [
+		"",
+		`/** The keys ${source} names. @public */`,
+		`export type ${name} = ${union(keys)};`
+	]);
+}
+/**
+* The constants app code references by name, from the config: permission keys,
+* role names, block events, entity URLs, realtime topics, bucket paths, and the
+* settings and meter keys.
+*/
+function nameConstantLines(config, entries) {
+	const events = eventLines(entries);
+	return {
+		specifiers: events.specifiers,
+		imports: events.imports,
+		lines: [
+			...permissionLines(config),
+			...roleLines(config, entries),
+			...events.lines,
+			...urlLines(config, entries),
+			...topicLines(entries),
+			...pathLines(config),
+			...keyUnionLines(config)
+		]
+	};
+}
+//#endregion
+//#region src/cli/gen/comment.ts
+/**
+* The metadata a `COMMENT ON` adds to a table or column: its description,
+* without the `@example` lines the validator generators read, and `deprecated`
+* when a line starts with `@deprecated`. The library's `parseComment`
+* (`src/generators/shared.ts`) reads comments the same way.
+*/
+function commentMeta(comment) {
+	if (!comment) return {};
+	const deprecated = /^\s*@deprecated\b/m.test(comment);
+	const description = comment.replaceAll(/^\s*@example\s+(.+?)\s*$/gm, "").replaceAll(/^\s*@deprecated\b.*$/gm, "").trim();
+	return {
+		...description ? { description } : {},
+		...deprecated ? { deprecated: true } : {}
+	};
+}
+//#endregion
+//#region src/cli/gen/model-functions.ts
+const NOT_NULL_TAG = /@notNull(?:\(([^)]*)\))?/u;
+/**
+* The `@notNull` tag in a function's comment: `true` for every result, or the
+* columns `@notNull(a, b)` names. `undefined` without a tag.
+*/
+function notNullTag(comment) {
+	const match = comment === void 0 ? null : NOT_NULL_TAG.exec(comment);
+	if (!match) return;
+	const list = match[1];
+	return list === void 0 ? true : list.split(",").map((name) => name.trim()).filter((name) => name !== "");
+}
+/** The callable functions; warns about functions another schema shadows. */
+function buildFunctions(ctx, tableModels) {
+	const { config, catalog, enumsByName, tsType, warnings } = ctx;
+	const tablesByName = new Map(tableModels.map((table) => [`${table.snapshot.schema}.${table.snapshot.name}`, table]));
+	const callable = catalog.functions.filter((fn) => config.schemas.includes(fn.schema)).filter((fn) => fn.returns !== "trigger" && fn.returns !== "event_trigger").filter((fn) => !fn.args.some((arg) => arg.udt === "internal"));
+	const ownerSchema = /* @__PURE__ */ new Map();
+	for (const schema of config.schemas) for (const fn of callable) if (fn.schema === schema && !ownerSchema.has(fn.name)) ownerSchema.set(fn.name, schema);
+	const shadowed = /* @__PURE__ */ new Set();
+	const unpromised = [];
+	const functions = callable.filter((fn) => {
+		if (ownerSchema.get(fn.name) === fn.schema) return true;
+		shadowed.add(`${fn.schema}.${fn.name}`);
+		return false;
+	}).map((fn) => {
+		const typeOf = (format, typeSchema) => {
+			const isArray = format.startsWith("_");
+			const values = enumsByName.get(`${typeSchema ?? fn.schema}.${isArray ? format.slice(1) : format}`);
+			if (values) return isArray ? arrayOf(enumType(values)) : enumType(values);
+			return tsType(fn.schema, format, typeSchema);
+		};
+		const configured = configFor(config.functions, fn.schema, fn.name)?.notNull;
+		const notNull = configured ?? notNullTag(fn.comment);
+		const source = configured === void 0 ? `the @notNull tag on ${fn.schema}.${fn.name}` : `functions.${fn.name}.notNull`;
+		const notNullColumns = new Set(Array.isArray(notNull) ? notNull : []);
+		if (Array.isArray(notNull)) {
+			for (const name of notNullColumns) if (!fn.returnsTable?.some((column) => column.name === name)) throw new TypeError(`${source}: "${name}" is not a column the function returns`);
+		}
+		const orNull = (type, column) => notNull === true || column !== void 0 && notNullColumns.has(column) || type === "undefined" || type === "Json" || type === "unknown" ? type : `${type} | null`;
+		let returns;
+		let result;
+		const rowTable = fn.returnsRelation ? tablesByName.get(fn.returnsRelation) : void 0;
+		if (fn.returnsTable) {
+			const columns = fn.returnsTable.map((column) => {
+				const codec = codecFor(column.udt, config);
+				const tsType = codec ? CODEC_TYPE[codec] : typeOf(column.udt, column.typeSchema);
+				return {
+					db: column.name,
+					app: applyCasing(column.name, config.casing),
+					codec,
+					tsType: column.notNull ? tsType : orNull(tsType, column.name)
+				};
+			});
+			if (notNull === void 0 && columns.some((column) => column.tsType.endsWith(" | null"))) unpromised.push(`${fn.schema}.${fn.name}`);
+			returns = `{ ${columns.map((column) => `${JSON.stringify(column.app)}: ${column.tsType}`).join("; ")} }[]`;
+			if (columns.some((column) => column.codec !== void 0 || column.app !== column.db)) result = { columns: columns.map(({ db, app, codec }) => ({
+				db,
+				...app === db ? {} : { name: app },
+				...codec ? { codec } : {}
+			})) };
+		} else if (rowTable) {
+			returns = `Models[${JSON.stringify(rowTable.key)}]['Row']`;
+			returns = fn.returnsSet ? arrayOf(returns) : orNull(returns);
+			if (rowTable.columns.some((column) => column.codec !== void 0 || column.app !== column.db)) result = { table: rowTable.key };
+		} else {
+			returns = orNull(typeOf(fn.returns, fn.returnsSchema));
+			if (fn.returnsSet) returns = arrayOf(returns);
+		}
+		return {
+			key: fn.name,
+			meta: {
+				name: fn.name,
+				schema: fn.schema,
+				args: fn.args.map((arg) => ({
+					name: arg.name,
+					type: arg.udt
+				})),
+				returns: fn.returns,
+				returnsSet: fn.returnsSet,
+				volatility: fn.volatility,
+				...result ? { result } : {}
+			},
+			args: fn.args.map((arg) => ({
+				name: arg.name,
+				tsType: typeOf(arg.isArray ? `_${arg.udt}` : arg.udt, arg.typeSchema),
+				optional: arg.hasDefault,
+				values: enumsByName.get(`${arg.typeSchema ?? fn.schema}.${arg.udt}`)
+			})),
+			returns
+		};
+	});
+	for (const name of Object.keys(config.functions)) if (!functions.some((fn) => fn.key === name || `${fn.meta.schema}.${fn.key}` === name)) throw new TypeError(`functions.${name}: no function "${name}" in ${config.schemas.join(", ")}`);
+	if (unpromised.length > 0) {
+		const names = [...new Set(unpromised)];
+		ctx.notices.push(`Notice: Postgres can't declare a \`returns table\` column not null, so ${names.length === 1 ? "this function's columns are" : `the columns of these ${names.length} functions are`} typed \`| null\`: ${names.join(", ")}. Name the columns that are never null with an \`@notNull(a, b)\` tag in the function's comment or with \`gen.functions.<name>.notNull\`; \`notNull: []\` keeps them all nullable and silences this notice.`);
+	}
+	for (const id of shadowed) {
+		const name = id.slice(id.indexOf(".") + 1);
+		warnings.push(`${id}: ${ownerSchema.get(name) ?? ""}.${name} has the same name and comes first in \`schemas\`, so ${id} gets no \`$rpc\` types.`);
+	}
+	return functions;
+}
+//#endregion
+//#region src/cli/gen/model-relations.ts
+function buildRelations(ctx, tables) {
+	const { config, keyOf } = ctx;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of tables) byKey.set(`${entry.table.schema}.${entry.table.name}`, entry);
+	const appName = (schema, table, column) => {
+		return byKey.get(`${schema}.${table}`)?.byDb.get(column)?.app ?? column;
+	};
+	const relations = /* @__PURE__ */ new Map();
+	const push = (tableId, relation) => {
+		const list = relations.get(tableId);
+		if (list) list.push(relation);
+		else relations.set(tableId, [relation]);
+	};
+	for (const { table, casing, byDb: own } of tables) {
+		const sourceId = `${table.schema}.${table.name}`;
+		for (const fk of table.foreignKeys) {
+			const targetId = `${fk.refSchema}.${fk.refTable}`;
+			const target = byKey.get(targetId);
+			if (!target) continue;
+			const targetKey = keyOf.get(targetId) ?? fk.refTable;
+			const sourceColumns = fk.columns.map((column) => appName(table.schema, table.name, column));
+			const targetColumns = fk.refColumns.map((column) => appName(fk.refSchema, fk.refTable, column));
+			const nullable = config.relations.nullableUnderRls && target.table.rls || fk.columns.some((column) => own.get(column)?.nullable ?? true);
+			const onDelete = fk.onDelete === "cascade" || fk.onDelete === "set null" || fk.onDelete === "set default" ? { onDelete: fk.onDelete } : {};
+			const naming = namingColumns(fk.columns, fk.refColumns);
+			const [only] = naming;
+			const forwardBase = naming.length === 1 && only?.endsWith("_id") ? only.slice(0, -3) : singular(fk.refTable);
+			push(sourceId, {
+				name: applyCasing(forwardBase, casing),
+				base: forwardBase,
+				fkColumns: fk.columns,
+				refColumns: fk.refColumns,
+				meta: {
+					table: targetKey,
+					kind: "one",
+					nullable,
+					foreignKey: fk.name,
+					columns: sourceColumns,
+					references: targetColumns,
+					direction: "forward",
+					...onDelete
+				}
+			});
+			const unique = fk.oneToOne || sameColumns(table.primaryKey, fk.columns) || table.uniques.some((key) => sameColumns(key.columns, fk.columns));
+			const reverseBase = unique ? singular(table.name) : table.name;
+			push(targetId, {
+				name: applyCasing(reverseBase, target.casing),
+				base: reverseBase,
+				fkColumns: fk.columns,
+				refColumns: fk.refColumns,
+				meta: {
+					table: keyOf.get(sourceId) ?? table.name,
+					kind: unique ? "one" : "many",
+					nullable: true,
+					foreignKey: fk.name,
+					columns: targetColumns,
+					references: sourceColumns,
+					direction: "reverse",
+					...onDelete
+				}
+			});
+		}
+	}
+	return relations;
+}
+/**
+* The columns that name a relation. A composite key that repeats a column on
+* both sides, such as `(customer_id, organization_id)` referencing `(id,
+* organization_id)` to keep rows in one tenant, is named by the rest.
+*/
+function namingColumns(columns, references) {
+	const own = columns.filter((column, index) => column !== references[index]);
+	return own.length > 0 ? own : columns;
+}
+//#endregion
+//#region src/cli/gen/model.ts
+const SOFT_DELETE_UDTS = /* @__PURE__ */ new Set(["timestamptz", "timestamp"]);
+/** The overloads of each function name, in model order. */
+function functionGroups(functions) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const fn of functions) {
+		const group = groups.get(fn.key);
+		if (group) group.push(fn);
+		else groups.set(fn.key, [fn]);
+	}
+	return groups;
+}
+function signatureOf(fn) {
+	const { name: _name, schema: _schema, ...signature } = fn.meta;
+	return {
+		...signature,
+		args: signature.args.map((arg, index) => fn.args[index]?.optional ? {
+			...arg,
+			optional: true
+		} : arg)
+	};
+}
+function tableKey(table, casing, schemas) {
+	const base = applyCasing(table.name, casing);
+	if (schemas.length === 1 || table.schema === "public") return base;
+	return applyCasing(`${table.schema}_${table.name}`, casing);
+}
+const TEXT_UDTS = /* @__PURE__ */ new Set([
+	"text",
+	"varchar",
+	"bpchar"
+]);
+/**
+* `config.storagePaths` resolved to bucket ids, with a check that every key is
+* used.
+*/
+function numberedColumnsOf(config) {
+	const columns = /* @__PURE__ */ new Map();
+	const block = config.blocks["numbering"];
+	if (!config.blockNames.includes("numbering") || block?.mode === "custom" || !isRecord$1(block?.options?.["entities"])) return columns;
+	for (const entry of Object.values(block.options["entities"])) {
+		if (!isRecord$1(entry) || typeof entry["table"] !== "string" || typeof entry["column"] !== "string") continue;
+		const key = entry["table"].includes(".") ? entry["table"] : `public.${entry["table"]}`;
+		const set = columns.get(key) ?? /* @__PURE__ */ new Set();
+		set.add(entry["column"]);
+		if (typeof entry["sequenceColumn"] === "string") set.add(entry["sequenceColumn"]);
+		columns.set(key, set);
+	}
+	return columns;
+}
+function storagePathsOf(config) {
+	const bucketId = (name) => {
+		const bucket = config.buckets[name];
+		if (!bucket) return name;
+		return bucket.id ?? name.replaceAll(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+	};
+	const unused = new Set(Object.keys(config.storagePaths));
+	return {
+		lookup(schema, table, column, udt) {
+			const key = [`${schema}.${table}.${column}`, `${table}.${column}`].find((candidate) => candidate in config.storagePaths);
+			if (key === void 0) return;
+			unused.delete(key);
+			if (!TEXT_UDTS.has(udt)) throw new TypeError(`storagePaths["${key}"]: ${schema}.${table}.${column} is ${udt}, not a text column`);
+			return bucketId(config.storagePaths[key]);
+		},
+		assertUsed() {
+			const [first] = unused;
+			if (first !== void 0) throw new TypeError(`storagePaths["${first}"]: no such column. Use \`table.column\` or \`schema.table.column\` (database names) in \`schemas\`.`);
+		}
+	};
+}
+function prepareCatalog(snapshot, config) {
+	const catalog = toCatalog(snapshot);
+	const introspection = restrictSchemas(snapshot.generator, config.schemas);
+	const tsType = (schema, format, typeSchema) => tsTypeOf(introspection, schema, format, typeSchema).replaceAll(/\(([\w.$]+)\)\[\]/g, "$1[]");
+	const enumsByName = /* @__PURE__ */ new Map();
+	for (const entry of catalog.enums) enumsByName.set(`${entry.schema}.${entry.name}`, entry.values);
+	const jsonImports = /* @__PURE__ */ new Map();
+	const unusedJson = new Set(Object.keys(config.json));
+	const jsonTypeFor = (schema, table, column) => {
+		const key = [`${schema}.${table}.${column}`, `${table}.${column}`].find((candidate) => candidate in config.json);
+		const override = key === void 0 ? void 0 : config.json[key];
+		if (key === void 0 || !override) return;
+		unusedJson.delete(key);
+		if ("type" in override) return override.type;
+		const [from, name] = override.import.split("#");
+		if (!from || !name) throw new TypeError(`json["${key}"].import must look like "./path.ts#TypeName"`);
+		jsonImports.set(name, {
+			name,
+			from
+		});
+		return name;
+	};
+	const optionsOf = (table) => configFor(config.tables, table.schema, table.name);
+	const included = catalog.tables.filter((table) => config.schemas.includes(table.schema) && !optionsOf(table)?.exclude);
+	const keyOf = /* @__PURE__ */ new Map();
+	const ownerOf = /* @__PURE__ */ new Map();
+	for (const table of included) {
+		const id = `${table.schema}.${table.name}`;
+		const key = tableKey(table, config.casing, config.schemas);
+		const other = ownerOf.get(key);
+		if (other !== void 0) throw new TypeError(`${other} and ${id} both generate the model key "${key}". Exclude one with \`tables["${id}"].exclude\`, or rename one of the tables.`);
+		ownerOf.set(key, id);
+		keyOf.set(id, key);
+	}
+	return {
+		config,
+		catalog,
+		introspection,
+		enumsByName,
+		jsonImports,
+		unusedJson,
+		included,
+		keyOf,
+		warnings: [],
+		notices: [],
+		tsType,
+		jsonTypeFor,
+		optionsOf
+	};
+}
+function draftTables(ctx) {
+	const { config, included, enumsByName, tsType, jsonTypeFor, optionsOf } = ctx;
+	const storagePaths = storagePathsOf(config);
+	const numbered = numberedColumnsOf(config);
+	const tables = included.map((table) => {
+		const casing = optionsOf(table)?.casing ?? config.casing;
+		const checks = /* @__PURE__ */ new Map();
+		const checkedNotNull = /* @__PURE__ */ new Set();
+		for (const check of table.checks) {
+			const union = parseCheckUnion(check.definition);
+			if (union) checks.set(union.column, union.values);
+			for (const column of parseCheckNotNull(check.definition)) checkedNotNull.add(column);
+		}
+		const beforeInsert = table.triggers.some((trigger) => trigger.timing === "before" && trigger.level === "row" && trigger.events.includes("insert"));
+		const insertOptional = new Set(optionsOf(table)?.insertOptional);
+		const numberedColumns = numbered.get(`${table.schema}.${table.name}`);
+		for (const name of insertOptional) if (!table.columns.some((column) => column.name === name)) throw new TypeError(`tables.${table.name}.insertOptional: "${name}" is not a column of ${table.schema}.${table.name}`);
+		const columns = table.columns.map((column) => {
+			const values = (column.isEnum ? enumsByName.get(`${column.typeSchema}.${column.udt}`) : void 0) ?? checks.get(column.name);
+			const appColumn = table.schema === "public" ? config.appTables[table.name]?.columns?.[column.name] : void 0;
+			const sealed = appColumn?.encrypted === true ? APP_COLUMN_UDT[appColumn.type] : void 0;
+			const udt = sealed ?? column.udt;
+			const format = sealed ?? column.format;
+			const json = isJsonUdt(udt);
+			const override = json ? jsonTypeFor(table.schema, table.name, column.name) : void 0;
+			const storage = storagePaths.lookup(table.schema, table.name, column.name, udt);
+			const codec = override || values || storage ? void 0 : codecFor(udt, config);
+			const base = override ?? (values ? enumType(values) : storage ? `StoragePath<${JSON.stringify(storage)}>` : codec ? CODEC_TYPE[codec] : void 0);
+			const columnType = base === void 0 ? tsType(table.schema, format, sealed === void 0 ? column.typeSchema : "pg_catalog") : column.isArray ? arrayOf(base) : base;
+			const readonly = column.generated || column.identity === "always";
+			const narrowed = column.nullable && checkedNotNull.has(column.name);
+			const nullable = column.nullable && !narrowed;
+			const filled = column.hasDefault || insertOptional.has(column.name) || (numberedColumns?.has(column.name) ?? false) || narrowed && beforeInsert;
+			const insertable = !readonly && table.insertable && (table.kind !== "view" || column.updatable);
+			const updatable = !readonly && table.updatable && column.updatable;
+			return {
+				...appColumn?.access === "server" || appColumn?.encrypted === true ? { selectable: false } : {},
+				app: applyCasing(column.name, casing),
+				db: column.name,
+				snapshot: column,
+				tsType: columnType,
+				nullable,
+				filled,
+				optional: nullable || filled || readonly,
+				readonly,
+				values,
+				json,
+				codec,
+				storage,
+				insertable,
+				updatable
+			};
+		});
+		const byApp = /* @__PURE__ */ new Map();
+		for (const column of columns) {
+			const other = byApp.get(column.app);
+			if (other !== void 0) throw new TypeError(`${table.schema}.${table.name}: columns "${other}" and "${column.db}" both become "${column.app}". Rename one, or set \`tables["${table.schema}.${table.name}"].casing: "snake"\`.`);
+			byApp.set(column.app, column.db);
+		}
+		return {
+			table,
+			casing,
+			columns,
+			byDb: new Map(columns.map((column) => [column.db, column]))
+		};
+	});
+	storagePaths.assertUsed();
+	return tables;
+}
+/** Config entries that match no table or column. */
+function configWarnings(ctx) {
+	const { config, catalog, unusedJson } = ctx;
+	const schemasOf = /* @__PURE__ */ new Map();
+	for (const table of catalog.tables) {
+		if (!config.schemas.includes(table.schema)) continue;
+		schemasOf.set(table.name, [...schemasOf.get(table.name) ?? [], table.schema]);
+	}
+	const known = (key) => {
+		const dot = key.indexOf(".");
+		if (dot === -1) return schemasOf.has(key);
+		return schemasOf.get(key.slice(dot + 1))?.includes(key.slice(0, dot)) ?? false;
+	};
+	return [
+		...Object.keys(config.tables).filter((name) => !known(name)).map((name) => `tables["${name}"]: no table by that name in ${config.schemas.join(", ")}, so the entry does nothing.`),
+		...Object.keys(config.tables).flatMap((name) => {
+			const shared = (schemasOf.get(name) ?? []).filter((schema) => !(`${schema}.${name}` in config.tables)).map((schema) => `${schema}.${name}`);
+			return shared.length > 1 ? [`tables["${name}"]: ${shared.join(" and ")} share the name, so the entry applies to each. Key it \`schema.table\` to pick one.`] : [];
+		}),
+		...[...unusedJson].map((key) => `json["${key}"]: no json or jsonb column by that name, so the type is not used. Keys are \`table.column\` or \`schema.table.column\` with database names.`)
+	];
+}
+function toTableModels(ctx, tables, relations) {
+	const { config, keyOf, optionsOf } = ctx;
+	const flagsConfig = config.extensions;
+	const subjectDeletedAt = /* @__PURE__ */ new Map();
+	const subjectTenant = /* @__PURE__ */ new Map();
+	for (const [type, subject] of Object.entries(config.subjects)) {
+		const table = subject.table.includes(".") ? subject.table : `public.${subject.table}`;
+		if (typeof subject.tenant === "string") subjectTenant.set(table, subject.tenant);
+		if (subject.deletedAt !== void 0) subjectDeletedAt.set(table, {
+			db: subject.deletedAt,
+			source: `subjects.${type}.deletedAt`
+		});
+	}
+	return tables.map(({ table, casing, columns, byDb }) => {
+		const id = `${table.schema}.${table.name}`;
+		const renames = optionsOf(table)?.relations ?? {};
+		const columnNames = new Set(columns.map((column) => column.app));
+		const list = dedupeRelations(relations.get(id) ?? [], columnNames, casing).map((relation) => ({
+			...relation,
+			name: renames[relation.name] ?? relation.name
+		}));
+		const has = (db) => byDb.get(db)?.app;
+		const flags = {};
+		const subjectColumn = subjectDeletedAt.get(id);
+		const softDelete = subjectColumn !== void 0 && byDb.has(subjectColumn.db) ? subjectColumn : flagsConfig.softDelete ? {
+			db: flagsConfig.softDelete.column,
+			source: "blocks.trash.options.deletedAt"
+		} : void 0;
+		const softDeleteColumn = softDelete && byDb.get(softDelete.db);
+		if (softDelete && softDeleteColumn) {
+			const udt = softDeleteColumn.snapshot.udt;
+			if (softDeleteColumn.snapshot.isArray || !SOFT_DELETE_UDTS.has(udt)) throw new TypeError(`${softDelete.source}: ${id}.${softDelete.db} is ${udt}, but the trash extension writes a timestamp. Use timestamptz or timestamp.`);
+			flags.softDelete = softDeleteColumn.app;
+		}
+		if (flagsConfig.timestamps) {
+			const createdAt = has(flagsConfig.timestamps.createdAt);
+			const updatedAt = has(flagsConfig.timestamps.updatedAt);
+			if (createdAt || updatedAt) flags.timestamps = {
+				...createdAt ? { createdAt } : {},
+				...updatedAt ? { updatedAt } : {}
+			};
+		}
+		if (flagsConfig.tenant) {
+			const mapped = subjectTenant.get(id);
+			const column = (mapped === void 0 ? void 0 : has(mapped)) ?? has(flagsConfig.tenant.column);
+			if (column) flags.tenant = column;
+		}
+		if (flagsConfig.actor) {
+			const createdBy = has(flagsConfig.actor.createdBy);
+			const updatedBy = has(flagsConfig.actor.updatedBy);
+			const impersonatedBy = has(flagsConfig.actor.impersonatedBy);
+			if (createdBy || updatedBy || impersonatedBy) flags.actor = {
+				...createdBy ? { createdBy } : {},
+				...updatedBy ? { updatedBy } : {},
+				...impersonatedBy ? { impersonatedBy } : {}
+			};
+		}
+		const key = keyOf.get(id) ?? table.name;
+		const columnMeta = {};
+		for (const column of columns) {
+			const meta = {
+				db: column.db,
+				type: column.snapshot.udt,
+				nullable: column.nullable,
+				hasDefault: column.filled
+			};
+			if (column.readonly) meta.generated = true;
+			if (column.snapshot.identity) meta.identity = column.snapshot.identity;
+			if (!column.readonly && !column.insertable) meta.insertable = false;
+			if (!column.readonly && !column.updatable) meta.updatable = false;
+			if (column.selectable === false) meta.selectable = false;
+			if (column.snapshot.isArray) meta.array = true;
+			if (column.json) meta.json = true;
+			if (column.values) meta.enum = column.values;
+			if (column.codec) meta.codec = column.codec;
+			if (column.storage) meta.storage = column.storage;
+			if (config.sensitive.includes(`${table.name}.${column.db}`) || config.sensitive.includes(`${table.schema}.${table.name}.${column.db}`)) meta.sensitive = true;
+			Object.assign(meta, commentMeta(column.snapshot.comment));
+			columnMeta[column.app] = meta;
+		}
+		const app = (db) => byDb.get(db)?.app ?? db;
+		const uniqueKeys = {};
+		for (const unique of table.uniques) uniqueKeys[unique.name] = unique.columns.map(app);
+		const relationMeta = {};
+		for (const relation of list) relationMeta[relation.name] = relation.meta;
+		return {
+			key,
+			snapshot: table,
+			casing,
+			columns,
+			relations: list,
+			meta: {
+				key,
+				name: table.name,
+				schema: table.schema,
+				kind: table.kind,
+				columns: columnMeta,
+				primaryKey: table.primaryKey.map(app),
+				uniqueKeys,
+				relations: relationMeta,
+				flags,
+				...commentMeta(table.comment)
+			}
+		};
+	});
+}
+function buildEnums(ctx) {
+	const { config, catalog } = ctx;
+	const includedEnums = catalog.enums.filter((entry) => config.schemas.includes(entry.schema));
+	const enumNameCount = /* @__PURE__ */ new Map();
+	for (const entry of includedEnums) enumNameCount.set(entry.name, (enumNameCount.get(entry.name) ?? 0) + 1);
+	return includedEnums.map((entry) => {
+		const key = entry.schema !== "public" && (enumNameCount.get(entry.name) ?? 0) > 1 ? `${entry.schema}_${entry.name}` : entry.name;
+		return {
+			schema: entry.schema,
+			name: entry.name,
+			key,
+			constant: identifier(`${toCamel(key)}Values`),
+			typeName: identifier(pascal$2(key)),
+			values: entry.values
+		};
+	});
+}
+function assembleMeta(config, tableModels, enums, functions) {
+	const tablesMeta = {};
+	for (const table of tableModels) tablesMeta[table.key] = table.meta;
+	const enumsMeta = {};
+	for (const entry of enums) enumsMeta[entry.key] = entry.values;
+	const functionsMeta = {};
+	for (const [key, group] of functionGroups(functions)) {
+		const [first] = group;
+		if (!first) continue;
+		functionsMeta[key] = group.length === 1 ? first.meta : {
+			...first.meta,
+			overloads: group.map(signatureOf)
+		};
+	}
+	const claimOverrides = {};
+	for (const key of Object.keys(DEFAULT_CLAIMS)) if (config.claims[key] !== DEFAULT_CLAIMS[key]) claimOverrides[key] = config.claims[key];
+	const tenantClaim = config.claims.tenant === DEFAULT_CLAIMS.tenant ? void 0 : tenantClaimPaths(config.claims.tenant);
+	return {
+		version: 1,
+		casing: config.casing,
+		tables: tablesMeta,
+		enums: enumsMeta,
+		functions: functionsMeta,
+		...Object.keys(config.buckets).length > 0 ? { buckets: Object.fromEntries(Object.entries(config.buckets).map(([name, bucket]) => [name, {
+			id: bucket.id ?? name.replaceAll(/[A-Z]/g, (char) => `-${char.toLowerCase()}`),
+			public: bucket.public ?? false,
+			path: bucket.path,
+			...bucket.policy ? { policy: typeof bucket.policy === "string" ? bucket.policy : resolveProviderSql(`buckets.${name}`, bucket.policy, config.authorization?.functions) } : {},
+			...bucket.policy === "tenant" && tenantClaim ? { tenant: { claim: tenantClaim } } : {},
+			...bucket.fileSizeLimit ? { fileSizeLimit: bucket.fileSizeLimit } : {},
+			...bucket.allowedMimeTypes ? { allowedMimeTypes: bucket.allowedMimeTypes } : {},
+			...bucket.versioning ? { versioning: true } : {},
+			...bucket.lifecycle ? { lifecycle: bucket.lifecycle } : {}
+		}])) } : {},
+		...Object.keys(config.topics).length > 0 ? { topics: config.topics } : {},
+		...config.realtime.tables.length > 0 ? { realtime: realtimeMeta(config.realtime.tables, config.realtime.users, tableModels) } : {},
+		...Object.keys(claimOverrides).length > 0 ? { claims: claimOverrides } : {}
+	};
+}
+/** Builds the codegen model from a snapshot and config. */
+function buildModel(snapshot, config) {
+	const ctx = prepareCatalog(snapshot, config);
+	const tables = draftTables(ctx);
+	ctx.warnings.push(...configWarnings(ctx));
+	const tableModels = toTableModels(ctx, tables, buildRelations(ctx, tables));
+	const enums = buildEnums(ctx);
+	const functions = buildFunctions(ctx, tableModels);
+	return {
+		tables: tableModels,
+		enums,
+		functions,
+		jsonImports: [...ctx.jsonImports.values()],
+		meta: assembleMeta(config, tableModels, enums, functions),
+		config,
+		catalog: ctx.catalog,
+		introspection: ctx.introspection,
+		warnings: ctx.warnings,
+		notices: ctx.notices
+	};
+}
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const entry of Object.values(value)) deepFreeze(entry);
+	}
+	return value;
+}
+/**
+* The public, frozen view of the model that generators receive, with the
+* installed blocks `generatorBlocks` lists.
+*/
+function generatorModel(model, blocks = []) {
+	return deepFreeze({
+		tables: model.tables.map((table) => ({
+			key: table.key,
+			schema: table.snapshot.schema,
+			name: table.snapshot.name,
+			casing: table.casing,
+			columns: table.columns.map((column) => ({
+				app: column.app,
+				db: column.db,
+				tsType: column.tsType,
+				nullable: column.nullable,
+				optional: column.optional,
+				readonly: column.readonly,
+				values: column.values === void 0 ? void 0 : [...column.values],
+				json: column.json
+			}))
+		})),
+		enums: model.enums.map((entry) => ({
+			schema: entry.schema,
+			name: entry.name,
+			values: [...entry.values]
+		})),
+		functions: model.functions.map((fn) => ({
+			key: fn.key,
+			schema: fn.meta.schema,
+			args: fn.args.map((arg) => ({
+				name: arg.name,
+				tsType: arg.tsType,
+				optional: arg.optional,
+				values: arg.values === void 0 ? void 0 : [...arg.values]
+			})),
+			returns: fn.returns,
+			returnsSet: fn.meta.returnsSet,
+			volatility: fn.meta.volatility
+		})),
+		blocks
+	});
+}
+/**
+* Makes relation names unique per table and distinct from column names: two FKs
+* to the same table become `customersByPrimaryContact`-style names. When those
+* still collide, the names use every column of the key
+* (`locationsByCustomerOrganization`), then the constraint name, and only then
+* a trailing `_`.
+*/
+function dedupeRelations(list, columns, casing) {
+	const suffixed = (relation, suffix) => applyCasing(`${relation.base}_by_${suffix}`, casing);
+	const keyColumns = (relation, all) => (all ? relation.fkColumns : namingColumns(relation.fkColumns, relation.refColumns)).map((column) => column.replace(/_?[iI]d$/, "")).join("_");
+	const repeated = (names) => {
+		const seen = /* @__PURE__ */ new Set();
+		const twice = /* @__PURE__ */ new Set();
+		for (const name of names) (seen.has(name) ? twice : seen).add(name);
+		return twice;
+	};
+	const plain = repeated(list.map((relation) => relation.name));
+	const names = [(relation) => suffixed(relation, keyColumns(relation, true)), (relation) => suffixed(relation, relation.meta.foreignKey)].reduce((current, step) => {
+		const clash = repeated(current);
+		return list.map((relation, index) => {
+			const name = current[index] ?? relation.name;
+			return clash.has(name) || columns.has(name) ? step(relation) : name;
+		});
+	}, list.map((relation) => plain.has(relation.name) || columns.has(relation.name) ? suffixed(relation, keyColumns(relation, false)) : relation.name));
+	const used = /* @__PURE__ */ new Set();
+	return list.map((relation, index) => {
+		let name = names[index] ?? relation.name;
+		while (used.has(name) || columns.has(name)) name = `${name}_`;
+		used.add(name);
+		return {
+			...relation,
+			name
+		};
+	});
+}
+function realtimeMeta(names, users, tables) {
+	const out = {};
+	for (const name of names) {
+		const table = tables.find((candidate) => candidate.meta.name === name || `${candidate.meta.schema}.${candidate.meta.name}` === name);
+		if (!table) throw new CliError("config_invalid", `database.realtime.tables: unknown table "${name}". Check the name and \`schemas\`.`);
+		const owner = users[name];
+		if (owner !== void 0) {
+			const user = Object.entries(table.meta.columns).find(([, column]) => column.db === owner)?.[0];
+			if (user === void 0) throw new CliError("config_invalid", `database.realtime.users: "${name}" has no column "${owner}".`);
+			out[table.key] = { user };
+			continue;
+		}
+		const tenant = table.meta.flags.tenant;
+		out[table.key] = tenant ? { tenant } : {};
+	}
+	return out;
+}
+//#endregion
+//#region src/cli/gen/emit.ts
+const GENERATED_HEADER = "// @generated by better-supabase gen. Do not edit; run `better-supabase gen` instead.";
+function rowEntries(columns, name) {
+	return columns.map((column) => `${prop(column[name])}${column.selectable === false ? "?" : ""}: ${nullable(column.tsType, column.nullable)};`);
+}
+function insertEntries(columns, name) {
+	return columns.map((column) => {
+		if (!column.insertable) return `${prop(column[name])}?: never;`;
+		const optional = column.optional ? "?" : "";
+		return `${prop(column[name])}${optional}: ${nullable(column.tsType, column.nullable)};`;
+	});
+}
+function updateEntries(columns, name) {
+	return columns.map((column) => {
+		if (!column.updatable) return `${prop(column[name])}?: never;`;
+		return `${prop(column[name])}?: ${nullable(column.tsType, column.nullable)};`;
+	});
+}
+/**
+* Postgres passes `null` to any argument, so every argument accepts it. This
+* only widens what a caller may pass; no result type changes with it. An
+* optional argument also accepts `undefined`, which `rpc()` leaves out, so
+* `exactOptionalPropertyTypes` apps can pass a maybe-missing value.
+*/
+function argEntries(fn) {
+	return fn.args.map((arg) => `${prop(arg.name)}${arg.optional ? "?" : ""}: ${nullable(arg.tsType, true)}${arg.optional ? " | undefined" : ""};`);
+}
+function enrichedDatabase(model) {
+	const schemas = model.config.schemas.flatMap((schema) => {
+		const tables = model.tables.filter((t) => t.snapshot.schema === schema).flatMap((table) => {
+			const overrides = table.columns.filter((column) => column.values !== void 0 && !column.snapshot.isEnum || column.json && column.tsType !== "Json" || column.storage !== void 0).map((column) => `${prop(column.db)}: ${column.tsType};`);
+			return overrides.length > 0 ? block(prop(table.snapshot.name), overrides) : [];
+		});
+		return tables.length > 0 ? block(prop(schema), tables) : [];
+	});
+	if (schemas.length === 0) return ["export type Database = SupabaseDatabase;"];
+	return [
+		"export type Database = EnrichDatabase<",
+		"  SupabaseDatabase,",
+		"  {",
+		...indent(schemas, 2),
+		"  }",
+		">;"
+	];
+}
+function modelsType(model) {
+	return [
+		"export type Models = {",
+		...indent(model.tables.flatMap((table) => {
+			const relations = table.relations.map((relation) => `${prop(relation.name)}: { table: ${q(relation.meta.table)}; kind: ${q(relation.meta.kind)}; nullable: ${String(relation.meta.nullable)} };`);
+			const pk = table.meta.primaryKey;
+			const uniques = Object.entries(table.meta.uniqueKeys).map(([name, columns]) => `${prop(name)}: readonly [${columns.map(q).join(", ")}];`);
+			const flags = [];
+			const tableFlags = table.meta.flags;
+			if (tableFlags.softDelete) flags.push(`softDelete: ${q(tableFlags.softDelete)};`);
+			if (tableFlags.timestamps) flags.push("timestamps: true;");
+			if (tableFlags.tenant) flags.push(`tenant: ${q(tableFlags.tenant)};`);
+			if (tableFlags.actor) flags.push("actor: true;");
+			const none = "Record<never, never>";
+			const union = (names) => names.length === 0 ? "never" : names.map(q).join(" | ");
+			return block(prop(table.key), [
+				...block("Row", rowEntries(table.columns, "app"), none),
+				...table.snapshot.insertable ? block("Insert", insertEntries(table.columns, "app"), none) : ["Insert: never;"],
+				...table.snapshot.updatable ? block("Update", updateEntries(table.columns, "app"), none) : ["Update: never;"],
+				...block("Relations", relations, none),
+				`PrimaryKey: ${union(pk)};`,
+				...block("UniqueKeys", uniques, none),
+				`Checks: ${union(table.snapshot.checks.map((check) => check.name))};`,
+				`ForeignKeys: ${union(table.snapshot.foreignKeys.map((fk) => fk.name))};`,
+				...block("Flags", flags, none)
+			]);
+		}), 1),
+		"};"
+	];
+}
+function functionsType(model) {
+	if (model.functions.length === 0) return ["export type Functions = Record<never, never>;"];
+	return [
+		"export type Functions = {",
+		...indent([...functionGroups(model.functions)].flatMap(([key, group]) => {
+			const [first] = group;
+			if (group.length === 1 && first) return block(prop(key), [...block("Args", argEntries(first), "Record<never, never>"), `Returns: ${first.returns};`]);
+			return [`${prop(key)}:`, ...indent(group.flatMap((fn, index) => {
+				const lines = [...block("Args", argEntries(fn), "Record<PropertyKey, never>"), `Returns: ${fn.returns};`];
+				const end = index === group.length - 1 ? "};" : "}";
+				return [
+					"| {",
+					...indent(lines, 1),
+					end
+				];
+			}), 1)];
+		}), 1),
+		"};"
+	];
+}
+/**
+* The metadata module next to `generated.ts`: `generated.meta.js` and its
+* `.d.ts`.
+*/
+function metaPaths(output) {
+	const base = output.replace(/\.[cm]?[jt]sx?$/, "");
+	return {
+		js: `${base}.meta.js`,
+		dts: `${base}.meta.d.ts`
+	};
+}
+/**
+* JSON with one line per table, function and other named entry, so the module
+* stays small to load and a schema change still diffs per entry.
+*/
+function compactJson(meta) {
+	return `{\n${Object.entries(meta).map(([key, value]) => {
+		const name = JSON.stringify(key);
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return `  ${name}: ${JSON.stringify(value)}`;
+		const inner = Object.entries(value).map(([entry, item]) => `    ${JSON.stringify(entry)}: ${JSON.stringify(item)}`);
+		return inner.length === 0 ? `  ${name}: {}` : `  ${name}: {\n${inner.join(",\n")}\n  }`;
+	}).join(",\n")}\n}`;
+}
+/**
+* The schema metadata as plain JavaScript plus a one-line declaration, so
+* TypeScript reads `SchemaMeta` instead of checking thousands of lines of
+* object literal in every program that imports the generated module.
+*/
+function emitMeta(model, options = {}) {
+	const runtime = options.runtimeImport ?? "better-supabase";
+	return {
+		js: [
+			GENERATED_HEADER,
+			`// @ts-self-types="${options.types ?? "./generated.meta.d.ts"}"`,
+			"/* oxlint-disable */",
+			"/* eslint-disable */",
+			"",
+			`export default ${compactJson({ ...model.meta })};`,
+			""
+		].join("\n"),
+		dts: [
+			GENERATED_HEADER,
+			"/* oxlint-disable */",
+			"/* eslint-disable */",
+			"",
+			`import type { SchemaMeta } from ${q(runtime)};`,
+			"",
+			"declare const meta: SchemaMeta;",
+			"export default meta;",
+			""
+		].join("\n")
+	};
+}
+/** Names the generated module declares or imports itself. */
+const RESERVED_EXPORTS = [
+	"defineSchema",
+	"Schema",
+	"SchemaMeta",
+	"EnrichDatabase",
+	"MutableWhere",
+	"OrderByArg",
+	"OrderByInput",
+	"StoragePath",
+	"SupabaseDatabase",
+	"meta",
+	"Json",
+	"Database",
+	"Models",
+	"Functions",
+	"TableName",
+	"UniqueConstraint",
+	"CheckConstraint",
+	"ForeignKeyConstraint",
+	"RowOf",
+	"InsertOf",
+	"UpdateOf",
+	"WhereOf",
+	"OrderByOf",
+	"OrderTermOf",
+	"WritableColumnOf",
+	"GeneratedColumnOf",
+	"buckets",
+	"topics",
+	"subjectTypes",
+	"SubjectType",
+	"RecordRef",
+	"schema",
+	"extensions",
+	"Extensions",
+	"ExtensionsOf",
+	"validation",
+	"validators"
+];
+function valueLists(model) {
+	const lists = model.enums.map((entry) => ({
+		constant: entry.constant,
+		typeName: entry.typeName,
+		values: entry.values,
+		source: `enum ${entry.schema}.${entry.name}`
+	}));
+	for (const table of model.tables) for (const column of table.columns) if (column.values && !column.snapshot.isEnum) lists.push({
+		constant: identifier(`${table.key}${pascal$2(column.app)}Values`.replace(/^[A-Z]/, (c) => c.toLowerCase())),
+		typeName: identifier(`${pascal$2(table.key)}${pascal$2(column.app)}`),
+		values: column.values,
+		source: `the CHECK on ${table.snapshot.schema}.${table.snapshot.name}.${column.db}`
+	});
+	return lists;
+}
+/** The repository extension calls the schema carries, in install order. */
+function extensionCalls(options) {
+	return [...(options.extensions ?? []).map((extension) => ({
+		fn: extension.export,
+		call: `${extension.export}(${extension.args})`
+	})), ...options.validatorsImport === void 0 ? [] : [{
+		fn: "validation",
+		call: "validation({ schemas: validators })"
+	}]];
+}
+function runtimeImports(options, runtime) {
+	const { validatorsImport } = options;
+	return [...(options.extensions ?? []).map((extension) => `import { ${extension.export} } from ${q(runtimeSubpath(runtime, extension.subpath))};`), ...validatorsImport === void 0 ? [] : [`import { validators } from ${q(validatorsImport)};`]];
+}
+/**
+* `database.types.ts` inside a type-only namespace, so its `Json` and
+* `Database` don't clash with the module's own. Its `Constants` value is left
+* out: a namespace holding a value is not erasable syntax.
+*/
+function inlineDatabaseTypes(text) {
+	const constants = text.search(/^export const Constants\b/m);
+	return [
+		"declare namespace SupabaseTypes {",
+		...indent([(constants === -1 ? text : text.slice(0, constants)).trimEnd()], 1),
+		"}",
+		"type SupabaseDatabase = SupabaseTypes.Database;"
+	];
+}
+/**
+* The runtime half of the generated module, for the content mapper: the values
+* (value lists, buckets, topics, extensions, subject types and `schema`), with
+* every type re-exported from the virtual module at `typesImport`, which holds
+* the full module.
+*/
+function emitRuntime(model, options) {
+	const runtime = options.runtimeImport ?? "better-supabase";
+	const calls = extensionCalls(options);
+	const subjects = Object.keys(model.config.subjects);
+	const lines = [
+		GENERATED_HEADER,
+		"/* oxlint-disable */",
+		"/* eslint-disable */",
+		"",
+		`import { defineSchema${options.validatorsImport === void 0 ? "" : ", validation"} } from ${q(runtime)};`,
+		...runtimeImports(options, runtime),
+		`import type { schema as typedSchema } from ${q(options.typesImport)};`,
+		`import meta from ${q(options.metaImport ?? "./generated.meta.js")};`,
+		"",
+		`export type * from ${q(options.typesImport)};`,
+		"",
+		...valueLists(model).map((list) => `export const ${list.constant} = [${list.values.map(q).join(", ")}] as const;`)
+	];
+	if (model.meta.buckets) lines.push(`export const buckets = ${JSON.stringify(model.meta.buckets, null, 2)} as const;`);
+	if (model.meta.topics) lines.push(`export const topics = ${JSON.stringify(model.meta.topics, null, 2)} as const;`);
+	if (subjects.length > 0) lines.push(`export const subjectTypes = [${subjects.map(q).join(", ")}] as const;`);
+	lines.push("", `export const schema: typeof typedSchema = defineSchema(meta${calls.length > 0 ? `, [${calls.map(({ call }) => call).join(", ")}]` : ""});`, "");
+	return lines.join("\n");
+}
+/** Renders the generated module. */
+function emitModule(model, options) {
+	const runtime = options.runtimeImport ?? "better-supabase";
+	const extensions = options.extensions ?? [];
+	const { validatorsImport } = options;
+	const extended = extensions.length > 0 || validatorsImport !== void 0;
+	const declaresMeta = options.inlineMeta === true || options.declareMeta === true;
+	const lines = [
+		GENERATED_HEADER,
+		"/* oxlint-disable */",
+		"/* eslint-disable */",
+		"",
+		`import { defineSchema, ${validatorsImport === void 0 ? "" : "validation, "}${extended ? "type ExtensionsOf, " : ""}type Schema${declaresMeta ? ", type SchemaMeta" : ""} } from ${q(runtime)};`,
+		...runtimeImports(options, runtime)
+	];
+	const storagePaths = model.tables.some((table) => table.columns.some((column) => column.storage !== void 0));
+	lines.push(`import type { EnrichDatabase, GeneratedColumns, MutableWhere, OrderByArg, OrderByInput${storagePaths ? ", StoragePath" : ""}, WritableColumns } from ${q(runtime)};`);
+	if (options.databaseTypes === void 0) lines.push(`import type { Database as SupabaseDatabase } from ${q(options.databaseTypesImport ?? "./database.types.ts")};`);
+	const byFile = /* @__PURE__ */ new Map();
+	for (const entry of model.jsonImports) {
+		const list = byFile.get(entry.from) ?? [];
+		list.push(entry.name);
+		byFile.set(entry.from, list);
+	}
+	for (const [from, names] of [...byFile.entries()].toSorted(([a], [b]) => byCodePoint(a, b))) lines.push(`import type { ${names.toSorted().join(", ")} } from ${q(options.importPathFor(from))};`);
+	lines.push(options.inlineMeta ? `\nconst meta: SchemaMeta = ${compactJson({ ...model.meta })};` : options.declareMeta ? "\ndeclare const meta: SchemaMeta;" : `import meta from ${q(options.metaImport ?? "./generated.meta.js")};`, ...options.databaseTypes === void 0 ? [] : ["", ...inlineDatabaseTypes(options.databaseTypes)], "", "export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[];", "", ...enrichedDatabase(model), "");
+	const exported = new Map([
+		...RESERVED_EXPORTS,
+		...extensions.map((extension) => extension.export),
+		...model.jsonImports.map((entry) => entry.name)
+	].map((name) => [name, "the generated module"]));
+	const claim = (name, source) => {
+		const other = exported.get(name);
+		if (other !== void 0) throw new TypeError(`${source} and ${other} both export "${name}" from the generated module. Rename one of them in the database.`);
+		exported.set(name, source);
+		return name;
+	};
+	for (const list of valueLists(model)) lines.push(`export const ${claim(list.constant, list.source)} = [${list.values.map(q).join(", ")}] as const;`, `export type ${claim(list.typeName, list.source)} = (typeof ${list.constant})[number];`);
+	if (model.enums.length > 0) lines.push("");
+	lines.push(...modelsType(model), "", ...functionsType(model), "", "export type TableName = keyof Models;", "/** Constraint names for `isConflict`, `isCheck` and `isForeignKey`. */", "export type UniqueConstraint = { [T in TableName]: Extract<keyof Models[T]['UniqueKeys'], string> }[TableName];", "export type CheckConstraint = Models[TableName]['Checks'];", "export type ForeignKeyConstraint = Models[TableName]['ForeignKeys'];", "export type RowOf<T extends TableName> = Models[T]['Row'];", "export type InsertOf<T extends TableName> = Models[T]['Insert'];", "export type UpdateOf<T extends TableName> = Models[T]['Update'];", "/** A `where` for `T` you can assign to one key at a time. */", "export type WhereOf<T extends TableName> = MutableWhere<Models, T>;", "/** An `orderBy` for `T`: one sort or a list, by column or to-one relation. */", "export type OrderByOf<T extends TableName> = OrderByArg<Models, T>;", "/** One sort term of `T`'s `orderBy`, by column or to-one relation. */", "export type OrderTermOf<T extends TableName> = OrderByInput<Models, T>;", "/** Columns of `T` that `Insert` and `Update` accept. */", "export type WritableColumnOf<T extends TableName> = WritableColumns<Models, T>;", "/** Columns of `T` the database fills (generated columns): in `Row`, never writable. */", "export type GeneratedColumnOf<T extends TableName> = GeneratedColumns<Models, T>;", "");
+	if (model.meta.buckets) lines.push("/** Bucket configs for `defineBucket` from `better-supabase/storage`. */", `export const buckets = ${JSON.stringify(model.meta.buckets, null, 2)} as const;`, "");
+	if (model.meta.topics) lines.push("/** Topic templates for `defineTopic` from `better-supabase/realtime`. */", `export const topics = ${JSON.stringify(model.meta.topics, null, 2)} as const;`, "");
+	const subjects = Object.keys(model.config.subjects);
+	const calls = extensionCalls(options);
+	if (extended) lines.push("/** The installed blocks' repository extensions; `defineSupabase` installs them. */", `type Extensions = readonly [${calls.map(({ fn }) => `ReturnType<typeof ${fn}>`).join(", ")}];`, `const extensions: Extensions = [${calls.map(({ call }) => call).join(", ")}];`, "");
+	const subjectType = subjects.length > 0 ? "SubjectType" : "string";
+	const schemaLine = extended ? `export const schema: Schema<Models, Database, Functions, ${subjectType}, ExtensionsOf<Extensions>> = defineSchema(meta, extensions);` : `export const schema: Schema<Models, Database, Functions${subjects.length > 0 ? ", SubjectType" : ""}> = defineSchema(meta);`;
+	if (subjects.length > 0) lines.push("/** The app's subject types, from `config.records`. */", `export const subjectTypes = [${subjects.map(q).join(", ")}] as const;`, "export type SubjectType = (typeof subjectTypes)[number];", "/** One subject: its type and its id as text. */", "export type RecordRef<T extends SubjectType = SubjectType> = { readonly type: T; readonly id: string };", "");
+	lines.push(schemaLine, "");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/gen/blocks.ts
+/** `blocks.generated.ts`, next to the main generated module. */
+function blockConfigPath(config) {
+	return posix.join(posix.dirname(config.output), "blocks.generated.ts");
+}
+function hasSchema(module) {
+	return module in BLOCK_OPTION_SCHEMAS;
+}
+/**
+* How the tenant rename, the modules' renamed entities and their
+* `blocks.<module>.functions` rename the block's functions and payload keys, or
+* undefined when nothing does. `blocks.permissions.functions` is the custom
+* model's templates, not renames.
+*/
+function namingOf(config, modules, instanceFunctionNames = {}) {
+	const functions = Object.fromEntries([...modules.flatMap((module) => module === "permissions" ? [] : Object.entries(resolveBlock(config.blocks[module]).functions)), ...Object.entries(instanceFunctionNames)]);
+	const entities = modules.flatMap((module) => blockEntityRenames(module, config.blocks));
+	const tenant = tenantNameOf(config.blocks);
+	const renames = Object.keys(functions).length > 0;
+	if (tenant === void 0 && !renames && entities.length === 0) return;
+	return {
+		...tenant === void 0 ? {} : { tenant },
+		...renames ? { functions } : {},
+		...entities.length === 0 ? {} : { entities }
+	};
+}
+/**
+* The generated config of every installed block: its schema, its API schema,
+* and the options marked `client` with the configured value or the module's
+* default. Blocks without a creator get an entry too, since `block.using(...)`
+* builds them with these options.
+*/
+function blockConfigEntries(config) {
+	const installed = resolveBlocks(config.blockNames, {
+		modules: config.blocks,
+		...config.sql.scope === void 0 ? {} : { scope: config.sql.scope }
+	}).map((module) => module.name);
+	const entries = [];
+	for (const manifest of PRESET_CATALOG.manifests) {
+		const modules = manifest.sql.filter((module) => installed.includes(module));
+		const [main] = modules;
+		const others = Object.values(config.instances).filter((instance) => instance.block === main);
+		if (main !== void 0 && (others.length === 0 || others.some((each) => each.name === main))) entries.push([manifest.name, generatedEntry(config, modules)]);
+		for (const instance of others) {
+			if (main === void 0 || instance.name === main) continue;
+			const layout = {
+				modules: config.blocks,
+				instances: config.instances,
+				...config.sql.scope === void 0 ? {} : { scope: config.sql.scope }
+			};
+			const entry = generatedEntry({
+				...config,
+				blocks: {
+					...config.blocks,
+					[main]: instance.config
+				}
+			}, modules, instanceFunctions(layout, installed, instance.name));
+			entries.push([instance.name, {
+				...entry,
+				block: manifest.name,
+				...Object.keys(instance.uses).length === 0 ? {} : { uses: instance.uses }
+			}]);
+		}
+	}
+	return Object.fromEntries(entries);
+}
+/**
+* One instance's generated config: the schema of its main module, the client
+* options of `modules` and its naming.
+*/
+function generatedEntry(config, modules, instanceFunctionNames) {
+	const resolved = resolveBlock(config.blocks[modules[0] ?? ""]);
+	const options = {};
+	for (const module of modules) {
+		if (!hasSchema(module)) continue;
+		const configured = resolveBlock(config.blocks[module]).options;
+		for (const [key, spec] of Object.entries(BLOCK_OPTION_SCHEMAS[module].specs)) {
+			if (!spec.client) continue;
+			const value = configured[key] ?? spec.default;
+			if (value !== void 0) options[key] = value;
+		}
+	}
+	const names = namingOf(config, modules, instanceFunctionNames);
+	return {
+		schema: resolved.schema,
+		...resolved.api === void 0 ? {} : { api: resolved.api.schema },
+		options,
+		...names === void 0 ? {} : { names }
+	};
+}
+function literal(value, indent) {
+	if (Array.isArray(value)) return `[${value.map((entry) => literal(entry, indent)).join(", ")}]`;
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		const inner = `${indent}  `;
+		return `{\n${entries.map(([key, entry]) => `${inner}${prop(key)}: ${literal(entry, inner)},`).join("\n")}\n${indent}}`;
+	}
+	return JSON.stringify(value);
+}
+/** Every event type the app tables emit, in config order. */
+function appTableEvents(config) {
+	return Object.entries(config.appTables).flatMap(([name, table]) => appTableEventTypes(name, table));
+}
+/**
+* `appTableEvents` and `appTableEventSchemas`, for app tables that set
+* `events`.
+*/
+function appTableEventLines(types) {
+	if (types.length === 0) return [];
+	return [
+		"",
+		"/**",
+		" * The events `tables.<table>.events` writes to the outbox, for `onBlockEvent` and the sinks.",
+		" * @public",
+		" */",
+		"export const appTableEvents = defineEvents({",
+		...types.map((type) => `  ${prop(type)}: event<AppTableEventData>(),`),
+		"});",
+		"",
+		"/**",
+		" * The app table events with an open payload, for AsyncAPI's `cloudEvents.blocks`.",
+		" * @public",
+		" */",
+		"export const appTableEventSchemas = {",
+		...types.map((type) => `  ${prop(type)}: true,`),
+		"} as const;"
+	];
+}
+const CATALOG_BLOCKS = new Map(PRESET_CATALOG.blocks.map((block) => [block.name, block]));
+const MANIFESTS = new Map(PRESET_CATALOG.manifests.map((manifest) => [manifest.name, manifest]));
+/**
+* The repository extensions of the installed blocks, in block order. The
+* `memberships` one also stands for an app's own tenancy, when
+* `auth.organization.column` turns it on without the block.
+*/
+function schemaExtensions(config) {
+	const tenant = config.extensions.tenant;
+	const tenantOptions = Object.entries({
+		onMissing: tenant?.onMissing,
+		header: tenant?.header
+	}).flatMap(([key, value]) => value === void 0 ? [] : [`${key}: ${q(value)}`]);
+	const tenantArgs = tenantOptions.length === 0 ? "" : `{ ${tenantOptions.join(", ")} }`;
+	const extensions = config.blockNames.flatMap((name) => {
+		const manifest = MANIFESTS.get(CATALOG_BLOCKS.get(name)?.manifest ?? "");
+		if (manifest?.extension === void 0) return [];
+		return [{
+			export: manifest.extension,
+			subpath: `blocks/${manifest.name}`,
+			args: manifest.name === "memberships" ? tenantArgs : ""
+		}];
+	});
+	if (tenant !== void 0 && !extensions.some((entry) => entry.subpath === "blocks/memberships")) extensions.push({
+		export: "membershipsExtension",
+		subpath: "blocks/memberships",
+		args: tenantArgs
+	});
+	return extensions;
+}
+/** The installed blocks with their final names, for `GeneratorModel.blocks`. */
+function generatorBlocks(config) {
+	return Object.entries(blockConfigEntries(config)).filter(([, entry]) => entry.block === void 0).map(([name, entry]) => {
+		const manifest = MANIFESTS.get(CATALOG_BLOCKS.get(name)?.manifest ?? "");
+		const owned = manifest?.name === name ? manifest : void 0;
+		const client = owned?.client ?? void 0;
+		const renames = entityNames(entry.names?.entities ?? []);
+		return {
+			name,
+			schema: entry.schema,
+			client: client === void 0 ? void 0 : {
+				export: renames.rename(client.export),
+				subpath: client.subpath
+			},
+			entities: blockEntities(name, config.blocks).map((entity) => ({
+				key: entity.key,
+				from: { ...entity.from },
+				to: { ...entity.to },
+				primary: entity.primary,
+				table: entity.table,
+				url: entity.url,
+				schemas: owned?.entitySchemas?.[entity.key] ?? {}
+			}))
+		};
+	});
+}
+/**
+* For each installed block whose entities `blocks.<name>.entities` renames: the
+* block under its renamed constant (`tasksBlock`) and an alias for each type
+* named after one of its entities (`Task<F>`, `TasksEvents`).
+*/
+function renamedBlockLines(entries) {
+	const imports = [];
+	const lines = [];
+	const exported = /* @__PURE__ */ new Set();
+	const constants = /* @__PURE__ */ new Map();
+	for (const manifest of PRESET_CATALOG.manifests) {
+		const instances = Object.entries(entries).filter(([key, entry]) => (entry.block ?? key) === manifest.name && (entry.names?.entities ?? []).length > 0);
+		if (manifest.client === null || instances.length === 0) continue;
+		const aliasAll = instances.length > 1;
+		const block = manifest.client.export;
+		const entityTypes = (manifest.entityTypes ?? []).filter((type) => !(type.name.endsWith("Options") && manifest.entityTypes?.some((other) => `${other.name}Options` === type.name)));
+		const eventsType = manifest.events?.type;
+		const types = eventsType === void 0 || entityTypes.some((type) => type.name === eventsType) ? entityTypes : [...entityTypes, { name: eventsType }];
+		const [first] = instances;
+		const firstNames = entityNames(first?.[1].names?.entities ?? []);
+		const localOf = (name) => aliasAll || firstNames.rename(name) === name ? `Default${name}` : name;
+		const local = aliasAll || firstNames.rename(block) === block ? `default${pascal(block)}` : block;
+		const specifiers = [...types.map((type) => localOf(type.name) === type.name ? `  type ${type.name},` : `  type ${type.name} as ${localOf(type.name)},`), `  ${local === block ? block : `${block} as ${local}`},`];
+		imports.push([
+			"import {",
+			...specifiers,
+			`} from ${q(manifest.client.subpath)};`
+		].join("\n"));
+		for (const [instance, entry] of instances) {
+			const names = entityNames(entry.names?.entities ?? []);
+			const alias = `${pascal(camelOf(instance))}Renames`;
+			const key = q(instance);
+			const wanted = instance === manifest.name ? names.rename(block) : `${camelOf(instance)}Block`;
+			const renamed = exported.has(wanted) ? `${camelOf(instance)}Block` : wanted;
+			exported.add(renamed);
+			constants.set(instance, renamed);
+			lines.push("", `type ${alias} = (typeof blockConfig)[${key}]["names"]["entities"];`, "", "/**", ` * The \`${manifest.name}\` block under the names \`blocks.${instance}.entities\` gives it.`, " * @public", " */", `export const ${renamed} = renameBlock(${local}, blockConfig[${key}].names);`, ...renamedTypeLines(types, names, localOf, alias, exported, {
+				block: eventsType,
+				instance: instance === manifest.name ? void 0 : `${pascal(camelOf(instance))}Events`
+			}));
+		}
+	}
+	return {
+		specifiers: imports.length === 0 ? [] : [
+			"renameBlock",
+			"type RenamedEvents",
+			"type RenamedType"
+		],
+		imports,
+		lines,
+		constants
+	};
+}
+/**
+* `blocks`: every installed instance with a client, under its key, for
+* `defineBlocks(blockConfig, blocks)`. A renamed instance uses its renamed
+* constant; the others import their block.
+*/
+function instanceMapLines(entries, renamed) {
+	const imported = /* @__PURE__ */ new Map();
+	const members = [];
+	for (const [instance, entry] of Object.entries(entries)) {
+		const manifest = MANIFESTS.get(entry.block ?? instance);
+		const client = manifest?.client;
+		if (manifest === void 0 || client === void 0 || client === null) continue;
+		const constant = renamed.get(instance);
+		if (constant !== void 0) {
+			members.push(`  ${prop(instance)}: ${constant},`);
+			continue;
+		}
+		const local = `${camelOf(manifest.name)}BlockInstance`;
+		imported.set(manifest.name, {
+			local,
+			subpath: client.subpath
+		});
+		members.push(`  ${prop(instance)}: ${local},`);
+	}
+	if (members.length === 0) return {
+		imports: [],
+		lines: []
+	};
+	return {
+		imports: [...imported].map(([name, { local, subpath }]) => {
+			return `import { ${MANIFESTS.get(name)?.client?.export ?? local} as ${local} } from ${q(subpath)};`;
+		}),
+		lines: [
+			"",
+			"/**",
+			" * Every installed block instance with a client, under its key, for",
+			" * `defineBlocks(blockConfig, { ...blocks, ... })`. Override an entry to give",
+			" * a block its ports (`notifications: notificationsBlock.using(...)`).",
+			" * @public",
+			" */",
+			"export const blocks = {",
+			...members,
+			"} as const;"
+		]
+	};
+}
+/**
+* An alias for each of `types` under the name an instance's entity renames give
+* it, skipping a name another instance already exports. A renamed instance's
+* block-named events type takes the instance's name (`MaintenanceEvents`).
+*/
+function renamedTypeLines(types, names, localOf, alias, exported, events) {
+	return types.flatMap((type) => {
+		const name = type.name === events.block && events.instance !== void 0 ? events.instance : names.rename(type.name);
+		const source = localOf(type.name);
+		if (exported.has(name)) return [];
+		exported.add(name);
+		if (type.name.endsWith("Events")) return [
+			"",
+			"/** @public */",
+			`export type ${name} = RenamedEvents<${source}, ${alias}>;`
+		];
+		return type.fields === true ? [
+			"",
+			"/** @public */",
+			`export type ${name}<F extends object = Record<never, never>> = RenamedType<${source}<F>, ${alias}>;`
+		] : [
+			"",
+			"/** @public */",
+			`export type ${name} = RenamedType<${source}, ${alias}>;`
+		];
+	});
+}
+function camelOf(name) {
+	return name.replaceAll(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascal(name) {
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+* `blocks.generated.ts`: each installed block's schema, API schema and the
+* options its TypeScript side reads, for `defineBlocks(blockConfig, ...)`, and
+* the app table events. `undefined` when the config installs no blocks.
+*/
+function emitBlockConfig(config, options = {}) {
+	if (config.blockNames.length === 0) return;
+	const entries = blockConfigEntries(config);
+	const events = appTableEvents(config);
+	const runtime = options.runtimeImport ?? "better-supabase";
+	const renamed = renamedBlockLines(entries);
+	const constants = nameConstantLines(config, entries);
+	const instances = instanceMapLines(entries, renamed.constants);
+	const specifiers = [
+		...events.length === 0 ? [] : [
+			"type AppTableEventData",
+			"defineEvents",
+			"event"
+		],
+		"type GeneratedBlocks",
+		...renamed.specifiers,
+		...constants.specifiers
+	].toSorted((a, b) => a.replace("type ", "").localeCompare(b.replace("type ", "")));
+	const blocksImport = specifiers.length === 1 ? `import type { GeneratedBlocks } from ${q(runtimeSubpath(runtime, "blocks"))};` : `import {\n${specifiers.map((name) => `  ${name},`).join("\n")}\n} from ${q(runtimeSubpath(runtime, "blocks"))};`;
+	return {
+		path: blockConfigPath(config),
+		contents: [
+			GENERATED_HEADER,
+			"",
+			blocksImport,
+			...renamed.imports,
+			...constants.imports,
+			...instances.imports,
+			"",
+			"/**",
+			" * The installed blocks' settings from the `blocks` config, for",
+			" * `defineBlocks(blockConfig, { ... })`: each block's schema, API schema",
+			" * and the options its SQL and TypeScript halves share.",
+			" */",
+			`export const blockConfig = ${literal(entries, "")} as const satisfies GeneratedBlocks;`,
+			...renamed.lines,
+			...instances.lines,
+			...appTableEventLines(events),
+			...constants.lines,
+			""
+		].join("\n")
+	};
+}
+//#endregion
+//#region src/cli/gen/hooks.ts
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function access(property) {
+	return IDENTIFIER.test(property) ? `db.${property}` : `db[${q(property)}]`;
+}
+/** `hooks.ts`, next to the main generated module. */
+function hooksPath(config) {
+	return posix.join(posix.dirname(config.output), "hooks.ts");
+}
+/** The list and record hook names for a `db` property. */
+function hookNames(property) {
+	const name = pascal$2(property);
+	const one = pascal$2(singular(property));
+	return one === name ? {
+		list: `use${name}List`,
+		one: `use${name}`
+	} : {
+		list: `use${name}`,
+		one: `use${one}`
+	};
+}
+/**
+* `hooks.ts`: `defineDataHooks` from the `gen.hooks` framework once per table,
+* typed by the app's definition in `./index`. Block instances keep their own
+* client methods on `db.<instance>`, which take their own arguments.
+* `undefined` with `hooks: false`.
+*/
+function emitHooks(config, tables, options = {}) {
+	if (config.hooks === false) return;
+	const runtime = options.runtimeImport ?? "better-supabase";
+	if (tables.length === 0) return;
+	return {
+		path: hooksPath(config),
+		contents: [
+			GENERATED_HEADER,
+			...config.hooks === "react" ? ["\"use client\";"] : [],
+			"",
+			`import type { DbOf } from ${q(runtime)};`,
+			"",
+			`import { defineDataHooks } from ${q(runtimeSubpath(runtime, config.hooks))};`,
+			"",
+			"import type { betterSupabase } from \"./index\";",
+			"",
+			"type AppDb = DbOf<typeof betterSupabase>;",
+			...tables.flatMap((property) => {
+				const names = hookNames(property);
+				return [
+					"",
+					`export const { useList: ${names.list}, useOne: ${names.one} } =`,
+					`  defineDataHooks(${q(property)}, (db: AppDb) => ${access(property)});`
+				];
+			}),
+			""
+		].join("\n")
+	};
+}
+//#endregion
+//#region src/cli/gen/records.ts
+/** `names` and every block they require, from the catalog. */
+function withRequired(names) {
+	const requires = new Map(PRESET_CATALOG.blocks.map((block) => [block.name, block.requires]));
+	const found = /* @__PURE__ */ new Set();
+	const add = (name) => {
+		if (!found.has(name)) {
+			found.add(name);
+			for (const required of requires.get(name) ?? []) add(required);
+		}
+	};
+	for (const name of names) add(name);
+	return [...found];
+}
+function camel(name) {
+	return name.replaceAll(/[-_]([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function kebab(name) {
+	return name.replaceAll("_", "-");
+}
+/**
+* The record types a block's SQL serves, which is where its binding loads: the
+* types `blocks.<instance>.on` names, or every tenant-scoped registered subject
+* when it names none. Versions keep only the listed types and the subjects with
+* `versions` set.
+*/
+function servedSubjects(config, block) {
+	const listed = config.blocks[block]?.on;
+	const registry = Object.entries(config.subjects);
+	const named = listed === void 0 ? void 0 : Array.isArray(listed) ? listed : Object.keys(listed);
+	if (block === "versions") {
+		const versioned = registry.filter(([, entry]) => entry.versions !== void 0).map(([type]) => type);
+		return /* @__PURE__ */ new Set([...named ?? [], ...versioned]);
+	}
+	if (named !== void 0) return new Set(named);
+	return new Set(registry.filter(([, entry]) => entry.tenant !== false).map(([type]) => type));
+}
+function bindingBlocks(config) {
+	const manifests = new Map(PRESET_CATALOG.manifests.map((manifest) => [manifest.name, manifest]));
+	return generatorBlocks(config).flatMap((block) => {
+		const manifest = manifests.get(block.name);
+		if (manifest?.record === void 0 || manifest.client === null || block.client === void 0) return [];
+		const renamed = block.client.export !== manifest.client.export;
+		return [{
+			name: block.name,
+			key: camel(block.name),
+			local: block.client.export,
+			from: renamed ? void 0 : block.client.subpath
+		}];
+	});
+}
+function recordFile(config, path, type, blocks, extras) {
+	const generated = importPath(path, blockConfigPath(config));
+	const fromGenerated = [
+		"blockConfig",
+		...extras.permissions ? ["permissions"] : [],
+		...blocks.filter((block) => block.from === void 0).map((b) => b.local)
+	].toSorted((a, b) => a.localeCompare(b));
+	const imports = [
+		"import { defineRecordType } from \"better-supabase/records\";",
+		...blocks.flatMap((block) => block.from === void 0 ? [] : [`import { ${block.local} } from ${q(block.from)};`]),
+		...extras.access === void 0 ? [] : [`import { permissionsBlock } from ${q(extras.access)};`]
+	].toSorted((a, b) => a.localeCompare(b));
+	return {
+		path,
+		contents: [
+			GENERATED_HEADER,
+			"",
+			...imports,
+			"",
+			`import { ${fromGenerated.join(", ")} } from ${q(generated)};`,
+			"",
+			"/**",
+			` * The ${type} record type: each installed block that binds to it. Pass it`,
+			" * to `bsb.record`, `recordQueries` or `createRecordProvider`.",
+			" */",
+			`export const ${camel(type)}Record = defineRecordType({`,
+			`  type: ${q(type)},`,
+			"  blocks: {",
+			...blocks.map((block) => block.key === block.local ? `    ${block.key},` : `    ${block.key}: ${block.local},`),
+			"  },",
+			"  config: blockConfig,",
+			...extras.permissions ? ["  permissions,"] : [],
+			...extras.access === void 0 ? [] : ["  access: permissionsBlock,"],
+			"});",
+			""
+		].join("\n")
+	};
+}
+/**
+* `records/` next to the main module: one `records/<type>.ts` per record type
+* that an installed block binds to, and an index. Record types the binding
+* blocks and the blocks they require register themselves (a comment's message,
+* an attachment) get none. Empty with `recordTypes: false`.
+*/
+function emitRecords(config) {
+	if (!config.recordTypes || config.blockNames.length === 0) return [];
+	const blocks = bindingBlocks(config);
+	if (blocks.length === 0) return [];
+	const served = new Map(blocks.map((block) => [block.name, servedSubjects(config, block.name)]));
+	const access = PRESET_CATALOG.manifests.find((manifest) => manifest.name === "permissions")?.client;
+	const extras = {
+		access: new Set(generatorBlocks(config).map((block) => block.name)).has("permissions") ? access?.subpath : void 0,
+		permissions: hasPermissionConstants(config)
+	};
+	const dir = posix.join(posix.dirname(config.output), "records");
+	const files = [];
+	const types = [];
+	const inner = new Set(withRequired(blocks.map((block) => block.name)).flatMap((name) => blockSubjectTypes(name, config.blocks)));
+	for (const type of Object.keys(config.subjects).toSorted()) {
+		if (inner.has(type)) continue;
+		const own = blocks.filter((block) => served.get(block.name)?.has(type));
+		if (own.length === 0) continue;
+		const path = posix.join(dir, `${kebab(type)}.ts`);
+		files.push(recordFile(config, path, type, own, extras));
+		types.push([type, path]);
+	}
+	if (types.length === 0) return [];
+	const index = posix.join(dir, "index.ts");
+	files.push({
+		path: index,
+		contents: [
+			GENERATED_HEADER,
+			"",
+			...types.map(([type, path]) => `export { ${camel(type)}Record } from ${q(importPath(index, path))};`),
+			""
+		].join("\n")
+	});
+	return files;
+}
+//#endregion
+//#region src/cli/gen/render.ts
+/** The file the content mapper serves the schema types for. */
+const MAPPER_FILE = "schema.bsb";
+/** Where `schema.bsb` sits: next to the generated module. */
+function mapperFilePath(config) {
+	return join(dirname(config.output), MAPPER_FILE);
+}
+const MAPPER_FILE_CONTENTS = `// The better-supabase content mapper serves the schema types for this file.
+// Its contents are ignored. Run \`better-supabase gen\` after a config change.
+`;
+/**
+* Renders every generated file for a snapshot, without touching disk:
+* `database.types.ts` (what `supabase gen types` prints), the main module,
+* `blocks.generated.ts` when the config installs blocks, the record features in
+* `features/`, then each configured generator's files.
+*/
+async function renderFiles(config, snapshot, options = {}) {
+	return (await render(config, snapshot, options)).files;
+}
+/**
+* The module the content mapper serves for `schema.bsb`: the full generated
+* module with `database.types.ts` inlined, from the cache when the CLI and
+* typegen versions, the config (and `configText`, its file) and the snapshot
+* match the last render.
+*/
+async function renderTypesModule(config, snapshot, configText) {
+	return cachedTypesModule(config.root, config.output, typesModuleKey(config, configText, snapshot), async () => (await render(config, snapshot, { typesModule: true })).typesModule ?? "");
+}
+async function render(config, snapshot, options = {}) {
+	const model = buildModel(snapshot, config);
+	const runtime = options.runtimeImport ? { runtimeImport: options.runtimeImport } : {};
+	const output = resolve(config.root, config.output);
+	const typegenOptions = {
+		schemas: config.schemas,
+		postgrestVersion: config.postgrestVersion
+	};
+	const databaseTypes = await cachedDatabaseTypes(config.root, [
+		typegenOptions,
+		await oxfmtInstalled(),
+		snapshot.generator
+	], () => generateDatabaseTypes(snapshot.generator, typegenOptions));
+	const metaFiles = metaPaths(config.output);
+	const emitOptions = {
+		databaseTypesImport: importPath(output, resolve(config.root, config.databaseTypesOutput)),
+		importPathFor: (from) => importPath(output, resolve(config.root, from)),
+		metaImport: `./${basename(metaFiles.js)}`,
+		extensions: options.extensions === false ? [] : schemaExtensions(config),
+		...options.inlineMeta ? { inlineMeta: true } : {},
+		...runtime
+	};
+	const meta = emitMeta(model, {
+		types: `./${basename(metaFiles.dts)}`,
+		...runtime
+	});
+	const mapper = config.gen.contentMapper === true;
+	const files = [
+		{
+			path: config.output,
+			contents: ""
+		},
+		{
+			path: metaFiles.js,
+			contents: meta.js
+		},
+		{
+			path: metaFiles.dts,
+			contents: meta.dts
+		}
+	];
+	files.splice(mapper ? 1 : 0, 0, mapper ? {
+		path: mapperFilePath(config),
+		contents: MAPPER_FILE_CONTENTS
+	} : {
+		path: config.databaseTypesOutput,
+		contents: databaseTypes
+	});
+	const main = mapper ? 0 : 1;
+	const blockConfig = emitBlockConfig(config, runtime);
+	if (blockConfig) files.push(blockConfig);
+	files.push(...emitRecords(config));
+	const hooks = emitHooks(config, Object.keys(model.meta.tables), runtime);
+	if (hooks) files.push(hooks);
+	const owners = new Map(files.map((file) => [resolve(config.root, file.path), "gen"]));
+	let view;
+	for (const generator of config.generators) {
+		let extra;
+		try {
+			extra = await generator.generate({
+				meta: model.meta,
+				introspection: model.introspection,
+				extras: snapshot.extras,
+				config,
+				output,
+				importPath: (from, to) => importPath(resolve(config.root, from), resolve(config.root, to)),
+				model: view ??= generatorModel(model, generatorBlocks(config)),
+				...runtime
+			});
+		} catch (cause) {
+			throw new CliError("generator_failed", `generator "${generator.name}" failed: ${errorText(cause)}`, { cause });
+		}
+		for (const file of extra) {
+			const path = resolve(config.root, file.path);
+			const inside = relative(config.root, path);
+			if (inside === "" || inside.startsWith("..") || isAbsolute(inside)) throw new CliError("generator_failed", `generator "${generator.name}" wrote ${file.path}, which is outside the project root`);
+			const owner = owners.get(path);
+			if (owner !== void 0) throw new CliError("generator_failed", `generator "${generator.name}" wrote ${file.path}, which ${owner === "gen" ? "better-supabase gen writes" : `generator "${owner}" also writes`}`);
+			owners.set(path, generator.name);
+			files.push(file);
+		}
+	}
+	const validators = options.extensions === false ? void 0 : files.find((file) => file.validators === true);
+	const withValidators = {
+		...emitOptions,
+		...validators === void 0 ? {} : { validatorsImport: importPath(output, resolve(config.root, validators.path)) }
+	};
+	files[main] = {
+		path: config.output,
+		contents: mapper ? emitRuntime(model, {
+			...withValidators,
+			typesImport: `./${MAPPER_FILE}`
+		}) : emitModule(model, withValidators)
+	};
+	const typesModule = mapper || options.typesModule === true ? emitModule(model, {
+		...withValidators,
+		databaseTypes,
+		declareMeta: true
+	}) : void 0;
+	return {
+		files,
+		warnings: model.warnings,
+		notices: model.notices,
+		...typesModule === void 0 ? {} : { typesModule }
+	};
+}
+//#endregion
+export { emitBlockConfig as a, metaPaths as c, configFor as d, renderTypesModule as i, buildModel as l, render as n, GENERATED_HEADER as o, renderFiles as r, emitModule as s, mapperFilePath as t, notNullTag as u };