better-supabase 0.12.0 → 0.14.0

package/dist/config-Dn0cC3bM.js

@@ -0,0 +1,1093 @@
+import { r as CONFIG_DEFAULTS, t as resolveNames } from "./resolved-names-Dr7brlLL.js";
+import { c as PRESET_CATALOG, n as expandPreset } from "./config-Dh4D8lBa.js";
+import { t as DEFAULT_CLAIMS } from "./claims-Bp9My7XP.js";
+import { o as tenantNames } from "./entity-naming-DLDhHTbK.js";
+import { A as tenantNameOf, d as appTablesOf, f as withAppTableSubjects, k as resolveModule } from "./app-tables-C5aoI5rZ.js";
+import { C as variantsFor, S as variantTitle, _ as schemaName, a as extraSchemas, b as tableEntries, c as resultType, d as fieldSpec, f as fieldsFor, g as rowType, h as propertyKey, i as extraKinds, l as HEADER, m as parseImport, o as fieldMetaLines, p as optionalLine, s as objectType, u as fieldDocs, v as siblingPath, x as temporalGuardImport, y as tableDocs } from "./json-schema-DWDTfD8J.js";
+//#region src/config/authorization.ts
+/**
+* The error for a provider built for another API version, or `undefined` for
+* version 1.
+*/
+function providerApiProblem(provider) {
+	const version = provider.apiVersion;
+	if (version === 1) return;
+	return `authorization "${typeof provider.name === "string" ? provider.name : "provider"}" targets authorization provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`;
+}
+//#endregion
+//#region src/config/block-subjects.ts
+const CATALOG = new Map(PRESET_CATALOG.blocks.map((block) => [block.name, block]));
+/** `names` and every block they require, from the catalog, in order. */
+function withRequired(names) {
+	const found = /* @__PURE__ */ new Set();
+	const add = (name) => {
+		if (found.has(name)) return;
+		found.add(name);
+		for (const required of CATALOG.get(name)?.requires ?? []) add(required);
+	};
+	for (const name of names) add(name);
+	return [...found];
+}
+const PLACEHOLDER = /\{([^{}]*)\}/g;
+/** One installed module's names under `blocks`, from the catalog. */
+function catalogNames(module) {
+	const entities = CATALOG.get(module)?.entities;
+	return entities === void 0 ? void 0 : {
+		tables: entities.tables,
+		entities: entities.specs
+	};
+}
+/**
+* The entities `blocks.<module>.entities` gives a new name, such as `work_item`
+* to `task`, for the block's TypeScript client (`blocks.generated.ts`). Empty
+* when the module renames none.
+*/
+function blockEntityRenames(module, blocks) {
+	const names = catalogNames(module);
+	if (names === void 0) return [];
+	return Object.values(resolveNames(module, names, blocks).entities).filter((entity) => !entity.global && (entity.to.singular !== entity.from.singular || entity.to.plural !== entity.from.plural)).map((entity) => ({
+		from: entity.from,
+		to: entity.to
+	}));
+}
+/** The entities one installed block declares, with their final names. */
+function blockEntities(module, blocks) {
+	const names = catalogNames(module);
+	if (names === void 0) return [];
+	const resolved = resolveNames(module, names, blocks);
+	const mapped = resolveModule(blocks[module]).tables;
+	return Object.values(resolved.entities).map((entity) => {
+		const logical = entity.table;
+		const spec = logical === void 0 ? void 0 : names.tables[logical];
+		const target = logical === void 0 ? void 0 : mapped[logical];
+		const table = spec === void 0 || target === null ? void 0 : target ?? resolved.naming.rename(spec.name);
+		return {
+			key: entity.key,
+			from: entity.from,
+			to: entity.to,
+			primary: entity.primary,
+			table,
+			url: entity.url
+		};
+	});
+}
+/** The subjects one installed block registers, keyed by renamed entity. */
+function subjectsOf(module, blocks) {
+	const entities = CATALOG.get(module)?.entities;
+	const names = catalogNames(module);
+	const config = resolveModule(blocks[module]);
+	if (entities === void 0 || names === void 0 || config.mode === "custom") return {};
+	const resolved = resolveNames(module, names, blocks);
+	const key = (action) => config.permissions[action] ?? resolved.entityNaming.rename(entities.keys[action] ?? `${module}.${action}`);
+	return Object.fromEntries(Object.values(resolved.entities).flatMap((entity) => {
+		const subject = entity.subject;
+		const table = entity.table === void 0 ? void 0 : names.tables[entity.table];
+		const mapped = entity.table === void 0 ? void 0 : config.tables[entity.table];
+		if (subject === void 0 || entity.table === void 0 || table === void 0 || mapped === null) return [];
+		const logical = entity.table;
+		const column = (name) => config.columns[logical]?.[name] ?? resolved.naming.rename(table.columns[name] ?? name);
+		const name = mapped ?? resolved.naming.rename(table.name);
+		const url = entity.url ?? subject.url;
+		const entry = {
+			table: name.includes(".") ? name : `${config.schema}.${name}`,
+			idType: "uuid",
+			tenant: column("tenant"),
+			title: column(subject.title),
+			permissions: {
+				read: key(subject.permissions.read),
+				write: key(subject.permissions.write),
+				...subject.permissions.upload === void 0 ? {} : { upload: key(subject.permissions.upload) }
+			},
+			...subject.deletedAt === void 0 ? {} : { deletedAt: column(subject.deletedAt) },
+			...subject.rank === void 0 ? {} : { rank: {
+				column: column(subject.rank.column),
+				group: column(subject.rank.group)
+			} },
+			...subject.search === void 0 ? {} : { search: {
+				title: column(subject.search.title),
+				body: subject.search.body.map(column)
+			} },
+			...url === void 0 ? {} : { url: url.replaceAll(PLACEHOLDER, (_, placeholder) => `{${column(placeholder)}}`) },
+			...subject.cascade === true ? { cascade: true } : {}
+		};
+		return [[entity.to.singular, entry]];
+	}));
+}
+/**
+* The entities of every installed block that registers one (work items, deals,
+* companies and people, products, employees), under their renamed type, then
+* `subjects`. Throws when `subjects` already has a block's type.
+*/
+/** The subject types one installed block registers, by renamed entity. */
+function blockSubjectTypes(module, blocks) {
+	return Object.keys(subjectsOf(module, blocks));
+}
+function withBlockSubjects(subjects, blockNames, blocks) {
+	const merged = {};
+	for (const module of withRequired(blockNames)) for (const [type, entry] of Object.entries(subjectsOf(module, blocks))) {
+		if (Object.hasOwn(subjects, type)) throw new TypeError(`subjects.${type}: the ${module} block registers "${type}" itself; remove subjects.${type}, or set blocks.${module}.entities.<entity>.subject to false to keep your own`);
+		merged[type] = entry;
+	}
+	return {
+		...merged,
+		...subjects
+	};
+}
+//#endregion
+//#region src/config/expose.ts
+const ALL_PRIVILEGES = [
+	"select",
+	"insert",
+	"update",
+	"delete"
+];
+const isFunctionKey = (key) => key.endsWith(")");
+const EXPOSE_PRIVILEGE = /^(?:select|insert|update|delete|(?:select|insert|update)\s*\(\s*(?:[a-z_][a-z0-9_$]*(?:\s*,\s*[a-z_][a-z0-9_$]*)*|\*(?:\s*,\s*-\s*[a-z_][a-z0-9_$]*)*)\s*\))$/;
+function checkedPrivileges(key, privileges) {
+	for (const privilege of privileges) {
+		const value = privilege;
+		if (typeof value !== "string" || !EXPOSE_PRIVILEGE.test(value)) throw new TypeError(`expose.${key}: "${String(value)}" is not a privilege. Use select, insert, update or delete, name columns such as "update(title, body)", or exclude them from every column with "select(*, -secret)"`);
+	}
+	return privileges;
+}
+function resolveExpose(key, entry) {
+	if (Array.isArray(entry)) return {
+		anon: [],
+		authenticated: checkedPrivileges(key, entry),
+		serviceRole: ALL_PRIVILEGES
+	};
+	if ("execute" in entry) throw new TypeError(`expose.${key}: \`execute\` is for functions; key it by its signature, such as ${key}(text)`);
+	const roles = entry;
+	return {
+		anon: checkedPrivileges(key, roles.anon ?? []),
+		authenticated: checkedPrivileges(key, roles.authenticated ?? []),
+		serviceRole: checkedPrivileges(key, roles.serviceRole ?? ALL_PRIVILEGES)
+	};
+}
+function resolveExposeFunction(key, entry) {
+	if (Array.isArray(entry) || !("execute" in entry)) throw new TypeError(`expose.${key}: a function takes { execute: ["authenticated"] }, not table privileges`);
+	return [...entry.execute, ...entry.serviceRole === false ? [] : ["service_role"]];
+}
+//#endregion
+//#region src/config/resolve.ts
+function entitlementsOf(config = {}, provider) {
+	const customer = config.customer;
+	const dot = customer?.lastIndexOf(".") ?? -1;
+	if (customer !== void 0 && dot <= 0) throw new TypeError(`entitlements.customer must be "table.column", got "${customer}"`);
+	return {
+		...customer === void 0 ? {} : {
+			table: customer.slice(0, dot),
+			column: customer.slice(dot + 1)
+		},
+		key: config.key ?? "id",
+		memberships: config.memberships ?? (provider ? "provider" : "tenant"),
+		source: config.source ?? "stripe-sync",
+		...config.claim === void 0 ? {} : { claim: config.claim }
+	};
+}
+function vectorSearchOf(config = {}) {
+	return Object.entries(config).map(([table, entry]) => typeof entry === "string" ? {
+		table,
+		column: entry,
+		distance: "cosine"
+	} : {
+		table,
+		column: entry.column,
+		distance: entry.distance ?? "cosine",
+		...entry.type === void 0 ? {} : { type: entry.type },
+		...entry.key === void 0 ? {} : { key: entry.key },
+		...entry.hybrid === void 0 ? {} : { hybrid: entry.hybrid },
+		...entry.boost === void 0 ? {} : { boost: entry.boost },
+		...entry.prefilter === void 0 ? {} : { prefilter: entry.prefilter },
+		...entry.predicate === void 0 ? {} : { predicate: entry.predicate },
+		...entry.boostMode === void 0 ? {} : { boostMode: entry.boostMode },
+		...entry.order === void 0 ? {} : { order: entry.order }
+	});
+}
+/**
+* With `authorization` set, the `access` module's model defaults to `provider`,
+* so `can`, `tenant_ids_with` and every module check answer from the provider's
+* templates instead of the built-in roles.
+*/
+function blocksOf(blocks, sql = {}, provider) {
+	const config = blocks ?? [];
+	const blockNames = isBlockList(config) ? config : Object.keys(config);
+	const resolved = withSqlDefaults(isBlockList(config) ? {} : config, blockNames, sql);
+	if (!provider || !blockNames.includes("access") || resolved.access?.model !== void 0) return {
+		blocks: resolved,
+		blockNames
+	};
+	return {
+		blocks: {
+			...resolved,
+			access: {
+				...resolved.access,
+				model: "provider"
+			}
+		},
+		blockNames
+	};
+}
+/**
+* `sql.schema` and `sql.api` on every block that leaves its own unset. A
+* block's `api: false` keeps it out of the API schema.
+*/
+function withSqlDefaults(modules, names, sql) {
+	if (sql.schema === void 0 && sql.api === void 0) return modules;
+	const { schema, api } = sql;
+	return Object.fromEntries(names.map((name) => {
+		const module = modules[name] ?? {};
+		return [name, {
+			...module,
+			...schema === void 0 || module.schema !== void 0 ? {} : { schema },
+			...api === void 0 || module.api !== void 0 ? {} : { api }
+		}];
+	}));
+}
+function isBlockList(config) {
+	return Array.isArray(config);
+}
+const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/**
+* Types `better-supabase.config.ts` and returns it with its literal types. With
+* `preset`, it expands the preset into `blocks` and its conventions first, and
+* the keys you set win. It checks the references between keys against the
+* config itself: block tables and app tables in `appTables` references, the
+* `buckets` in `storagePaths`, and the `blocks.access.roles` other blocks
+* name.
+*/
+function defineConfig(config) {
+	return expandPreset(config);
+}
+function pick(value, defaults) {
+	if (value === void 0 || value === false) return;
+	if (value === true) return defaults;
+	return {
+		...defaults,
+		...value
+	};
+}
+function generatorsOf(generators) {
+	for (const generator of generators ?? []) {
+		const version = generator.apiVersion;
+		if (version !== void 0 && version !== 1) throw new TypeError(`generator "${generator.name}" targets generator API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the generator for API 1.`);
+	}
+	return generators ?? [];
+}
+function authorizationOf(provider) {
+	const problem = providerApiProblem(provider);
+	if (problem !== void 0) throw new TypeError(problem);
+	return provider;
+}
+/** Applies defaults. Paths stay relative to `root`. */
+function resolveConfig(input, root) {
+	const config = expandPreset(input);
+	const output = config.output ?? CONFIG_DEFAULTS.output;
+	const legacyOpenApi = config.openapi;
+	const tenantName = tenantNameOf(config.blocks);
+	const appTables = appTablesOf(config.appTables, tenantName);
+	const blocks = blocksOf(config.blocks, config.sql, config.authorization !== void 0);
+	return {
+		root,
+		source: config.source ?? {},
+		schemas: config.schemas ?? CONFIG_DEFAULTS.schemas,
+		casing: config.casing ?? CONFIG_DEFAULTS.casing,
+		tables: config.tables ?? {},
+		output,
+		databaseTypesOutput: output.replace(/[^/]+$/, "database.types.ts"),
+		postgrestVersion: config.postgrestVersion ?? CONFIG_DEFAULTS.postgrestVersion,
+		generateFeatures: config.generateFeatures ?? true,
+		json: config.json ?? {},
+		codecs: {
+			timestamptz: config.codecs?.timestamptz ?? CONFIG_DEFAULTS.codecs.timestamptz,
+			int8: config.codecs?.int8 ?? CONFIG_DEFAULTS.codecs.int8,
+			numeric: config.codecs?.numeric ?? CONFIG_DEFAULTS.codecs.numeric
+		},
+		relations: { nullableUnderRls: config.relations?.nullableUnderRls ?? false },
+		sensitive: config.sensitive ?? [],
+		storagePaths: config.storagePaths ?? {},
+		functions: config.functions ?? {},
+		expose: Object.fromEntries(Object.entries(config.expose ?? {}).filter(([key]) => !isFunctionKey(key)).map(([table, entry]) => [table, resolveExpose(table, entry)])),
+		exposeFunctions: Object.fromEntries(Object.entries(config.expose ?? {}).filter(([key]) => isFunctionKey(key)).map(([fn, entry]) => [fn, resolveExposeFunction(fn, entry)])),
+		readSets: config.readSets ?? [],
+		generators: generatorsOf(config.generators),
+		plugins: {
+			timestamps: pick(config.plugins?.timestamps, {
+				createdAt: "created_at",
+				updatedAt: "updated_at"
+			}),
+			softDelete: pick(config.plugins?.softDelete, { column: "deleted_at" }),
+			tenant: pick(config.plugins?.tenant, { column: tenantNames(tenantName).rename("organization_id") }),
+			actor: pick(config.plugins?.actor, {
+				createdBy: "created_by",
+				updatedBy: "updated_by",
+				impersonatedBy: "impersonated_by"
+			})
+		},
+		claims: {
+			...DEFAULT_CLAIMS,
+			...config.claims
+		},
+		buckets: config.buckets ?? {},
+		topics: config.topics ?? {},
+		realtime: {
+			tables: config.realtime?.tables ?? [],
+			global: config.realtime?.global ?? [],
+			users: config.realtime?.users ?? {},
+			triggers: config.realtime?.triggers ?? [],
+			...config.realtime?.policies === void 0 ? {} : { policies: config.realtime.policies }
+		},
+		entitlements: entitlementsOf(config.entitlements, config.authorization !== void 0),
+		...config.authorization === void 0 ? {} : { authorization: authorizationOf(config.authorization) },
+		vectorSearch: vectorSearchOf(config.vectorSearch),
+		subjects: withBlockSubjects(withAppTableSubjects(config.subjects ?? {}, appTables, config.sql?.scope, tenantName), blocks.blockNames, blocks.blocks),
+		sql: {
+			...config.sql?.workflow === void 0 ? {} : { workflow: config.sql.workflow },
+			dir: config.sql?.dir ?? CONFIG_DEFAULTS.sql.dir,
+			prefix: config.sql?.prefix ?? CONFIG_DEFAULTS.sql.prefix,
+			testsDir: config.sql?.testsDir ?? CONFIG_DEFAULTS.sql.testsDir,
+			...config.sql?.scope === void 0 ? {} : { scope: config.sql.scope }
+		},
+		...config.preset === void 0 ? {} : { preset: config.preset },
+		...blocks,
+		appTables,
+		seed: {
+			entry: config.seed?.entry ?? CONFIG_DEFAULTS.seed.entry,
+			output: config.seed?.output ?? CONFIG_DEFAULTS.seed.output,
+			perTenant: config.seed?.perTenant ?? CONFIG_DEFAULTS.seed.perTenant
+		},
+		openapi: {
+			entry: legacyOpenApi?.entry ?? CONFIG_DEFAULTS.openapi.entry,
+			output: legacyOpenApi?.output ?? CONFIG_DEFAULTS.openapi.output
+		},
+		specs: {
+			entry: config.specs?.entry ?? legacyOpenApi?.entry ?? CONFIG_DEFAULTS.openapi.entry,
+			outputs: config.specs?.outputs ?? [{
+				format: "openapi",
+				output: legacyOpenApi?.output ?? CONFIG_DEFAULTS.openapi.output
+			}],
+			failOn: config.specs?.failOn ?? CONFIG_DEFAULTS.specs.failOn,
+			...config.specs?.manifest === void 0 ? {} : { manifest: config.specs.manifest }
+		},
+		doctor: {
+			ignore: config.doctor?.ignore ?? [],
+			only: config.doctor?.only ?? [],
+			strict: config.doctor?.strict ?? false,
+			format: config.doctor?.format ?? CONFIG_DEFAULTS.doctor.format,
+			sources: config.doctor?.sources ?? CONFIG_DEFAULTS.doctor.sources,
+			policyHelperLimit: config.doctor?.policyHelperLimit ?? CONFIG_DEFAULTS.doctor.policyHelperLimit,
+			...config.doctor?.output === void 0 ? {} : { output: config.doctor.output },
+			...config.doctor?.claimsLimit === void 0 ? {} : { claimsLimit: config.doctor.claimsLimit },
+			...config.doctor?.migrationSafety === void 0 ? {} : { migrationSafety: config.doctor.migrationSafety }
+		},
+		gen: {
+			...config.gen,
+			watchInterval: config.gen?.watchInterval ?? CONFIG_DEFAULTS.gen.watchInterval
+		},
+		env: {
+			output: config.env?.output ?? CONFIG_DEFAULTS.env.output,
+			...config.env?.prefix === void 0 ? {} : { prefix: config.env.prefix }
+		},
+		scaffold: config.scaffold ?? {},
+		integrations: config.integrations ?? [],
+		skills: config.skills ?? {},
+		keys: config.keys ?? {}
+	};
+}
+//#endregion
+//#region src/generators/factories.ts
+const NUMBER = String.raw`(-?\d+(?:\.\d+)?)`;
+/** The call number as the generated template literal interpolates it. */
+const N = ["$", "{String(n)}"].join("");
+function escape(name) {
+	return name.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function tighten(bounds, op, value) {
+	switch (op) {
+		case ">=":
+		case ">": {
+			const min = op === ">" ? value + 1 : value;
+			bounds.min = Math.max(bounds.min ?? min, min);
+			break;
+		}
+		case "<=":
+		case "<": {
+			const max = op === "<" ? value - 1 : value;
+			bounds.max = Math.min(bounds.max ?? max, max);
+			break;
+		}
+	}
+}
+const FLIP = {
+	">=": "<=",
+	">": "<",
+	"<=": ">=",
+	"<": ">"
+};
+/** Numeric and length bounds a check constraint puts on `db`. */
+function checkBounds(db, checks) {
+	const name = String.raw`"?${escape(db)}"?`;
+	const bounds = {};
+	const lengths = {};
+	for (const check of checks) {
+		const length = new RegExp(String.raw`(?:char_length|length)\(\s*${name}(?:::\w+)?\s*\)\s*(>=|>|<=|<)\s*${NUMBER}`, "gi");
+		for (const [, op = "", value = ""] of check.matchAll(length)) tighten(lengths, op, Number(value));
+		const after = new RegExp(String.raw`(?<![\w.])${name}(?:::\w+)?\s*(>=|>|<=|<)\s*\(?\s*${NUMBER}`, "gi");
+		for (const [, op = "", value = ""] of check.matchAll(after)) tighten(bounds, op, Number(value));
+		const before = new RegExp(String.raw`${NUMBER}\s*\)?\s*(>=|>|<=|<)\s*${name}(?![\w(])`, "gi");
+		for (const [, value = "", op = ""] of check.matchAll(before)) tighten(bounds, FLIP[op] ?? op, Number(value));
+		const between = new RegExp(String.raw`${name}\s+between\s+${NUMBER}\s+and\s+${NUMBER}`, "gi");
+		for (const [, low = "", high = ""] of check.matchAll(between)) {
+			tighten(bounds, ">=", Number(low));
+			tighten(bounds, "<=", Number(high));
+		}
+	}
+	return {
+		...bounds,
+		...lengths.min === void 0 ? {} : { minLength: lengths.min },
+		...lengths.max === void 0 ? {} : { maxLength: lengths.max }
+	};
+}
+function numberValue(bounds) {
+	const { min, max } = bounds;
+	if (min !== void 0 && max !== void 0) return max <= min ? String(min) : `${String(min)} + ((n - 1) % ${String(max - min + 1)})`;
+	if (min !== void 0) return min === 1 ? "n" : `${String(min)} + n - 1`;
+	return max === void 0 ? "n" : `Math.min(${String(max)}, n)`;
+}
+function textValue(column, bounds) {
+	let value = `\`${column.db.replaceAll("_", "-")}-${N}\``;
+	if (bounds.minLength !== void 0 && bounds.minLength > column.db.length) value = `${value}.padEnd(${String(bounds.minLength)}, "x")`;
+	if (bounds.maxLength !== void 0) value = `${value}.slice(0, ${String(bounds.maxLength)})`;
+	return value;
+}
+const TEMPORAL = {
+	"Temporal.Instant": "factoryTime.instant()",
+	"Temporal.PlainDate": "factoryTime.plainDate()",
+	"Temporal.PlainDateTime": "factoryTime.plainDateTime()",
+	"Temporal.PlainTime": "factoryTime.plainTime()"
+};
+const STRING_FORMATS = {
+	uuid: `\`00000000-0000-4000-8000-${["$", "{String(n).padStart(12, \"0\")}"].join("")}\``,
+	date: "\"2026-01-01\"",
+	timestamptz: "\"2026-01-01T00:00:00Z\"",
+	timestamp: "\"2026-01-01T00:00:00\"",
+	time: "\"00:00:00\""
+};
+/** The default for one required column, or undefined when a call needs it. */
+function defaultValue(column, format, bounds) {
+	if (column.values !== void 0) return JSON.stringify(column.values[0]);
+	const bucket = /^StoragePath<"([^"]+)">$/.exec(column.tsType)?.[1];
+	if (bucket !== void 0) return `factoryPath(${JSON.stringify(bucket)}, \`${column.app}/${N}\`)`;
+	if (column.tsType.endsWith("[]")) return "[]";
+	if (column.json) return column.tsType === "Json" ? "{}" : void 0;
+	const temporal = TEMPORAL[column.tsType];
+	if (temporal !== void 0) return temporal;
+	switch (column.tsType) {
+		case "boolean": return "false";
+		case "bigint": return "BigInt(n)";
+		case "number": return numberValue(bounds);
+		case "string": {
+			const formatted = format === void 0 ? void 0 : STRING_FORMATS[format];
+			if (formatted !== void 0) return formatted;
+			return /email/i.test(column.app) ? `\`user${N}@example.com\`` : textValue(column, bounds);
+		}
+		default: return;
+	}
+}
+function sortByKey(a, b) {
+	return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+function camel(noun) {
+	return noun.replaceAll(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function planTable(table, input) {
+	const { introspection, extras, model } = input;
+	const checks = (extras.tables.find((entry) => entry.schema === table.schema && entry.name === table.name)?.checks ?? []).map((check) => check.definition);
+	const columns = introspection.columns.filter((entry) => entry.schema === table.schema && entry.table === table.name);
+	const refs = /* @__PURE__ */ new Map();
+	const relationships = introspection.relationships.filter((relationship) => relationship.schema === table.schema && relationship.relation === table.name).toSorted((a, b) => a.columns.length - b.columns.length);
+	for (const relationship of relationships) {
+		const parent = model.tables.find((entry) => entry.schema === relationship.referenced_schema && entry.name === relationship.referenced_relation);
+		for (const [index, db] of relationship.columns.entries()) {
+			const target = relationship.referenced_columns[index];
+			if (target === void 0 || refs.has(db)) continue;
+			refs.set(db, parent?.columns.find((column) => column.db === target)?.app ?? target);
+		}
+	}
+	return table.columns.filter((column) => !column.readonly).map((column) => {
+		const ref = refs.get(column.db);
+		const meta = columns.find((entry) => entry.name === column.db);
+		const own = meta?.check ? [meta.check] : [];
+		return {
+			column,
+			ref,
+			value: column.optional || ref !== void 0 ? void 0 : defaultValue(column, meta?.format, checkBounds(column.db, [...own, ...checks]))
+		};
+	});
+}
+function union$1(keys) {
+	return keys.length === 0 ? "never" : keys.map((key) => JSON.stringify(key)).join(" | ");
+}
+function tableLines$1(table, plan) {
+	const refs = plan.filter((entry) => entry.ref !== void 0);
+	const required = plan.filter((entry) => !entry.column.optional && entry.value === void 0);
+	const type = `Factory<InsertOf<${JSON.stringify(table.key)}>, ${union$1(refs.map((entry) => entry.column.app))}, ${union$1(required.map((entry) => entry.column.app))}>`;
+	const defaults = plan.flatMap((entry) => entry.value === void 0 ? [] : [`${JSON.stringify(entry.column.app)}: ${entry.value}`]);
+	const refMap = refs.map((entry) => `${JSON.stringify(entry.column.app)}: ${JSON.stringify(entry.ref)}`);
+	const uses = defaults.some((line) => /\bn\b/.test(line));
+	const object = (items) => items.length === 0 ? "{}" : `{ ${items.join(", ")} }`;
+	return {
+		type,
+		value: `defineFactory<InsertOf<${JSON.stringify(table.key)}>, ${union$1(refs.map((entry) => entry.column.app))}, ${union$1(required.map((entry) => entry.column.app))}>((${uses ? "n" : "_n"}) => (${object(defaults)}), ${object(refMap)})`
+	};
+}
+/**
+* Test factories, one per table: `factories.customers({ name })` returns an
+* insert row with valid defaults for the required columns. Defaults respect
+* enums, check-constraint bounds and `StoragePath` buckets. A foreign key takes
+* the parent row or its id, and a column without a safe default is a required
+* input. Block entities also get a factory under their singular noun
+* (`factories.task`). The file imports `better-supabase/testing`.
+*/
+function factories(options = {}) {
+	return {
+		apiVersion: 1,
+		name: "factories",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "factories.ts");
+			const wanted = options.tables === void 0 ? void 0 : new Set(options.tables);
+			const tables = input.model.tables.filter((table) => (wanted === void 0 || wanted.has(table.key)) && input.introspection.tables.some((entry) => entry.schema === table.schema && entry.name === table.name)).toSorted(sortByKey);
+			const missing = [...wanted ?? []].filter((key) => !tables.some((table) => table.key === key));
+			if (missing.length > 0) throw new Error(`factories(): no table named ${missing.map((key) => `"${key}"`).join(", ")}`);
+			const lines = tables.map((table) => ({
+				key: table.key,
+				plan: planTable(table, input),
+				table
+			})).map(({ key, plan, table }) => ({
+				key,
+				...tableLines$1(table, plan)
+			}));
+			const aliases = input.model.blocks.flatMap((block) => block.entities.flatMap((entity) => {
+				const key = camel(entity.to.singular);
+				const table = tables.find((entry) => entry.schema === block.schema && entry.name === entity.table);
+				return table === void 0 || table.key === key || tables.some((entry) => entry.key === key) ? [] : [{
+					key,
+					target: table.key
+				}];
+			}));
+			const runtime = options.testingImport ?? `${input.runtimeImport ?? "better-supabase"}/testing`;
+			const usesPath = lines.some((line) => line.value.includes("factoryPath("));
+			const usesTime = lines.some((line) => line.value.includes("factoryTime."));
+			const local = (key) => `${key}Factory`;
+			const members = [...lines.map((line) => ({
+				key: line.key,
+				target: line.key
+			})), ...aliases].toSorted((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+			return [{
+				path,
+				contents: [
+					HEADER,
+					`import type { Factory } from ${JSON.stringify(runtime)};`,
+					`import { ${[
+						"defineFactory",
+						...usesPath ? ["factoryPath"] : [],
+						...usesTime ? ["factoryTime"] : []
+					].join(", ")} } from ${JSON.stringify(runtime)};`,
+					"",
+					`import type { InsertOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`,
+					...lines.flatMap((line) => ["", `const ${local(line.key)}: ${line.type} = ${line.value};`]),
+					"",
+					"/**",
+					" * Insert rows with valid defaults, one factory per table and one per block",
+					" * entity under the name the config gives it.",
+					" */",
+					"export const factories: {",
+					...members.map(({ key, target }) => `  readonly ${key}: typeof ${local(target)};`),
+					"} = {",
+					...members.map(({ key, target }) => `  ${key}: ${local(target)},`),
+					"};",
+					""
+				].join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/generators/nuqs.ts
+/**
+* The list params every table gets; a column with one of these names is left
+* out.
+*/
+const LIST_PARAMS = /* @__PURE__ */ new Set([
+	"cursor",
+	"direction",
+	"limit",
+	"orderBy"
+]);
+const SORTABLE = /* @__PURE__ */ new Set([
+	"bigint",
+	"boolean",
+	"number",
+	"string"
+]);
+function sortable(column) {
+	return !column.json && (column.values !== void 0 || SORTABLE.has(column.tsType) || column.tsType.startsWith("Temporal."));
+}
+function pascal(key) {
+	return key.replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function literal(values) {
+	return `[${values.map((value) => JSON.stringify(value)).join(", ")}] as const`;
+}
+function union(values) {
+	return values.map((value) => JSON.stringify(value)).join(" | ");
+}
+function tableLines(table, limit) {
+	const name = `${table.key.replace(/^[A-Z]/, (c) => c.toLowerCase())}SearchParams`;
+	const params = [];
+	for (const column of table.columns) {
+		if (column.values === void 0 || LIST_PARAMS.has(column.app)) continue;
+		params.push([
+			column.app,
+			`SingleParserBuilder<${union(column.values)}>`,
+			`parseAsStringLiteral(${literal(column.values)})`
+		]);
+	}
+	const orderBy = table.columns.filter(sortable).map((column) => column.app);
+	if (orderBy.length > 0) params.push([
+		"orderBy",
+		`SingleParserBuilder<${union(orderBy)}>`,
+		`parseAsStringLiteral(${literal(orderBy)})`
+	]);
+	params.push([
+		"direction",
+		"SingleParserBuilder<\"asc\" | \"desc\"> & { readonly defaultValue: \"asc\" | \"desc\" }",
+		`parseAsStringLiteral(${literal(["asc", "desc"])}).withDefault("asc")`
+	], [
+		"cursor",
+		"SingleParserBuilder<string>",
+		"parseAsString"
+	], [
+		"limit",
+		"SingleParserBuilder<number> & { readonly defaultValue: number }",
+		`parseAsInteger.withDefault(${String(limit)})`
+	]);
+	const map = `typeof ${name}`;
+	return [
+		"",
+		`/** Search params for a list of \`${table.key}\`: filters, order, cursor and page size. */`,
+		`export const ${name}: {`,
+		...params.map(([key, type]) => `  readonly ${key}: ${type};`),
+		"} = {",
+		...params.map(([key, , value]) => `  ${key}: ${value},`),
+		"};",
+		"",
+		`/** Reads \`${name}\` once per request in Server Components. */`,
+		`export const ${name}Cache: ReturnType<typeof createSearchParamsCache<${map}>> = createSearchParamsCache(${name});`,
+		"",
+		`/** Parses \`${name}\` from a URL, a \`Request\` or \`searchParams\`. */`,
+		`export const load${pascal(name)}: LoaderFunction<${map}> = createLoader(${name});`,
+		"",
+		`/** Writes \`${name}\` into a URL, for links. */`,
+		`export const serialize${pascal(name)}: ReturnType<typeof createSerializer<${map}>> = createSerializer(${name});`
+	];
+}
+/**
+* Search-param parsers for nuqs, one set per table list: a filter for every
+* column with a closed set of values, `orderBy` over the sortable columns,
+* `direction`, `cursor` and `limit`, with a cache, a loader and a serializer.
+* The file imports `nuqs/server`, which the app installs.
+*/
+function nuqs(options = {}) {
+	return {
+		apiVersion: 1,
+		name: "nuqs",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "nuqs.ts");
+			const wanted = options.tables === void 0 ? void 0 : new Set(options.tables);
+			const tables = input.model.tables.filter((table) => wanted === void 0 || wanted.has(table.key)).toSorted((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+			const missing = [...wanted ?? []].filter((key) => !tables.some((table) => table.key === key));
+			if (missing.length > 0) throw new Error(`nuqs(): no table named ${missing.map((key) => `"${key}"`).join(", ")}`);
+			return [{
+				path,
+				contents: [
+					HEADER,
+					"import type { LoaderFunction, SingleParserBuilder } from \"nuqs/server\";",
+					"import { createLoader, createSearchParamsCache, createSerializer, parseAsInteger, parseAsString, parseAsStringLiteral } from \"nuqs/server\";",
+					...tables.flatMap((table) => tableLines(table, options.limit ?? 25)),
+					""
+				].join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/generators/standard-schema.ts
+/**
+* Standard Schemas for every table's Row, Insert and Update shape, with no
+* validation library. Each one also converts to JSON Schema (Standard JSON
+* Schema), and `validators` plugs into the validation plugin.
+*/
+function standardSchema(options = {}) {
+	return {
+		apiVersion: 1,
+		name: "standard-schema",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "standard.ts");
+			const imports = /* @__PURE__ */ new Map();
+			const jsonImports = /* @__PURE__ */ new Map();
+			const tableNames = new Map(Object.values(input.meta.tables).map((t) => [t.name, t.key]));
+			for (const [key, spec] of Object.entries(options.json ?? {})) {
+				const [tableName, column] = key.split(".");
+				const { from, name } = parseImport(spec);
+				const specifier = from.startsWith(".") ? input.importPath(path, from) : from;
+				imports.set(specifier, [...imports.get(specifier) ?? [], name]);
+				jsonImports.set(`${tableNames.get(tableName ?? "") ?? tableName}.${column}`, name);
+			}
+			const extras = extraSchemas(input);
+			const usesJson = extras.inputs.some((schema) => Object.values(schema.fields).some((field) => field.kind === "json"));
+			const lines = [
+				HEADER,
+				`import { type TableSchema, tableSchema } from ${JSON.stringify(input.runtimeImport ?? "better-supabase")};`,
+				"",
+				`import type { InsertOf, ${usesJson ? "Json, " : ""}RowOf, UpdateOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`
+			];
+			for (const [from, names] of imports) lines.push(`import { ${[...new Set(names)].toSorted().join(", ")} } from ${JSON.stringify(from)};`);
+			const validators = [];
+			const validatorTypes = [];
+			for (const [key, table] of tableEntries(input)) {
+				const variants = variantsFor(table);
+				const docs = tableDocs(input, table);
+				for (const variant of variants) {
+					lines.push("", `export const ${schemaName(key, variant)}: TableSchema<${variant}Of<'${key}'>> = tableSchema({`);
+					if (docs) {
+						lines.push(`  title: ${JSON.stringify(variantTitle(docs, variant))},`);
+						if (docs.description !== void 0) lines.push(`  description: ${JSON.stringify(docs.description)},`);
+					}
+					lines.push("  fields: {");
+					for (const plan of fieldsFor(table, variant, input)) {
+						const imported = jsonImports.get(`${key}.${plan.column.db}`);
+						const entries = Object.entries(fieldSpec(plan, fieldDocs(docs, plan))).map(([name, value]) => `${name}: ${JSON.stringify(value)}`);
+						if (imported) entries.push(`schema: ${imported}`);
+						lines.push(`    ${propertyKey(plan.name)}: { ${entries.join(", ")} },`);
+					}
+					lines.push("  },", "});");
+				}
+				if (variants.includes("Insert")) {
+					const insert = schemaName(key, "Insert");
+					const update = schemaName(key, "Update");
+					validators.push(`  ${propertyKey(key)}: { insert: ${insert}, update: ${update} },`);
+					validatorTypes.push(`  readonly ${propertyKey(key)}: { readonly insert: typeof ${insert}; readonly update: typeof ${update} };`);
+				}
+			}
+			lines.push("", "/** Write validators for the validation plugin. */", "export const validators: {", ...validatorTypes, "} = {", ...validators, "};");
+			for (const schema of extras.inputs) lines.push("", `export const ${schema.name}: TableSchema<${objectType(schema)}> = tableSchema({`, `  title: ${JSON.stringify(schema.title)},`, "  fields: {", ...Object.entries(schema.fields).map(([name, spec]) => `    ${propertyKey(name)}: ${JSON.stringify(spec)},`), "  },", "});");
+			lines.push(...options.fieldMeta ? fieldMetaLines(input, extras) : [], "");
+			return [{
+				path,
+				contents: lines.join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/generators/valibot.ts
+function scalar$1(kind) {
+	switch (kind.kind) {
+		case "uuid": return "v.pipe(v.string(), v.uuid())";
+		case "string": return "v.string()";
+		case "integer": return "v.pipe(v.number(), v.integer())";
+		case "number": return "v.number()";
+		case "boolean": return "v.boolean()";
+		case "datetime": return "v.pipe(v.string(), v.isoTimestamp())";
+		case "date": return "v.pipe(v.string(), v.isoDate())";
+		case "instant": return "v.custom<Temporal.Instant>(isInstant)";
+		case "plainDate": return "v.custom<Temporal.PlainDate>(isPlainDate)";
+		case "plainDateTime": return "v.custom<Temporal.PlainDateTime>(isPlainDateTime)";
+		case "bigint": return "v.bigint()";
+		case "json": return "json";
+		case "enum": return `v.picklist([${kind.values.map((value) => JSON.stringify(value)).join(", ")}])`;
+		case "unknown": return "v.unknown()";
+		default: return kind;
+	}
+}
+/** `expr` with `actions` appended, flattening an existing top-level `v.pipe`. */
+function piped(expr, actions) {
+	if (actions.length === 0) return expr;
+	return `v.pipe(${/^v\.pipe\((.*)\)$/s.exec(expr)?.[1] ?? expr}, ${actions.join(", ")})`;
+}
+function boundActions(docs) {
+	return [
+		docs.minimum === void 0 ? void 0 : `v.minValue(${docs.minimum})`,
+		docs.exclusiveMinimum === void 0 ? void 0 : `v.gtValue(${docs.exclusiveMinimum})`,
+		docs.maximum === void 0 ? void 0 : `v.maxValue(${docs.maximum})`,
+		docs.exclusiveMaximum === void 0 ? void 0 : `v.ltValue(${docs.exclusiveMaximum})`,
+		docs.minLength === void 0 ? void 0 : `v.minLength(${docs.minLength})`,
+		docs.maxLength === void 0 ? void 0 : `v.maxLength(${docs.maxLength})`
+	].filter((action) => action !== void 0);
+}
+function docActions(docs) {
+	return [...docs.description === void 0 ? [] : [`v.description(${JSON.stringify(docs.description)})`], ...docs.examples === void 0 ? [] : [`v.examples(${JSON.stringify(docs.examples)})`]];
+}
+function field$1(table, plan, jsonImports, docs) {
+	let expr = jsonImports.get(`${table}.${plan.column.db}`) ?? (plan.customJson ? `v.custom<NonNullable<RowOf<'${table}'>['${plan.name}']>>((value) => value !== undefined)` : plan.column.storage === void 0 ? piped(scalar$1(plan.scalar), boundActions(docs)) : `(v.string() as unknown as v.GenericSchema<${rowType(table, plan)}>)`);
+	if (plan.column.array) expr = `v.array(${expr})`;
+	if (plan.nullable) expr = `v.nullable(${expr})`;
+	expr = piped(expr, docActions(docs));
+	if (plan.optional) expr = `v.exactOptional(${expr})`;
+	return `  ${propertyKey(plan.name)}: ${expr},`;
+}
+function specExpr$1(spec) {
+	let expr = spec.kind === "custom" ? "v.unknown()" : piped(scalar$1(spec), boundActions(spec));
+	if (spec.array) expr = `v.array(${expr})`;
+	if (spec.nullable) expr = `v.nullable(${expr})`;
+	expr = piped(expr, docActions(spec));
+	return spec.optional ? `v.exactOptional(${expr})` : expr;
+}
+function resultExpr$1(result, rows) {
+	if (result.of.kind === "row") {
+		if (!rows.has(result.of.table)) return;
+		const row = schemaName(result.of.table, "Row");
+		return result.set ? `v.array(${row})` : `v.nullable(${row})`;
+	}
+	const item = scalar$1(result.of.scalar);
+	const element = result.nullable ? `v.nullable(${item})` : item;
+	return result.set ? `v.array(${element})` : element;
+}
+function extraLines$1(input, extras) {
+	const lines = [];
+	for (const schema of extras.inputs) {
+		lines.push("", `export const ${schema.name}: v.GenericSchema<${objectType(schema)}> = v.pipe(v.object({`);
+		for (const [name, spec] of Object.entries(schema.fields)) lines.push(`  ${propertyKey(name)}: ${specExpr$1(spec)},`);
+		lines.push(`}), v.title(${JSON.stringify(schema.title)}));`);
+	}
+	const rows = new Set(Object.keys(input.meta.tables));
+	for (const result of extras.results) {
+		const expr = resultExpr$1(result, rows);
+		if (expr !== void 0) lines.push("", `export const ${result.name}: v.GenericSchema<${resultType(result)}> = ${expr};`);
+	}
+	return lines;
+}
+/** Valibot schemas for every table's Row, Insert and Update shape. */
+function valibot(options = {}) {
+	return {
+		apiVersion: 1,
+		name: "valibot",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "valibot.ts");
+			const imports = /* @__PURE__ */ new Map();
+			const jsonImports = /* @__PURE__ */ new Map();
+			const tableNames = new Map(Object.values(input.meta.tables).map((t) => [t.name, t.key]));
+			for (const [key, spec] of Object.entries(options.json ?? {})) {
+				const [tableName, column] = key.split(".");
+				const { from, name } = parseImport(spec);
+				const specifier = from.startsWith(".") ? input.importPath(path, from) : from;
+				imports.set(specifier, [...imports.get(specifier) ?? [], name]);
+				jsonImports.set(`${tableNames.get(tableName ?? "") ?? tableName}.${column}`, name);
+			}
+			const extras = extraSchemas(input);
+			const lines = [
+				HEADER,
+				"import * as v from \"valibot\";",
+				...optionalLine(temporalGuardImport(input, extraKinds(extras))),
+				"",
+				`import type { InsertOf, Json, RowOf, UpdateOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`
+			];
+			for (const [from, names] of imports) lines.push(`import { ${[...new Set(names)].toSorted().join(", ")} } from ${JSON.stringify(from)};`);
+			lines.push("", "const json: v.GenericSchema<Json> = v.lazy(() =>", "  v.union([v.string(), v.number(), v.boolean(), v.null(), v.array(json), v.record(v.string(), v.optional(json))]),", ");");
+			const validators = [];
+			const validatorTypes = [];
+			for (const [key, table] of tableEntries(input)) {
+				lines.push("");
+				const variants = variantsFor(table);
+				const docs = tableDocs(input, table);
+				for (const variant of variants) {
+					const name = schemaName(key, variant);
+					const objectActions = docs ? [`v.title(${JSON.stringify(variantTitle(docs, variant))})`, ...docs.description === void 0 ? [] : [`v.description(${JSON.stringify(docs.description)})`]] : [];
+					lines.push(`export const ${name}: v.GenericSchema<${variant}Of<'${key}'>> = ${objectActions.length > 0 ? "v.pipe(" : ""}v.object({`);
+					for (const plan of fieldsFor(table, variant, input)) lines.push(field$1(key, plan, jsonImports, fieldDocs(docs, plan)));
+					lines.push(objectActions.length > 0 ? `}), ${objectActions.join(", ")});` : "});");
+				}
+				if (variants.includes("Insert")) {
+					const insert = schemaName(key, "Insert");
+					const update = schemaName(key, "Update");
+					validators.push(`  ${propertyKey(key)}: { insert: ${insert}, update: ${update} },`);
+					validatorTypes.push(`  readonly ${propertyKey(key)}: { readonly insert: typeof ${insert}; readonly update: typeof ${update} };`);
+				}
+			}
+			lines.push("", "/** Write validators for the validation plugin. */", "export const validators: {", ...validatorTypes, "} = {", ...validators, "};", ...extraLines$1(input, extras), ...options.fieldMeta ? fieldMetaLines(input, extras) : [], "");
+			return [{
+				path,
+				contents: lines.join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/generators/zod.ts
+function scalar(kind) {
+	switch (kind.kind) {
+		case "uuid": return "z.guid()";
+		case "string": return "z.string()";
+		case "integer": return "z.int()";
+		case "number": return "z.number()";
+		case "boolean": return "z.boolean()";
+		case "datetime": return "z.iso.datetime({ offset: true })";
+		case "date": return "z.iso.date()";
+		case "instant": return "z.custom<Temporal.Instant>(isInstant)";
+		case "plainDate": return "z.custom<Temporal.PlainDate>(isPlainDate)";
+		case "plainDateTime": return "z.custom<Temporal.PlainDateTime>(isPlainDateTime)";
+		case "bigint": return "z.bigint()";
+		case "json": return "z.json()";
+		case "enum": return `z.enum([${kind.values.map((value) => JSON.stringify(value)).join(", ")}])`;
+		case "unknown": return "z.unknown()";
+		default: return kind;
+	}
+}
+function bounds(docs, flavor) {
+	if (flavor === "mini") {
+		const checks = [
+			docs.minimum === void 0 ? "" : `z.gte(${docs.minimum})`,
+			docs.exclusiveMinimum === void 0 ? "" : `z.gt(${docs.exclusiveMinimum})`,
+			docs.maximum === void 0 ? "" : `z.lte(${docs.maximum})`,
+			docs.exclusiveMaximum === void 0 ? "" : `z.lt(${docs.exclusiveMaximum})`,
+			docs.minLength === void 0 ? "" : `z.minLength(${docs.minLength})`,
+			docs.maxLength === void 0 ? "" : `z.maxLength(${docs.maxLength})`
+		].filter((check) => check !== "");
+		return checks.length === 0 ? "" : `.check(${checks.join(", ")})`;
+	}
+	return [
+		docs.minimum === void 0 ? "" : `.min(${docs.minimum})`,
+		docs.exclusiveMinimum === void 0 ? "" : `.gt(${docs.exclusiveMinimum})`,
+		docs.maximum === void 0 ? "" : `.max(${docs.maximum})`,
+		docs.exclusiveMaximum === void 0 ? "" : `.lt(${docs.exclusiveMaximum})`,
+		docs.minLength === void 0 ? "" : `.min(${docs.minLength})`,
+		docs.maxLength === void 0 ? "" : `.max(${docs.maxLength})`
+	].join("");
+}
+/**
+* `.meta({ ... })` (`.check(z.meta({ ... }))` in mini) for the entries that are
+* set, or nothing.
+*/
+function meta(entries, flavor) {
+	const set = Object.entries(entries).filter(([, value]) => value !== void 0);
+	if (set.length === 0) return "";
+	const object = `{ ${set.map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ")} }`;
+	return flavor === "mini" ? `.check(z.meta(${object}))` : `.meta(${object})`;
+}
+function field(table, plan, jsonImports, docs, flavor) {
+	const expr = jsonImports.get(`${table}.${plan.column.db}`) ?? (plan.customJson ? `z.custom<NonNullable<RowOf<'${table}'>['${plan.name}']>>((value) => value !== undefined)` : plan.column.storage === void 0 ? `${scalar(plan.scalar)}${bounds(docs, flavor)}` : `(z.string() as unknown as ${typeName(flavor)}<${rowType(table, plan)}>)`);
+	return `  ${propertyKey(plan.name)}: ${wrap(expr, {
+		array: plan.column.array === true,
+		nullable: plan.nullable,
+		optional: plan.optional,
+		...docs
+	}, flavor)},`;
+}
+/** `expr` as an array, nullable, documented and optional, as `spec` says. */
+function wrap(expr, spec, flavor) {
+	const mini = flavor === "mini";
+	let out = spec.array ? `z.array(${expr})` : expr;
+	if (spec.nullable) out = mini ? `z.nullable(${out})` : `${out}.nullable()`;
+	out += meta({
+		description: spec.description,
+		examples: spec.examples
+	}, flavor);
+	if (spec.optional) out = mini ? `z.exactOptional(${out})` : `${out}.exactOptional()`;
+	return out;
+}
+function specExpr(spec, flavor) {
+	return wrap(spec.kind === "custom" ? "z.unknown()" : `${scalar(spec)}${bounds(spec, flavor)}`, spec, flavor);
+}
+function resultExpr(result, rows, flavor) {
+	const mini = flavor === "mini";
+	if (result.of.kind === "row") {
+		if (!rows.has(result.of.table)) return;
+		const row = schemaName(result.of.table, "Row");
+		if (result.set) return `z.array(${row})`;
+		return mini ? `z.nullable(${row})` : `${row}.nullable()`;
+	}
+	const item = scalar(result.of.scalar);
+	const nullable = mini ? `z.nullable(${item})` : `${item}.nullable()`;
+	if (result.set) return `z.array(${result.nullable ? nullable : item})`;
+	return result.nullable ? nullable : item;
+}
+function extraLines(input, extras, flavor) {
+	const lines = [];
+	for (const schema of extras.inputs) {
+		lines.push("", `export const ${schema.name}: ${typeName(flavor)}<${objectType(schema)}> = z.object({`);
+		for (const [name, spec] of Object.entries(schema.fields)) lines.push(`  ${propertyKey(name)}: ${specExpr(spec, flavor)},`);
+		lines.push(`})${meta({ title: schema.title }, flavor)};`);
+	}
+	const rows = new Set(Object.keys(input.meta.tables));
+	for (const result of extras.results) {
+		const expr = resultExpr(result, rows, flavor);
+		if (expr !== void 0) lines.push("", `export const ${result.name}: ${typeName(flavor)}<${resultType(result)}> = ${expr};`);
+	}
+	return lines;
+}
+function typeName(flavor) {
+	return flavor === "mini" ? "z.ZodMiniType" : "z.ZodType";
+}
+/**
+* Zod 4 schemas for every table's Row, Insert and Update shape, for `zod` or,
+* with `flavor: 'mini'`, `zod/mini`.
+*/
+function zod(options = {}) {
+	const flavor = options.flavor ?? "classic";
+	return {
+		apiVersion: 1,
+		name: "zod",
+		generate(input) {
+			const path = options.output ?? siblingPath(input.config.output, "zod.ts");
+			const imports = /* @__PURE__ */ new Map();
+			const jsonImports = /* @__PURE__ */ new Map();
+			const tableNames = new Map(Object.values(input.meta.tables).map((t) => [t.name, t.key]));
+			for (const [key, spec] of Object.entries(options.json ?? {})) {
+				const [tableName, column] = key.split(".");
+				const { from, name } = parseImport(spec);
+				const specifier = from.startsWith(".") ? input.importPath(path, from) : from;
+				imports.set(specifier, [...imports.get(specifier) ?? [], name]);
+				jsonImports.set(`${tableNames.get(tableName ?? "") ?? tableName}.${column}`, name);
+			}
+			const extras = extraSchemas(input);
+			const kinds = extraKinds(extras);
+			const lines = [
+				HEADER,
+				flavor === "mini" ? "import { z } from \"zod/mini\";" : "import { z } from \"zod\";",
+				...optionalLine(temporalGuardImport(input, kinds)),
+				"",
+				`import type { InsertOf, ${kinds.includes("json") ? "Json, " : ""}RowOf, UpdateOf } from ${JSON.stringify(input.importPath(path, input.config.output))};`
+			];
+			for (const [from, names] of imports) lines.push(`import { ${[...new Set(names)].toSorted().join(", ")} } from ${JSON.stringify(from)};`);
+			const validators = [];
+			for (const [key, table] of tableEntries(input)) {
+				lines.push("");
+				const variants = variantsFor(table);
+				const docs = tableDocs(input, table);
+				for (const variant of variants) {
+					const name = schemaName(key, variant);
+					lines.push(`export const ${name}: ${typeName(flavor)}<${variant}Of<'${key}'>> = z.object({`);
+					for (const plan of fieldsFor(table, variant, input)) lines.push(field(key, plan, jsonImports, fieldDocs(docs, plan), flavor));
+					lines.push(`})${docs ? meta({
+						title: variantTitle(docs, variant),
+						description: docs.description
+					}, flavor) : ""};`);
+				}
+				if (variants.includes("Insert")) validators.push(`  ${propertyKey(key)}: { insert: ${schemaName(key, "Insert")}, update: ${schemaName(key, "Update")} },`);
+			}
+			lines.push("", "/** Write validators for the validation plugin. */", "export const validators: {");
+			for (const [key, table] of tableEntries(input)) {
+				if (!variantsFor(table).includes("Insert")) continue;
+				lines.push(`  readonly ${propertyKey(key)}: { readonly insert: typeof ${schemaName(key, "Insert")}; readonly update: typeof ${schemaName(key, "Update")} };`);
+			}
+			lines.push("} = {", ...validators, "};", ...extraLines(input, extras, flavor), ...options.fieldMeta ? fieldMetaLines(input, extras) : [], "");
+			return [{
+				path,
+				contents: lines.join("\n")
+			}];
+		}
+	};
+}
+//#endregion
+export { factories as a, resolveConfig as c, blockSubjectTypes as d, providerApiProblem as f, nuqs as i, blockEntities as l, valibot as n, CONFIG_SCHEMA_URL as o, standardSchema as r, defineConfig as s, zod as t, blockEntityRenames as u };