kitcn 0.17.2 → 0.17.4

package/dist/local-env-DykABjCt.mjs

@@ -0,0 +1,4219 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path, { join } from "node:path";
+import { createHash } from "node:crypto";
+import { v } from "convex/values";
+import "convex/server";
+import { createColors } from "picocolors";
+
+//#region src/orm/builders/column-builder.ts
+/**
+* entityKind symbol for runtime type checking
+* Following Drizzle's pattern for type guards
+*/
+const entityKind = Symbol.for("kitcn:entityKind");
+/**
+* Base ColumnBuilder abstract class
+*
+* All column builders inherit from this class.
+* Implements chaining methods and stores runtime config.
+*/
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	[entityKind] = "ColumnBuilder";
+	/**
+	* Runtime configuration - actual mutable state
+	*/
+	config;
+	constructor(name, dataType, columnType) {
+		this.config = {
+			name,
+			notNull: false,
+			default: void 0,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: void 0,
+			uniqueNulls: void 0,
+			foreignKeyConfigs: [],
+			dataType,
+			columnType
+		};
+	}
+	/**
+	* Mark column as NOT NULL
+	* Returns type-branded instance with notNull: true
+	*/
+	notNull() {
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Override the TypeScript type for this column.
+	* Mirrors Drizzle's $type() (type-only, no runtime validation changes).
+	*/
+	$type() {
+		return this;
+	}
+	/**
+	* Set default value for column
+	* Makes field optional on insert
+	*/
+	default(value) {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Set default function for column (runtime evaluated on insert).
+	* Mirrors Drizzle's $defaultFn() / $default().
+	*/
+	$defaultFn(fn) {
+		this.config.defaultFn = fn;
+		return this;
+	}
+	/**
+	* Alias of $defaultFn for Drizzle parity.
+	*/
+	$default(fn) {
+		return this.$defaultFn(fn);
+	}
+	/**
+	* Set on-update function for column (runtime evaluated on update).
+	* Mirrors Drizzle's $onUpdateFn() / $onUpdate().
+	*/
+	$onUpdateFn(fn) {
+		this.config.onUpdateFn = fn;
+		return this;
+	}
+	/**
+	* Alias of $onUpdateFn for Drizzle parity.
+	*/
+	$onUpdate(fn) {
+		return this.$onUpdateFn(fn);
+	}
+	/**
+	* Mark column as primary key
+	* Implies NOT NULL
+	*/
+	primaryKey() {
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Mark column as UNIQUE
+	* Mirrors Drizzle column unique API
+	*/
+	unique(name, config) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		this.config.uniqueNulls = config?.nulls;
+		return this;
+	}
+	/**
+	* Define a foreign key reference
+	* Mirrors Drizzle column references() API
+	*/
+	references(ref, config = {}) {
+		this.config.foreignKeyConfigs.push({
+			ref,
+			config
+		});
+		return this;
+	}
+};
+
+//#endregion
+//#region src/orm/builders/system-fields.ts
+/**
+* System Fields - Convex-provided fields available on all documents
+*
+* id: Document ID (string, backed by internal Convex _id)
+* createdAt: Creation timestamp alias (backed by internal Convex _creationTime)
+*
+* These are automatically added to every Convex table.
+*/
+var ConvexSystemIdBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemIdBuilder";
+	[entityKind] = "ConvexSystemIdBuilder";
+	constructor() {
+		super("_id", "string", "ConvexSystemId");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.string();
+	}
+	/**
+	* Convex validator - runtime access
+	* System fields use v.string() for _id
+	*/
+	get convexValidator() {
+		return this.build();
+	}
+};
+var ConvexSystemCreationTimeBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemCreationTimeBuilder";
+	[entityKind] = "ConvexSystemCreationTimeBuilder";
+	constructor() {
+		super("_creationTime", "number", "ConvexSystemCreationTime");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.number();
+	}
+	/**
+	* Convex validator - runtime access
+	* System fields use v.number() for _creationTime
+	*/
+	get convexValidator() {
+		return this.build();
+	}
+};
+var ConvexSystemCreatedAtBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemCreatedAtBuilder";
+	[entityKind] = "ConvexSystemCreatedAtBuilder";
+	constructor() {
+		super("_creationTime", "number", "ConvexSystemCreatedAt");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.number();
+	}
+	get convexValidator() {
+		return this.build();
+	}
+};
+function createSystemFields(tableName) {
+	const id = new ConvexSystemIdBuilder();
+	const creationTime = new ConvexSystemCreationTimeBuilder();
+	const createdAt = new ConvexSystemCreatedAtBuilder();
+	id.config.tableName = tableName;
+	creationTime.config.tableName = tableName;
+	createdAt.config.tableName = tableName;
+	return {
+		id,
+		_creationTime: creationTime,
+		createdAt
+	};
+}
+
+//#endregion
+//#region src/orm/symbols.ts
+const TableName = Symbol.for("kitcn:TableName");
+const Columns = Symbol.for("kitcn:Columns");
+const Brand = Symbol.for("kitcn:Brand");
+const Relations = Symbol.for("kitcn:Relations");
+const OrmContext = Symbol.for("kitcn:OrmContext");
+const RlsPolicies = Symbol.for("kitcn:RlsPolicies");
+const EnableRLS = Symbol.for("kitcn:EnableRLS");
+const TableDeleteConfig = Symbol.for("kitcn:TableDeleteConfig");
+const TablePolymorphic = Symbol.for("kitcn:TablePolymorphic");
+const OrmSchemaOptions = Symbol.for("kitcn:OrmSchemaOptions");
+const OrmSchemaDefinition = Symbol.for("kitcn:OrmSchemaDefinition");
+const OrmSchemaExtensionTables = Symbol.for("kitcn:OrmSchemaExtensionTables");
+const OrmSchemaExtensions = Symbol.for("kitcn:OrmSchemaExtensions");
+const OrmSchemaExtensionRelations = Symbol.for("kitcn:OrmSchemaExtensionRelations");
+const OrmSchemaExtensionTriggers = Symbol.for("kitcn:OrmSchemaExtensionTriggers");
+const OrmSchemaRelations = Symbol.for("kitcn:OrmSchemaRelations");
+const OrmSchemaTriggers = Symbol.for("kitcn:OrmSchemaTriggers");
+
+//#endregion
+//#region src/orm/builders/convex-column-builder.ts
+/**
+* Convex-specific column builder base class
+*
+* All Convex column builders (ConvexTextBuilder, ConvexIntegerBuilder, etc.)
+* inherit from this class.
+*/
+var ConvexColumnBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexColumnBuilder";
+};
+
+//#endregion
+//#region src/orm/builders/boolean.ts
+/**
+* Boolean column builder class
+* Compiles to v.boolean() or v.optional(v.boolean())
+*/
+var ConvexBooleanBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexBooleanBuilder";
+	constructor(name) {
+		super(name, "boolean", "ConvexBoolean");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.boolean();
+		return v.optional(v.union(v.null(), v.boolean()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.boolean()
+	* nullable → v.optional(v.boolean())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function boolean$1(name) {
+	return new ConvexBooleanBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/internal/upstream/validators.ts
+/** @deprecated Use `v.string()` instead. Any string value. */
+const string = v.string();
+/** @deprecated Use `v.float64()` instead. JavaScript number, represented as a float64 in the database. */
+const number = v.float64();
+/** @deprecated Use `v.float64()` instead. JavaScript number, represented as a float64 in the database. */
+const float64 = v.float64();
+/** @deprecated Use `v.boolean()` instead. boolean value. For typing it only as true, use `l(true)` */
+const boolean = v.boolean();
+/** @deprecated Use `v.int64()` instead. bigint, though stored as an int64 in the database. */
+const biging = v.int64();
+/** @deprecated Use `v.int64()` instead. bigint, though stored as an int64 in the database. */
+const int64 = v.int64();
+/** @deprecated Use `v.any()` instead. Any Convex value */
+const any = v.any();
+/** @deprecated Use `v.null()` instead. Null value. Underscore is so it doesn't shadow the null builtin */
+const null_ = v.null();
+/** @deprecated Use `v.*()` instead. */
+const { id: id$1, object, array, bytes, literal, optional, union } = v;
+/** @deprecated Use `v.bytes()` instead. ArrayBuffer validator. */
+const arrayBuffer = v.bytes();
+/** Mark fields as deprecated with this permissive validator typed as null */
+const deprecated = v.optional(v.any());
+/**
+* Converts an optional validator to a required validator.
+*
+* This is the inverse of `v.optional()`. It takes a validator that may be optional
+* and returns the equivalent required validator.
+*
+* ```ts
+* const optionalString = v.optional(v.string());
+* const requiredString = vRequired(optionalString); // v.string()
+*
+* // Already required validators are returned as-is
+* const alreadyRequired = v.string();
+* const stillRequired = vRequired(alreadyRequired); // v.string()
+* ```
+*
+* @param validator The validator to make required.
+* @returns A required version of the validator.
+*/
+function vRequired(validator) {
+	const { kind, isOptional } = validator;
+	if (isOptional === "required") return validator;
+	switch (kind) {
+		case "id": return v.id(validator.tableName);
+		case "string": return v.string();
+		case "float64": return v.float64();
+		case "int64": return v.int64();
+		case "boolean": return v.boolean();
+		case "null": return v.null();
+		case "any": return v.any();
+		case "literal": return v.literal(validator.value);
+		case "bytes": return v.bytes();
+		case "object": return v.object(validator.fields);
+		case "array": return v.array(validator.element);
+		case "record": return v.record(validator.key, validator.value);
+		case "union": return v.union(...validator.members);
+		default: throw new Error("Unknown Convex validator type: " + kind);
+	}
+}
+
+//#endregion
+//#region src/orm/builders/custom.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidator(value) {
+	return isRecord$2(value) && typeof value.kind === "string" && typeof value.isOptional === "string";
+}
+function isColumnBuilder$1(value) {
+	return isRecord$2(value) && value[entityKind] === "ColumnBuilder";
+}
+function toRequiredValidator(validator) {
+	return validator.isOptional === "optional" ? vRequired(validator) : validator;
+}
+function toRequiredBuilderValidator(validator) {
+	const requiredValidator = toRequiredValidator(validator);
+	if (requiredValidator.kind !== "union") return requiredValidator;
+	const nonNullMembers = requiredValidator.members.filter((member) => member.kind !== "null");
+	if (nonNullMembers.length !== 1) return requiredValidator;
+	const [member] = nonNullMembers;
+	if (member.kind === "object" || member.kind === "array") return member;
+	return requiredValidator;
+}
+function formatInvalidInput(path, value) {
+	return `${path} expected a column builder, Convex validator, or nested object shape. Got ${Array.isArray(value) ? "array" : value === null ? "null" : typeof value}.`;
+}
+function objectShapeToValidator(shape, path) {
+	const fields = {};
+	for (const [key, value] of Object.entries(shape)) fields[key] = nestedInputToValidator(value, `${path}.${key}`);
+	return v.object(fields);
+}
+function nestedInputToValidator(input, path) {
+	if (isColumnBuilder$1(input)) return toRequiredBuilderValidator(input.convexValidator);
+	if (isValidator(input)) return toRequiredValidator(input);
+	if (isRecord$2(input)) return objectShapeToValidator(input, path);
+	throw new Error(formatInvalidInput(path, input));
+}
+var ConvexCustomBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexCustomBuilder";
+	constructor(name, validator) {
+		super(name, "any", "ConvexCustom");
+		this.config.validator = validator;
+	}
+	get convexValidator() {
+		const validator = this.config.validator;
+		if (this.config.notNull) return validator;
+		return v.optional(v.union(v.null(), validator));
+	}
+	build() {
+		return this.convexValidator;
+	}
+};
+function custom(a, b) {
+	if (b !== void 0) return new ConvexCustomBuilder(a, b);
+	return new ConvexCustomBuilder("", a);
+}
+/**
+* Creates an array column from a nested validator or builder.
+*
+* Values in nested arrays are always compiled as required validators.
+*/
+function arrayOf(element) {
+	return custom(v.array(nestedInputToValidator(element, "arrayOf(element)"))).$type();
+}
+/**
+* Creates an object column from either:
+* - a nested shape of validators/builders, or
+* - a validator/builder describing homogeneous record values
+*
+* Fields in nested objects are always compiled as required validators.
+*/
+function objectOf(input) {
+	if (isColumnBuilder$1(input) || isValidator(input)) return custom(v.record(v.string(), nestedInputToValidator(input, "objectOf(value)"))).$type();
+	if (!isRecord$2(input)) throw new Error(formatInvalidInput("objectOf(shape)", input));
+	return custom(objectShapeToValidator(input, "objectOf(shape)")).$type();
+}
+/**
+* Convenience wrapper for Convex "JSON" values.
+*
+* Note: This is Convex JSON (runtime `v.any()`), not SQL JSON/JSONB.
+*/
+function json() {
+	return custom(v.any()).$type();
+}
+
+//#endregion
+//#region src/orm/builders/id.ts
+/**
+* ID column builder class
+* Compiles to v.id(tableName) or v.optional(v.id(tableName))
+*/
+var ConvexIdBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexIdBuilder";
+	constructor(name, tableName) {
+		super(name, "string", "ConvexId");
+		this.tableName = tableName;
+		this.config.referenceTable = tableName;
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.id(this.tableName);
+		return v.optional(v.union(v.null(), v.id(this.tableName)));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.id(tableName)
+	* nullable → v.optional(v.id(tableName))
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function id(tableName) {
+	return new ConvexIdBuilder("", tableName);
+}
+
+//#endregion
+//#region src/orm/builders/number.ts
+/**
+* Number column builder class
+* Compiles to v.number() or v.optional(v.number())
+*/
+var ConvexNumberBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexNumberBuilder";
+	constructor(name) {
+		super(name, "number", "ConvexNumber");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.number();
+		return v.optional(v.union(v.null(), v.number()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.number()
+	* nullable → v.optional(v.number())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function integer(name) {
+	return new ConvexNumberBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/orm/builders/text.ts
+/**
+* Text column builder class
+* Compiles to v.string() or v.optional(v.string())
+*/
+var ConvexTextBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexTextBuilder";
+	constructor(name) {
+		super(name, "string", "ConvexText");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.string();
+		return v.optional(v.union(v.null(), v.string()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.string()
+	* nullable → v.optional(v.string())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function text(name) {
+	return new ConvexTextBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/orm/extensions.ts
+function defineChainMethod(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: false,
+		configurable: true
+	});
+}
+function createSchemaExtensionChain(state, capabilities) {
+	const extension = {
+		key: state.key,
+		tables: state.tables
+	};
+	Object.defineProperty(extension, OrmSchemaExtensionRelations, {
+		value: state.relations,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(extension, OrmSchemaExtensionTriggers, {
+		value: state.triggers,
+		enumerable: false,
+		configurable: true
+	});
+	if (capabilities.canRelations) defineChainMethod(extension, "relations", (relations) => createSchemaExtensionChain({
+		...state,
+		relations
+	}, {
+		canRelations: false,
+		canTriggers: true
+	}));
+	if (capabilities.canTriggers) defineChainMethod(extension, "triggers", (triggers) => createSchemaExtensionChain({
+		...state,
+		triggers
+	}, {
+		canRelations: false,
+		canTriggers: false
+	}));
+	return extension;
+}
+function defineSchemaExtension(key, tables) {
+	return createSchemaExtensionChain({
+		key,
+		tables,
+		relations: void 0,
+		triggers: void 0
+	}, {
+		canRelations: true,
+		canTriggers: true
+	});
+}
+
+//#endregion
+//#region src/orm/indexes.ts
+var ConvexIndexBuilderOn = class {
+	static [entityKind] = "ConvexIndexBuilderOn";
+	[entityKind] = "ConvexIndexBuilderOn";
+	constructor(name, unique) {
+		this.name = name;
+		this.unique = unique;
+	}
+	on(...columns) {
+		return new ConvexIndexBuilder(this.name, columns, this.unique);
+	}
+};
+var ConvexIndexBuilder = class {
+	static [entityKind] = "ConvexIndexBuilder";
+	[entityKind] = "ConvexIndexBuilder";
+	config;
+	constructor(name, columns, unique) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			where: void 0
+		};
+	}
+	/**
+	* Partial index conditions are not supported in Convex.
+	* This method is kept for Drizzle API parity.
+	*/
+	where(condition) {
+		this.config.where = condition;
+		return this;
+	}
+};
+var ConvexSearchIndexBuilderOn = class {
+	static [entityKind] = "ConvexSearchIndexBuilderOn";
+	[entityKind] = "ConvexSearchIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(searchField) {
+		return new ConvexSearchIndexBuilder(this.name, searchField);
+	}
+};
+var ConvexSearchIndexBuilder = class {
+	static [entityKind] = "ConvexSearchIndexBuilder";
+	[entityKind] = "ConvexSearchIndexBuilder";
+	config;
+	constructor(name, searchField) {
+		this.config = {
+			name,
+			searchField,
+			filterFields: [],
+			staged: false
+		};
+	}
+	filter(...fields) {
+		this.config.filterFields = fields;
+		return this;
+	}
+	staged() {
+		this.config.staged = true;
+		return this;
+	}
+};
+var ConvexVectorIndexBuilderOn = class {
+	static [entityKind] = "ConvexVectorIndexBuilderOn";
+	[entityKind] = "ConvexVectorIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(vectorField) {
+		return new ConvexVectorIndexBuilder(this.name, vectorField);
+	}
+};
+var ConvexAggregateIndexBuilderOn = class {
+	static [entityKind] = "ConvexAggregateIndexBuilderOn";
+	[entityKind] = "ConvexAggregateIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(...columns) {
+		return new ConvexAggregateIndexBuilder(this.name, columns);
+	}
+	all() {
+		return new ConvexAggregateIndexBuilder(this.name, []);
+	}
+};
+var ConvexAggregateIndexBuilder = class {
+	static [entityKind] = "ConvexAggregateIndexBuilder";
+	[entityKind] = "ConvexAggregateIndexBuilder";
+	config;
+	constructor(name, columns) {
+		this.config = {
+			name,
+			columns,
+			countFields: [],
+			sumFields: [],
+			avgFields: [],
+			minFields: [],
+			maxFields: []
+		};
+	}
+	count(...fields) {
+		this.config.countFields = [...this.config.countFields, ...fields];
+		return this;
+	}
+	sum(...fields) {
+		this.config.sumFields = [...this.config.sumFields, ...fields];
+		return this;
+	}
+	avg(...fields) {
+		this.config.avgFields = [...this.config.avgFields, ...fields];
+		return this;
+	}
+	min(...fields) {
+		this.config.minFields = [...this.config.minFields, ...fields];
+		return this;
+	}
+	max(...fields) {
+		this.config.maxFields = [...this.config.maxFields, ...fields];
+		return this;
+	}
+};
+var ConvexRankIndexBuilderOn = class {
+	static [entityKind] = "ConvexRankIndexBuilderOn";
+	[entityKind] = "ConvexRankIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	partitionBy(...columns) {
+		return new ConvexRankIndexBuilder(this.name, columns, []);
+	}
+	all() {
+		return new ConvexRankIndexBuilder(this.name, [], []);
+	}
+};
+var ConvexRankIndexBuilder = class {
+	static [entityKind] = "ConvexRankIndexBuilder";
+	[entityKind] = "ConvexRankIndexBuilder";
+	config;
+	constructor(name, partitionColumns, orderColumns) {
+		this.config = {
+			name,
+			partitionColumns,
+			orderColumns,
+			sumField: void 0
+		};
+	}
+	orderBy(...columns) {
+		const orderColumns = columns.map((entry) => {
+			if (entry && typeof entry === "object" && "column" in entry && "direction" in entry) {
+				const builder = entry.column;
+				if (!builder) throw new Error("rankIndex orderBy() expected a column builder.");
+				return {
+					column: builder,
+					direction: entry.direction
+				};
+			}
+			return {
+				column: entry,
+				direction: "asc"
+			};
+		});
+		this.config.orderColumns = [...this.config.orderColumns, ...orderColumns];
+		return this;
+	}
+	sum(field) {
+		this.config.sumField = field;
+		return this;
+	}
+};
+var ConvexVectorIndexBuilder = class {
+	static [entityKind] = "ConvexVectorIndexBuilder";
+	[entityKind] = "ConvexVectorIndexBuilder";
+	config;
+	constructor(name, vectorField) {
+		this.config = {
+			name,
+			vectorField,
+			dimensions: void 0,
+			filterFields: [],
+			staged: false
+		};
+	}
+	dimensions(dimensions) {
+		if (!Number.isInteger(dimensions)) throw new Error(`Vector index '${this.config.name}' dimensions must be an integer, got ${dimensions}`);
+		if (dimensions <= 0) throw new Error(`Vector index '${this.config.name}' dimensions must be positive, got ${dimensions}`);
+		if (dimensions > 1e4) console.warn(`Vector index '${this.config.name}' has unusually large dimensions (${dimensions}). Common values: 768, 1536, 3072`);
+		this.config.dimensions = dimensions;
+		return this;
+	}
+	filter(...fields) {
+		this.config.filterFields = fields;
+		return this;
+	}
+	staged() {
+		this.config.staged = true;
+		return this;
+	}
+};
+function index(name) {
+	return new ConvexIndexBuilderOn(name, false);
+}
+
+//#endregion
+//#region src/orm/rls/policies.ts
+var RlsPolicy = class {
+	static [entityKind] = "RlsPolicy";
+	[entityKind] = "RlsPolicy";
+	as;
+	for;
+	to;
+	using;
+	withCheck;
+	/** @internal */
+	_linkedTable;
+	constructor(name, config) {
+		this.name = name;
+		if (config) {
+			this.as = config.as;
+			this.for = config.for;
+			this.to = config.to;
+			this.using = config.using;
+			this.withCheck = config.withCheck;
+		}
+	}
+	link(table) {
+		this._linkedTable = table;
+		return this;
+	}
+};
+function isRlsPolicy(value) {
+	return !!value && typeof value === "object" && value[entityKind] === "RlsPolicy";
+}
+
+//#endregion
+//#region src/orm/table.ts
+/**
+* Reserved Convex system table names that cannot be used
+*/
+const RESERVED_TABLES = new Set(["_storage", "_scheduled_functions"]);
+const RESERVED_COLUMN_NAMES = new Set([
+	"id",
+	"_id",
+	"_creationTime"
+]);
+const DEFAULT_POLYMORPHIC_ALIAS = "details";
+const CONVEX_TABLE_FIELD_LIMIT = 1024;
+/**
+* Valid table name pattern: starts with letter/underscore, contains only alphanumeric and underscore
+*/
+const TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+* Validate table name against Convex constraints
+*/
+function validateTableName(name) {
+	if (RESERVED_TABLES.has(name)) throw new Error(`Table name '${name}' is reserved. System tables cannot be redefined.`);
+	if (!TABLE_NAME_REGEX.test(name)) throw new Error(`Invalid table name '${name}'. Must start with letter, contain only alphanumeric and underscore.`);
+}
+/**
+* Create a Convex object validator from column builders
+*
+* Extracts .convexValidator from each column and creates v.object({...})
+* This is the core factory that bridges ORM columns to Convex validators.
+*
+* @param columns - Record of column name to column builder
+* @returns Convex object validator
+*/
+function createValidatorFromColumns(columns) {
+	const validatorFields = Object.fromEntries(Object.entries(columns).map(([key, builder]) => [key, builder.convexValidator]));
+	return v.object(validatorFields);
+}
+var ConvexDeletionBuilder = class {
+	static [entityKind] = "ConvexDeletionBuilder";
+	[entityKind] = "ConvexDeletionBuilder";
+	constructor(config) {
+		this.config = config;
+	}
+};
+function isConvexIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilder";
+}
+function isConvexIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilderOn";
+}
+function isConvexAggregateIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilder";
+}
+function isConvexAggregateIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilderOn";
+}
+function isConvexRankIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilderOn";
+}
+function isConvexRankIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilder";
+}
+function isConvexUniqueConstraintBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexUniqueConstraintBuilderOn";
+}
+function isConvexForeignKeyBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexForeignKeyBuilder";
+}
+function isConvexCheckBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexCheckBuilder";
+}
+function isConvexSearchIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexSearchIndexBuilderOn";
+}
+function isConvexUniqueConstraintBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexUniqueConstraintBuilder";
+}
+function isConvexSearchIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexSearchIndexBuilder";
+}
+function isConvexVectorIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexVectorIndexBuilderOn";
+}
+function isConvexVectorIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexVectorIndexBuilder";
+}
+function isConvexDeletionBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexDeletionBuilder";
+}
+function isConvexLifecycleBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexLifecycleBuilder";
+}
+function getColumnName(column) {
+	const config = column.config;
+	if (!config?.name) throw new Error("Invalid index column: expected a convexTable column builder.");
+	return config.name;
+}
+function getColumnType(column) {
+	return column.config?.columnType;
+}
+function getColumnDimensions(column) {
+	return column.config?.dimensions;
+}
+function getColumnTableName(column) {
+	const config = column.config;
+	return config?.tableName ?? config?.referenceTable;
+}
+function getColumnTable(column) {
+	return column.config?.table;
+}
+function getUniqueIndexName(tableName, fields, explicitName) {
+	if (explicitName) return explicitName;
+	return `${tableName}_${fields.join("_")}_unique`;
+}
+function assertColumnInTable(column, expectedTable, context) {
+	const tableName = getColumnTableName(column);
+	if (tableName && tableName !== expectedTable) throw new Error(`${context} references column from '${tableName}', but belongs to '${expectedTable}'.`);
+	return getColumnName(column);
+}
+function assertNoReservedCreatedAtIndexFields(fields, context) {
+	if (fields.includes("createdAt")) throw new Error(`${context} cannot use 'createdAt'. 'createdAt' is reserved and maps to internal '_creationTime'.`);
+}
+function assertSearchFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (columnType !== "ConvexText") throw new Error(`Search index '${indexName}' only supports text() columns. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertVectorFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (columnType !== "ConvexVector") throw new Error(`Vector index '${indexName}' requires a vector() column. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateSumFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (!["ConvexNumber", "ConvexTimestamp"].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' sum() supports integer()/timestamp() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateAvgFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (!["ConvexNumber", "ConvexTimestamp"].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' avg() supports integer()/timestamp() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateComparableFieldType(column, indexName, method) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (![
+		"ConvexNumber",
+		"ConvexTimestamp",
+		"ConvexDate",
+		"ConvexText",
+		"ConvexBoolean",
+		"ConvexId"
+	].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' ${method}() does not support column type '${columnType}' on '${getColumnName(column)}'.`);
+}
+function assertRankOrderFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (![
+		"ConvexNumber",
+		"ConvexTimestamp",
+		"ConvexDate"
+	].includes(columnType)) throw new Error(`rankIndex '${indexName}' orderBy() supports integer()/timestamp()/date() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+const dedupeFieldNames = (fields) => [...new Set(fields)];
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isColumnBuilder = (value) => isRecord$1(value) && typeof value.build === "function";
+const getDiscriminatorConfig = (value) => {
+	if (!isColumnBuilder(value)) return;
+	const discriminator = value.config?.discriminator;
+	if (!discriminator) return;
+	return discriminator;
+};
+const getPolymorphicFieldSignature = (column) => {
+	const validator = column.convexValidator ?? column.build();
+	return JSON.stringify({
+		columnType: column.config?.columnType,
+		validator: validator?.json
+	});
+};
+function resolveTableColumns(tableName, columns) {
+	const resolvedColumns = {};
+	const pendingPolymorphic = [];
+	for (const [columnName, rawBuilder] of Object.entries(columns)) {
+		if (!isColumnBuilder(rawBuilder)) throw new Error(`Column '${columnName}' on '${tableName}' must be a column builder.`);
+		resolvedColumns[columnName] = rawBuilder;
+		const discriminatorConfig = getDiscriminatorConfig(rawBuilder);
+		if (!discriminatorConfig) continue;
+		if (!isRecord$1(discriminatorConfig.variants) || Object.keys(discriminatorConfig.variants).length === 0) throw new Error(`discriminator('${tableName}.${columnName}') requires at least one variant.`);
+		const alias = discriminatorConfig.as === void 0 ? DEFAULT_POLYMORPHIC_ALIAS : discriminatorConfig.as;
+		if (typeof alias !== "string" || alias.length === 0) throw new Error(`discriminator('${tableName}.${columnName}').as must be a non-empty string.`);
+		pendingPolymorphic.push({
+			discriminator: columnName,
+			alias,
+			variants: discriminatorConfig.variants
+		});
+	}
+	if (pendingPolymorphic.length > 1) throw new Error(`Only one discriminator(...) column is currently supported on '${tableName}'.`);
+	const polymorphicConfigs = [];
+	for (const pending of pendingPolymorphic) {
+		if (pending.alias in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}') alias '${pending.alias}' collides with an existing column.`);
+		const generatedFieldMap = /* @__PURE__ */ new Map();
+		const variantRuntime = {};
+		for (const [variantKey, rawVariantColumns] of Object.entries(pending.variants)) {
+			if (!isRecord$1(rawVariantColumns)) throw new Error(`discriminator('${tableName}.${pending.discriminator}') variant '${variantKey}' must be an object.`);
+			const fieldNames = [];
+			const requiredFieldNames = [];
+			for (const [fieldName, rawFieldBuilder] of Object.entries(rawVariantColumns)) {
+				if (!isColumnBuilder(rawFieldBuilder)) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} must be a column builder.`);
+				if (fieldName in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} collides with an existing table column.`);
+				const fieldBuilder = rawFieldBuilder;
+				const fieldConfig = fieldBuilder.config;
+				const isRequiredForVariant = fieldConfig?.notNull === true && fieldConfig.hasDefault !== true && typeof fieldConfig.defaultFn !== "function";
+				const signature = getPolymorphicFieldSignature(fieldBuilder);
+				const existing = generatedFieldMap.get(fieldName);
+				if (existing && existing.signature !== signature) throw new Error(`discriminator('${tableName}.${pending.discriminator}') field '${fieldName}' has conflicting builder signatures across variants.`);
+				if (!existing) {
+					if (fieldConfig) fieldConfig.notNull = false;
+					generatedFieldMap.set(fieldName, {
+						builder: fieldBuilder,
+						signature
+					});
+				}
+				fieldNames.push(fieldName);
+				if (isRequiredForVariant) requiredFieldNames.push(fieldName);
+			}
+			variantRuntime[variantKey] = {
+				fieldNames,
+				requiredFieldNames
+			};
+		}
+		for (const [fieldName, { builder }] of generatedFieldMap.entries()) resolvedColumns[fieldName] = builder;
+		polymorphicConfigs.push({
+			discriminator: pending.discriminator,
+			alias: pending.alias,
+			generatedFieldNames: Object.freeze([...generatedFieldMap.keys()]),
+			variants: Object.freeze(variantRuntime)
+		});
+	}
+	if (Object.keys(resolvedColumns).length > CONVEX_TABLE_FIELD_LIMIT) throw new Error(`Table '${tableName}' exceeds Convex field count limit (${CONVEX_TABLE_FIELD_LIMIT}) after discriminator expansion.`);
+	return {
+		columns: resolvedColumns,
+		polymorphicConfigs
+	};
+}
+function applyExtraConfig(table, config) {
+	if (!config) return;
+	const entries = Array.isArray(config) ? config : Object.values(config);
+	for (const entry of entries) {
+		if (isConvexIndexBuilderOn(entry)) throw new Error(`Invalid index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexUniqueConstraintBuilderOn(entry)) throw new Error(`Invalid unique constraint definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexAggregateIndexBuilderOn(entry)) throw new Error(`Invalid aggregate index definition on '${table.tableName}'. Did you forget to call .on(...) or .all()?`);
+		if (isConvexRankIndexBuilderOn(entry)) throw new Error(`Invalid rank index definition on '${table.tableName}'. Did you forget to call .partitionBy(...) or .all()?`);
+		if (isConvexSearchIndexBuilderOn(entry)) throw new Error(`Invalid search index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexVectorIndexBuilderOn(entry)) throw new Error(`Invalid vector index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isRlsPolicy(entry)) {
+			const target = entry._linkedTable ?? table;
+			if (typeof target.addRlsPolicy === "function") target.addRlsPolicy(entry);
+			else {
+				const policies = target[RlsPolicies] ?? [];
+				policies.push(entry);
+				target[RlsPolicies] = policies;
+				target[EnableRLS] = true;
+			}
+			continue;
+		}
+		if (isConvexDeletionBuilder(entry)) {
+			if (table[TableDeleteConfig]) throw new Error(`Only one deletion(...) config can be defined for '${table.tableName}'.`);
+			table[TableDeleteConfig] = {
+				mode: entry.config.mode,
+				delayMs: entry.config.delayMs
+			};
+			continue;
+		}
+		if (isConvexLifecycleBuilder(entry)) throw new Error(`Lifecycle hooks are no longer supported inside convexTable('${table.tableName}', ..., extraConfig). Export schema triggers with defineTriggers(relations, { ... }) from schema.ts.`);
+		if (isConvexIndexBuilder(entry)) {
+			const { name, columns, unique, where } = entry.config;
+			if (where) throw new Error(`Convex does not support partial indexes. Remove .where(...) from index '${name}'.`);
+			if (unique) {}
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, `Index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(fields, `Index '${name}'`);
+			table.addIndex(name, fields);
+			if (unique) table.addUniqueIndex(name, fields, false);
+			continue;
+		}
+		if (isConvexAggregateIndexBuilder(entry)) {
+			const { name, columns, countFields, sumFields, avgFields, minFields, maxFields } = entry.config;
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, `Aggregate index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(fields, `Aggregate index '${name}'`);
+			const resolvedCountFields = dedupeFieldNames(countFields.map((column) => assertColumnInTable(column, table.tableName, `Aggregate index '${name}' count`)));
+			assertNoReservedCreatedAtIndexFields(resolvedCountFields, `Aggregate index '${name}' count`);
+			const resolvedSumFields = dedupeFieldNames(sumFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' sum`);
+				assertAggregateSumFieldType(column, name);
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedSumFields, `Aggregate index '${name}' sum`);
+			const resolvedAvgFields = dedupeFieldNames(avgFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' avg`);
+				assertAggregateAvgFieldType(column, name);
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedAvgFields, `Aggregate index '${name}' avg`);
+			const resolvedMinFields = dedupeFieldNames(minFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' min`);
+				assertAggregateComparableFieldType(column, name, "min");
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedMinFields, `Aggregate index '${name}' min`);
+			const resolvedMaxFields = dedupeFieldNames(maxFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' max`);
+				assertAggregateComparableFieldType(column, name, "max");
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedMaxFields, `Aggregate index '${name}' max`);
+			table.addAggregateIndex(name, {
+				fields,
+				countFields: resolvedCountFields,
+				sumFields: resolvedSumFields,
+				avgFields: resolvedAvgFields,
+				minFields: resolvedMinFields,
+				maxFields: resolvedMaxFields
+			});
+			continue;
+		}
+		if (isConvexRankIndexBuilder(entry)) {
+			const { name, partitionColumns, orderColumns, sumField } = entry.config;
+			if (!orderColumns.length) throw new Error(`rankIndex '${name}' on '${table.tableName}' must declare at least one orderBy(...) column.`);
+			const resolvedPartitionFields = dedupeFieldNames(partitionColumns.map((column) => assertColumnInTable(column, table.tableName, `rankIndex '${name}'`)));
+			assertNoReservedCreatedAtIndexFields(resolvedPartitionFields, `rankIndex '${name}' partitionBy`);
+			const resolvedOrderFields = orderColumns.map((entry) => {
+				const field = assertColumnInTable(entry.column, table.tableName, `rankIndex '${name}' orderBy`);
+				assertNoReservedCreatedAtIndexFields([field], `rankIndex '${name}'`);
+				assertRankOrderFieldType(entry.column, name);
+				return {
+					field,
+					direction: entry.direction
+				};
+			});
+			const resolvedSumField = sumField ? (() => {
+				const field = assertColumnInTable(sumField, table.tableName, `rankIndex '${name}' sum`);
+				assertNoReservedCreatedAtIndexFields([field], `rankIndex '${name}'`);
+				assertAggregateSumFieldType(sumField, name);
+				return field;
+			})() : void 0;
+			table.addRankIndex(name, {
+				partitionFields: resolvedPartitionFields,
+				orderFields: resolvedOrderFields,
+				sumField: resolvedSumField
+			});
+			continue;
+		}
+		if (isConvexUniqueConstraintBuilder(entry)) {
+			const { name, columns, nullsNotDistinct } = entry.config;
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, "Unique constraint"));
+			assertNoReservedCreatedAtIndexFields(fields, "Unique constraint");
+			const indexName = getUniqueIndexName(table.tableName, fields, name);
+			table.addIndex(indexName, fields);
+			table.addUniqueIndex(indexName, fields, nullsNotDistinct);
+			continue;
+		}
+		if (isConvexForeignKeyBuilder(entry)) {
+			const { name, columns, foreignColumns, onDelete, onUpdate } = entry.config;
+			if (columns.length === 0 || foreignColumns.length === 0) throw new Error(`Foreign key on '${table.tableName}' requires at least one column.`);
+			if (columns.length !== foreignColumns.length) throw new Error(`Foreign key on '${table.tableName}' must specify matching columns and foreignColumns.`);
+			const localFields = columns.map((column) => assertColumnInTable(column, table.tableName, "Foreign key"));
+			const foreignTableName = getColumnTableName(foreignColumns[0]);
+			if (!foreignTableName) throw new Error(`Foreign key on '${table.tableName}' references a column without a table.`);
+			const foreignTable = getColumnTable(foreignColumns[0]);
+			const foreignFields = foreignColumns.map((column) => {
+				const tableName = getColumnTableName(column);
+				if (tableName && tableName !== foreignTableName) throw new Error(`Foreign key on '${table.tableName}' mixes foreign columns from '${foreignTableName}' and '${tableName}'.`);
+				return getColumnName(column);
+			});
+			table.addForeignKey({
+				name,
+				columns: localFields,
+				foreignTableName,
+				foreignTable,
+				foreignColumns: foreignFields,
+				onDelete,
+				onUpdate
+			});
+			continue;
+		}
+		if (isConvexCheckBuilder(entry)) {
+			const { name, expression } = entry.config;
+			table.addCheck(name, expression);
+			continue;
+		}
+		if (isConvexSearchIndexBuilder(entry)) {
+			const { name, searchField, filterFields, staged } = entry.config;
+			const searchFieldName = assertColumnInTable(searchField, table.tableName, `Search index '${name}'`);
+			assertNoReservedCreatedAtIndexFields([searchFieldName], `Search index '${name}'`);
+			assertSearchFieldType(searchField, name);
+			const filterFieldNames = filterFields.map((field) => assertColumnInTable(field, table.tableName, `Search index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(filterFieldNames, `Search index '${name}'`);
+			table.addSearchIndex(name, {
+				searchField: searchFieldName,
+				filterFields: filterFieldNames,
+				staged
+			});
+			continue;
+		}
+		if (isConvexVectorIndexBuilder(entry)) {
+			const { name, vectorField, dimensions, filterFields, staged } = entry.config;
+			if (dimensions === void 0) throw new Error(`Vector index '${name}' is missing dimensions. Call .dimensions(n) before using.`);
+			const vectorFieldName = assertColumnInTable(vectorField, table.tableName, `Vector index '${name}'`);
+			assertNoReservedCreatedAtIndexFields([vectorFieldName], `Vector index '${name}'`);
+			assertVectorFieldType(vectorField, name);
+			const columnDimensions = getColumnDimensions(vectorField);
+			if (columnDimensions !== void 0 && columnDimensions !== dimensions) throw new Error(`Vector index '${name}' dimensions (${dimensions}) do not match vector column '${vectorFieldName}' dimensions (${columnDimensions}).`);
+			const filterFieldNames = filterFields.map((field) => assertColumnInTable(field, table.tableName, `Vector index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(filterFieldNames, `Vector index '${name}'`);
+			table.addVectorIndex(name, {
+				vectorField: vectorFieldName,
+				dimensions,
+				filterFields: filterFieldNames,
+				staged
+			});
+			continue;
+		}
+		throw new Error(`Unsupported extra config value in convexTable('${table.tableName}').`);
+	}
+}
+/**
+* ConvexTable implementation class
+* Provides all properties required by Convex's TableDefinition
+*
+* Following convex-ents pattern:
+* - Private fields for indexes (matches TableDefinition structure)
+* - Duck typing (defineSchema only checks object shape)
+* - Direct validator storage (no re-wrapping)
+*/
+var ConvexTableImpl = class {
+	/**
+	* Required by TableDefinition
+	* Public validator property containing v.object({...}) with all column validators
+	*/
+	validator;
+	/**
+	* TableDefinition private fields
+	* These satisfy structural typing requirements for defineSchema()
+	*/
+	indexes = [];
+	uniqueIndexes = [];
+	aggregateIndexes = [];
+	rankIndexes = [];
+	foreignKeys = [];
+	deferredForeignKeys = [];
+	deferredForeignKeysResolved = false;
+	stagedDbIndexes = [];
+	searchIndexes = [];
+	stagedSearchIndexes = [];
+	vectorIndexes = [];
+	stagedVectorIndexes = [];
+	checks = [];
+	/**
+	* Symbol-based metadata storage
+	*/
+	[TableName];
+	[Columns];
+	[Brand] = "ConvexTable";
+	[EnableRLS] = false;
+	[RlsPolicies] = [];
+	[TableDeleteConfig];
+	[TablePolymorphic];
+	/**
+	* Public tableName for convenience
+	*/
+	tableName;
+	constructor(name, columns, polymorphicConfigs) {
+		validateTableName(name);
+		for (const columnName of Object.keys(columns)) if (RESERVED_COLUMN_NAMES.has(columnName)) throw new Error(`Column name '${columnName}' is reserved. System fields are managed by Convex ORM.`);
+		this[TableName] = name;
+		const namedColumns = Object.fromEntries(Object.entries(columns).map(([columnName, builder]) => {
+			builder.config.name = columnName;
+			builder.config.tableName = name;
+			builder.config.table = this;
+			return [columnName, builder];
+		}));
+		this[Columns] = namedColumns;
+		this.tableName = name;
+		if (polymorphicConfigs && polymorphicConfigs.length > 0) this[TablePolymorphic] = polymorphicConfigs;
+		this.validator = createValidatorFromColumns(namedColumns);
+		for (const [columnName, builder] of Object.entries(namedColumns)) {
+			const config = builder.config;
+			if (config?.isUnique) {
+				const indexName = getUniqueIndexName(name, [columnName], config.uniqueName);
+				const nullsNotDistinct = config.uniqueNulls === "not distinct";
+				this.addIndex(indexName, [columnName]);
+				this.addUniqueIndex(indexName, [columnName], nullsNotDistinct);
+			}
+			if (config?.referenceTable && (!config.foreignKeyConfigs || config.foreignKeyConfigs.length === 0)) this.addForeignKey({
+				name: void 0,
+				columns: [columnName],
+				foreignTableName: config.referenceTable,
+				foreignColumns: ["_id"]
+			});
+			if (config?.foreignKeyConfigs?.length) for (const foreignConfig of config.foreignKeyConfigs) this.deferredForeignKeys.push({
+				localColumnName: columnName,
+				ref: foreignConfig.ref,
+				config: foreignConfig.config
+			});
+		}
+	}
+	getPolymorphicConfigs() {
+		return this[TablePolymorphic];
+	}
+	/**
+	* Internal: add index to table from builder extraConfig
+	*
+	*/
+	addIndex(name, fields) {
+		this.indexes.push({
+			indexDescriptor: name,
+			fields
+		});
+	}
+	/**
+	* Internal: add unique index metadata for runtime enforcement
+	*/
+	addUniqueIndex(name, fields, nullsNotDistinct) {
+		this.uniqueIndexes.push({
+			name,
+			fields,
+			nullsNotDistinct
+		});
+	}
+	addAggregateIndex(name, config) {
+		if (this.aggregateIndexes.some((index) => index.name === name) || this.rankIndexes.some((index) => index.name === name)) throw new Error(`Duplicate aggregate index '${name}' on '${this.tableName}'.`);
+		this.aggregateIndexes.push({
+			name,
+			fields: config.fields,
+			countFields: config.countFields,
+			sumFields: config.sumFields,
+			avgFields: config.avgFields,
+			minFields: config.minFields,
+			maxFields: config.maxFields
+		});
+	}
+	addRankIndex(name, config) {
+		if (this.rankIndexes.some((index) => index.name === name) || this.aggregateIndexes.some((index) => index.name === name)) throw new Error(`Duplicate aggregate index '${name}' on '${this.tableName}'.`);
+		this.rankIndexes.push({
+			name,
+			partitionFields: config.partitionFields,
+			orderFields: config.orderFields,
+			sumField: config.sumField
+		});
+	}
+	getAggregateIndexes() {
+		return [...this.aggregateIndexes];
+	}
+	getRankIndexes() {
+		return [...this.rankIndexes];
+	}
+	/**
+	* Internal: expose unique index metadata for mutation enforcement
+	*/
+	getUniqueIndexes() {
+		return this.uniqueIndexes;
+	}
+	/**
+	* Internal: expose index metadata for runtime enforcement
+	*/
+	getIndexes() {
+		return this.indexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			fields: entry.fields
+		}));
+	}
+	/**
+	* Internal: expose search index metadata for runtime query execution
+	*/
+	getSearchIndexes() {
+		return this.searchIndexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			searchField: entry.searchField,
+			filterFields: entry.filterFields
+		}));
+	}
+	/**
+	* Internal: expose vector index metadata for runtime query execution
+	*/
+	getVectorIndexes() {
+		return this.vectorIndexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			vectorField: entry.vectorField,
+			dimensions: entry.dimensions,
+			filterFields: entry.filterFields
+		}));
+	}
+	/**
+	* Internal: attach an RLS policy to this table
+	*/
+	addRlsPolicy(policy) {
+		this[RlsPolicies].push(policy);
+		this[EnableRLS] = true;
+	}
+	/**
+	* Internal: return attached RLS policies
+	*/
+	getRlsPolicies() {
+		return this[RlsPolicies];
+	}
+	/**
+	* Internal: check if RLS is enabled on this table
+	*/
+	isRlsEnabled() {
+		return this[EnableRLS];
+	}
+	/**
+	* Internal: add foreign key metadata for runtime enforcement
+	*/
+	addForeignKey(definition) {
+		const matches = (existing) => {
+			if (existing.foreignTableName !== definition.foreignTableName) return false;
+			if (existing.columns.length !== definition.columns.length) return false;
+			if (existing.foreignColumns.length !== definition.foreignColumns.length) return false;
+			for (let i = 0; i < existing.columns.length; i++) if (existing.columns[i] !== definition.columns[i]) return false;
+			for (let i = 0; i < existing.foreignColumns.length; i++) if (existing.foreignColumns[i] !== definition.foreignColumns[i]) return false;
+			return true;
+		};
+		this.foreignKeys = this.foreignKeys.filter((existing) => !matches(existing));
+		this.foreignKeys.push(definition);
+	}
+	resolveDeferredForeignKeys() {
+		if (this.deferredForeignKeysResolved) return;
+		this.deferredForeignKeysResolved = true;
+		for (const deferred of this.deferredForeignKeys) {
+			let foreignColumn;
+			try {
+				foreignColumn = deferred.ref();
+			} catch (error) {
+				const reason = error instanceof Error ? ` ${error.message}` : "";
+				throw new Error(`Failed to resolve foreign key reference for '${this.tableName}.${deferred.localColumnName}'. Use references(() => targetTable.column) after both tables are declared.${reason}`);
+			}
+			const foreignTableName = getColumnTableName(foreignColumn);
+			if (!foreignTableName) throw new Error(`Foreign key on '${this.tableName}.${deferred.localColumnName}' references a column without a table. Use references(() => targetTable.column).`);
+			const foreignTable = getColumnTable(foreignColumn);
+			if (!foreignTable) throw new Error(`Foreign key on '${this.tableName}.${deferred.localColumnName}' references a column without table metadata. Replace references(() => id('tableName')) with references(() => table.id).`);
+			const foreignColumnName = getColumnName(foreignColumn);
+			this.addForeignKey({
+				name: deferred.config.name,
+				columns: [deferred.localColumnName],
+				foreignTableName,
+				foreignTable,
+				foreignColumns: [foreignColumnName],
+				onDelete: deferred.config.onDelete,
+				onUpdate: deferred.config.onUpdate
+			});
+		}
+		this.deferredForeignKeys = [];
+	}
+	/**
+	* Internal: expose foreign key metadata for mutation enforcement
+	*/
+	getForeignKeys() {
+		this.resolveDeferredForeignKeys();
+		return this.foreignKeys;
+	}
+	addCheck(name, expression) {
+		this.checks.push({
+			name,
+			expression
+		});
+	}
+	getChecks() {
+		return this.checks;
+	}
+	/**
+	* Internal: add search index to table from builder extraConfig
+	*/
+	addSearchIndex(name, config) {
+		const entry = {
+			indexDescriptor: name,
+			searchField: config.searchField,
+			filterFields: config.filterFields ?? []
+		};
+		if (config.staged) this.stagedSearchIndexes.push(entry);
+		else this.searchIndexes.push(entry);
+	}
+	/**
+	* Internal: add vector index to table from builder extraConfig
+	*/
+	addVectorIndex(name, config) {
+		const entry = {
+			indexDescriptor: name,
+			vectorField: config.vectorField,
+			dimensions: config.dimensions,
+			filterFields: config.filterFields ?? []
+		};
+		if (config.staged) this.stagedVectorIndexes.push(entry);
+		else this.vectorIndexes.push(entry);
+	}
+	/**
+	* Export the contents of this definition for Convex schema tooling.
+	* Mirrors convex/server TableDefinition.export().
+	*/
+	export() {
+		const documentType = this.validator.json;
+		if (typeof documentType !== "object") throw new Error("Invalid validator: please make sure that the parameter of `defineTable` is valid (see https://docs.convex.dev/database/schemas)");
+		return {
+			indexes: this.indexes,
+			stagedDbIndexes: this.stagedDbIndexes,
+			searchIndexes: this.searchIndexes,
+			stagedSearchIndexes: this.stagedSearchIndexes,
+			vectorIndexes: this.vectorIndexes,
+			stagedVectorIndexes: this.stagedVectorIndexes,
+			documentType
+		};
+	}
+};
+const convexTableInternal = (name, columns, extraConfig) => {
+	const expanded = resolveTableColumns(name, columns);
+	const rawTable = new ConvexTableImpl(name, expanded.columns, expanded.polymorphicConfigs);
+	const systemFields = createSystemFields(name);
+	for (const builder of Object.values(systemFields)) builder.config.table = rawTable;
+	const table = Object.assign(rawTable, systemFields, rawTable[Columns]);
+	const internalCreationTime = systemFields._creationTime;
+	if (Object.hasOwn(table, "_creationTime")) table._creationTime = void 0;
+	Object.defineProperty(table, "_creationTime", {
+		value: internalCreationTime,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	Object.defineProperty(table, "_id", {
+		value: systemFields.id,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	applyExtraConfig(rawTable, extraConfig?.(table));
+	return table;
+};
+const convexTableWithRLS = (name, columns, extraConfig) => {
+	const table = convexTableInternal(name, columns, extraConfig);
+	table[EnableRLS] = true;
+	return table;
+};
+const convexTable = Object.assign(convexTableInternal, { withRLS: convexTableWithRLS });
+
+//#endregion
+//#region src/orm/aggregate-index/schema.ts
+const AGGREGATE_BUCKET_TABLE = "aggregate_bucket";
+const AGGREGATE_MEMBER_TABLE = "aggregate_member";
+const AGGREGATE_EXTREMA_TABLE = "aggregate_extrema";
+const AGGREGATE_RANK_TREE_TABLE = "aggregate_rank_tree";
+const AGGREGATE_RANK_NODE_TABLE = "aggregate_rank_node";
+const AGGREGATE_STATE_TABLE = "aggregate_state";
+const countBucketTable = convexTable(AGGREGATE_BUCKET_TABLE, {
+	tableKey: text().notNull(),
+	indexName: text().notNull(),
+	keyHash: text().notNull(),
+	keyParts: arrayOf(json()).notNull(),
+	count: integer().notNull(),
+	sumValues: objectOf(integer().notNull()).notNull(),
+	nonNullCountValues: objectOf(integer().notNull()).notNull(),
+	updatedAt: integer().notNull()
+}, (t) => [index("by_table_index_hash").on(t.tableKey, t.indexName, t.keyHash), index("by_table_index").on(t.tableKey, t.indexName)]);
+const countMemberTable = convexTable(AGGREGATE_MEMBER_TABLE, {
+	kind: text().notNull(),
+	tableKey: text().notNull(),
+	indexName: text().notNull(),
+	docId: text().notNull(),
+	keyHash: text().notNull(),
+	keyParts: arrayOf(json()).notNull(),
+	sumValues: objectOf(integer().notNull()).notNull(),
+	nonNullCountValues: objectOf(integer().notNull()).notNull(),
+	extremaValues: objectOf(json()).notNull(),
+	rankNamespace: json(),
+	rankKey: json(),
+	rankSumValue: integer(),
+	updatedAt: integer().notNull()
+}, (t) => [index("by_kind_table_index_doc").on(t.kind, t.tableKey, t.indexName, t.docId), index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName)]);
+const countExtremaTable = convexTable(AGGREGATE_EXTREMA_TABLE, {
+	tableKey: text().notNull(),
+	indexName: text().notNull(),
+	keyHash: text().notNull(),
+	fieldName: text().notNull(),
+	valueHash: text().notNull(),
+	value: json().notNull(),
+	sortKey: text().notNull(),
+	count: integer().notNull(),
+	updatedAt: integer().notNull()
+}, (t) => [
+	index("by_table_index").on(t.tableKey, t.indexName),
+	index("by_table_index_hash_field_value").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.valueHash),
+	index("by_table_index_hash_field_sort").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.sortKey)
+]);
+const countStateTable = convexTable(AGGREGATE_STATE_TABLE, {
+	kind: text().notNull(),
+	tableKey: text().notNull(),
+	indexName: text().notNull(),
+	keyDefinitionHash: text().notNull(),
+	metricDefinitionHash: text().notNull(),
+	status: text().notNull(),
+	cursor: text(),
+	processed: integer().notNull(),
+	startedAt: integer().notNull(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	lastError: text()
+}, (t) => [index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName), index("by_kind_status").on(t.kind, t.status)]);
+const rankTreeTable = convexTable(AGGREGATE_RANK_TREE_TABLE, {
+	aggregateName: text().notNull(),
+	maxNodeSize: integer().notNull(),
+	namespace: json(),
+	root: id(AGGREGATE_RANK_NODE_TABLE).notNull()
+}, (tree) => [index("by_namespace").on(tree.namespace), index("by_aggregate_name").on(tree.aggregateName)]);
+const rankNodeTable = convexTable(AGGREGATE_RANK_NODE_TABLE, {
+	aggregate: objectOf({
+		count: integer().notNull(),
+		sum: integer().notNull()
+	}),
+	items: arrayOf(objectOf({
+		k: json(),
+		v: json(),
+		s: integer().notNull()
+	})).notNull(),
+	subtrees: arrayOf(text().notNull()).notNull()
+});
+const aggregateStorageTables = {
+	[AGGREGATE_BUCKET_TABLE]: countBucketTable,
+	[AGGREGATE_MEMBER_TABLE]: countMemberTable,
+	[AGGREGATE_EXTREMA_TABLE]: countExtremaTable,
+	[AGGREGATE_RANK_TREE_TABLE]: rankTreeTable,
+	[AGGREGATE_RANK_NODE_TABLE]: rankNodeTable,
+	[AGGREGATE_STATE_TABLE]: countStateTable
+};
+function aggregateExtension() {
+	return defineSchemaExtension("aggregate", aggregateStorageTables);
+}
+
+//#endregion
+//#region src/orm/migrations/schema.ts
+const MIGRATION_STATE_TABLE = "migration_state";
+const MIGRATION_RUN_TABLE = "migration_run";
+const migrationStateTable = convexTable(MIGRATION_STATE_TABLE, {
+	migrationId: text().notNull(),
+	checksum: text().notNull(),
+	applied: boolean$1().notNull(),
+	status: text().notNull(),
+	direction: text(),
+	runId: text(),
+	cursor: text(),
+	processed: integer().notNull(),
+	startedAt: integer(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	lastError: text(),
+	writeMode: text().notNull()
+}, (t) => [index("by_migration_id").on(t.migrationId), index("by_status").on(t.status)]);
+const migrationRunTable = convexTable(MIGRATION_RUN_TABLE, {
+	runId: text().notNull(),
+	direction: text().notNull(),
+	status: text().notNull(),
+	dryRun: boolean$1().notNull(),
+	allowDrift: boolean$1().notNull(),
+	migrationIds: custom(v.array(v.string())).notNull(),
+	currentIndex: integer().notNull(),
+	startedAt: integer().notNull(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	cancelRequested: boolean$1().notNull(),
+	lastError: text()
+}, (t) => [index("by_run_id").on(t.runId), index("by_status").on(t.status)]);
+const migrationStorageTables = {
+	[MIGRATION_STATE_TABLE]: migrationStateTable,
+	[MIGRATION_RUN_TABLE]: migrationRunTable
+};
+function migrationExtension() {
+	return defineSchemaExtension("migration", migrationStorageTables);
+}
+
+//#endregion
+//#region src/orm/relations.ts
+var RelationsBuilderTable = class {
+	static [entityKind] = "RelationsBuilderTable";
+	_;
+	constructor(table, name) {
+		this._ = {
+			name,
+			table
+		};
+	}
+};
+var RelationsBuilderColumn = class {
+	static [entityKind] = "RelationsBuilderColumn";
+	_;
+	constructor(column, tableName, key) {
+		this._ = {
+			tableName,
+			column,
+			key
+		};
+	}
+	through(column) {
+		return new RelationsBuilderJunctionColumn(this._.column, this._.tableName, this._.key, column);
+	}
+};
+var RelationsBuilderJunctionColumn = class {
+	static [entityKind] = "RelationsBuilderColumn";
+	_;
+	constructor(column, tableName, key, through) {
+		this._ = {
+			tableName,
+			column,
+			through,
+			key
+		};
+	}
+};
+var RelationsHelperStatic = class {
+	static [entityKind] = "RelationsHelperStatic";
+	constructor(tables) {
+		const one = {};
+		const many = {};
+		for (const [tableName, table] of Object.entries(tables)) {
+			one[tableName] = (config) => new One(tables, table, tableName, config);
+			many[tableName] = (config) => new Many(tables, table, tableName, config);
+		}
+		this.one = one;
+		this.many = many;
+	}
+	one;
+	many;
+};
+function createRelationsHelper(tables) {
+	const helperStatic = new RelationsHelperStatic(tables);
+	const relationsTables = Object.entries(tables).reduce((acc, [tKey, value]) => {
+		const rTable = new RelationsBuilderTable(value, tKey);
+		const columns = Object.entries(getTableColumns(value)).reduce((colsAcc, [cKey, column]) => {
+			colsAcc[cKey] = new RelationsBuilderColumn(column, tKey, cKey);
+			return colsAcc;
+		}, {});
+		const relationsTable = Object.assign(rTable, columns);
+		Object.defineProperty(relationsTable, "_id", {
+			get() {
+				throw new Error("`_id` is no longer public in relations. Use `id`.");
+			},
+			enumerable: false,
+			configurable: false
+		});
+		acc[tKey] = relationsTable;
+		return acc;
+	}, {});
+	return Object.assign(helperStatic, relationsTables);
+}
+function extractTablesFromSchema(schema) {
+	const schemaTables = schema && typeof schema === "object" && !Array.isArray(schema) && "tables" in schema && schema.tables && typeof schema.tables === "object" && !Array.isArray(schema.tables) ? schema.tables : schema;
+	return Object.fromEntries(Object.entries(schemaTables).filter(([_, e]) => isConvexTable(e)));
+}
+var Relation = class {
+	static [entityKind] = "RelationV2";
+	fieldName;
+	sourceColumns;
+	targetColumns;
+	alias;
+	where;
+	sourceTable;
+	targetTable;
+	through;
+	throughTable;
+	isReversed;
+	/** @internal */
+	sourceColumnTableNames = [];
+	/** @internal */
+	targetColumnTableNames = [];
+	constructor(targetTable, targetTableName) {
+		this.targetTableName = targetTableName;
+		this.targetTable = targetTable;
+	}
+};
+var One = class extends Relation {
+	static [entityKind] = "OneV2";
+	relationType = "one";
+	optional;
+	constructor(tables, targetTable, targetTableName, config) {
+		super(targetTable, targetTableName);
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.sourceColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.targetColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (this.throughTable) this.through = {
+			source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+			target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+		};
+		this.optional = config?.optional ?? true;
+	}
+};
+var Many = class extends Relation {
+	static [entityKind] = "ManyV2";
+	relationType = "many";
+	constructor(tables, targetTable, targetTableName, config) {
+		super(targetTable, targetTableName);
+		this.config = config;
+		this.alias = config?.alias;
+		this.where = config?.where;
+		if (config?.from) this.sourceColumns = (Array.isArray(config.from) ? config.from : [config.from]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.sourceColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (config?.to) this.targetColumns = (Array.isArray(config.to) ? config.to : [config.to]).map((it) => {
+			this.throughTable ??= it._.through ? tables[it._.through._.tableName] : void 0;
+			this.targetColumnTableNames.push(it._.tableName);
+			return it._.column;
+		});
+		if (this.throughTable) this.through = {
+			source: (Array.isArray(config?.from) ? config.from : config?.from ? [config.from] : []).map((c) => c._.through),
+			target: (Array.isArray(config?.to) ? config.to : config?.to ? [config.to] : []).map((c) => c._.through)
+		};
+	}
+};
+function buildRelations(tables, config, strict, defaults) {
+	const tablesConfig = {};
+	for (const [tsName, table] of Object.entries(tables)) tablesConfig[tsName] = {
+		table,
+		name: tsName,
+		polymorphic: table[TablePolymorphic],
+		relations: config[tsName] ?? {},
+		strict,
+		defaults
+	};
+	return processRelations(tablesConfig, tables);
+}
+function defineRelations(schema, relations) {
+	const tables = extractTablesFromSchema(schema);
+	const schemaOptions = schema[OrmSchemaOptions];
+	const strict = schemaOptions?.strict ?? true;
+	const defaults = schemaOptions?.defaults;
+	const schemaDefinition = schema[OrmSchemaDefinition];
+	const pluginTableNames = schema[OrmSchemaExtensionTables];
+	const plugins = schema[OrmSchemaExtensions];
+	const tablesConfig = buildRelations(tables, relations ? relations(createRelationsHelper(tables)) : {}, strict, defaults);
+	Object.defineProperty(tablesConfig, OrmSchemaOptions, {
+		value: {
+			strict,
+			defaults
+		},
+		enumerable: false
+	});
+	if (schemaDefinition) Object.defineProperty(tablesConfig, OrmSchemaDefinition, {
+		value: schemaDefinition,
+		enumerable: false
+	});
+	if (pluginTableNames) Object.defineProperty(tablesConfig, OrmSchemaExtensionTables, {
+		value: pluginTableNames,
+		enumerable: false
+	});
+	if (plugins) Object.defineProperty(tablesConfig, OrmSchemaExtensions, {
+		value: plugins,
+		enumerable: false
+	});
+	return tablesConfig;
+}
+function processRelations(tablesConfig, tables) {
+	for (const tableConfig of Object.values(tablesConfig)) for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+		if (!isRelation(relation)) continue;
+		relation.sourceTable = tableConfig.table;
+		relation.fieldName = relationFieldName;
+	}
+	for (const [sourceTableName, tableConfig] of Object.entries(tablesConfig)) for (const [relationFieldName, relation] of Object.entries(tableConfig.relations)) {
+		if (!isRelation(relation)) continue;
+		let reverseRelation;
+		const { targetTableName, alias, sourceColumns, targetColumns, throughTable, sourceTable, through, where, sourceColumnTableNames, targetColumnTableNames } = relation;
+		const relationPrintName = `relations -> ${tableConfig.name}: { ${relationFieldName}: r.${relation.relationType === "one" ? "one" : "many"}.${targetTableName}(...) }`;
+		if (relationFieldName in getTableColumns(tableConfig.table)) throw new Error(`${relationPrintName}: relation name collides with column "${relationFieldName}" of table "${tableConfig.name}"`);
+		if (typeof alias === "string" && !alias) throw new Error(`${relationPrintName}: "alias" cannot be empty`);
+		if (sourceColumns?.length === 0) throw new Error(`${relationPrintName}: "from" cannot be empty`);
+		if (targetColumns?.length === 0) throw new Error(`${relationPrintName}: "to" cannot be empty`);
+		if (sourceColumns && targetColumns) {
+			if (sourceColumns.length !== targetColumns.length && !throughTable) throw new Error(`${relationPrintName}: "from" and "to" must have same length`);
+			for (const sName of sourceColumnTableNames) if (sName !== sourceTableName) throw new Error(`${relationPrintName}: all "from" columns must belong to table "${sourceTableName}", found "${sName}"`);
+			for (const tName of targetColumnTableNames) if (tName !== targetTableName) throw new Error(`${relationPrintName}: all "to" columns must belong to table "${targetTableName}", found "${tName}"`);
+			if (through) {
+				if (through.source.length !== sourceColumns.length || through.target.length !== targetColumns.length) throw new Error(`${relationPrintName}: .through() must be used on all columns in "from" and "to" or none`);
+				for (const column of through.source) if (tables[column._.tableName] !== throughTable) throw new Error(`${relationPrintName}: .through() must use same table for all columns`);
+				for (const column of through.target) if (tables[column._.tableName] !== throughTable) throw new Error(`${relationPrintName}: .through() must use same table for all columns`);
+			}
+			continue;
+		}
+		if (sourceColumns || targetColumns) throw new Error(`${relationPrintName}: relation must have both "from" and "to" or none`);
+		const reverseTableConfig = tablesConfig[targetTableName];
+		if (!reverseTableConfig) throw new Error(`${relationPrintName}: missing "from"/"to" and no reverse relation found for "${targetTableName}"`);
+		if (alias) {
+			const reverseRelations = Object.values(reverseTableConfig.relations).filter((it) => isRelation(it) && it.alias === alias && it !== relation);
+			if (reverseRelations.length > 1) throw new Error(`${relationPrintName}: multiple reverse relations with alias "${alias}" found`);
+			reverseRelation = reverseRelations[0];
+			if (!reverseRelation) throw new Error(`${relationPrintName}: no reverse relation with alias "${alias}" found in "${targetTableName}"`);
+		} else {
+			const reverseRelations = Object.values(reverseTableConfig.relations).filter((it) => isRelation(it) && it.targetTable === sourceTable && !it.alias && it !== relation);
+			if (reverseRelations.length > 1) throw new Error(`${relationPrintName}: multiple relations between "${targetTableName}" and "${sourceTableName}"; use alias`);
+			reverseRelation = reverseRelations[0];
+			if (!reverseRelation) throw new Error(`${relationPrintName}: no reverse relation between "${targetTableName}" and "${sourceTableName}"`);
+		}
+		if (!reverseRelation.sourceColumns || !reverseRelation.targetColumns) throw new Error(`${relationPrintName}: reverse relation "${targetTableName}.${reverseRelation.fieldName}" missing "from"/"to"`);
+		relation.sourceColumns = reverseRelation.targetColumns;
+		relation.targetColumns = reverseRelation.sourceColumns;
+		relation.through = reverseRelation.through ? {
+			source: reverseRelation.through.target,
+			target: reverseRelation.through.source
+		} : void 0;
+		relation.throughTable = reverseRelation.throughTable;
+		relation.isReversed = !where;
+		relation.where = where ?? reverseRelation.where;
+	}
+	return tablesConfig;
+}
+function isConvexTable(value) {
+	return typeof value === "object" && value !== null && "tableName" in value && Columns in value;
+}
+function isRelation(value) {
+	return value instanceof Relation;
+}
+function getTableColumns(table) {
+	const columns = table[Columns];
+	const system = {};
+	if (table.id) system.id = table.id;
+	if (table.createdAt || table._creationTime) system.createdAt = table._creationTime ?? table.createdAt;
+	return {
+		...columns,
+		...system
+	};
+}
+
+//#endregion
+//#region src/orm/triggers.ts
+function defineTriggers(schema, triggers) {
+	return triggers;
+}
+
+//#endregion
+//#region src/orm/schema.ts
+const BUILTIN_SCHEMA_EXTENSIONS = [aggregateExtension(), migrationExtension()];
+function resolveSchemaExtensions(extensions) {
+	const resolved = [...BUILTIN_SCHEMA_EXTENSIONS, ...extensions ?? []];
+	const seen = /* @__PURE__ */ new Set();
+	for (const extension of resolved) {
+		if (seen.has(extension.key)) throw new Error(`defineSchema received duplicate extension '${extension.key}'. Remove duplicate extension registrations.`);
+		seen.add(extension.key);
+	}
+	return resolved;
+}
+function mergeRelationConfigs(sources) {
+	const merged = {};
+	const relationOrigins = /* @__PURE__ */ new Map();
+	for (const { source, config } of sources) for (const [tableName, relationConfig] of Object.entries(config)) {
+		if (!relationConfig) continue;
+		let tableRelations = merged[tableName];
+		if (!tableRelations) {
+			tableRelations = Object.create(null);
+			merged[tableName] = tableRelations;
+		}
+		for (const [fieldName, relation] of Object.entries(relationConfig)) {
+			const relationKey = `${tableName}.${fieldName}`;
+			const existingSource = relationOrigins.get(relationKey);
+			if (existingSource) throw new Error(`defineSchema relation field '${relationKey}' is defined more than once (${existingSource} and ${source}).`);
+			tableRelations[fieldName] = relation;
+			relationOrigins.set(relationKey, source);
+		}
+	}
+	return merged;
+}
+function mergeTriggerConfigs(sources) {
+	const merged = {};
+	const triggerOrigins = /* @__PURE__ */ new Map();
+	for (const { source, config } of sources) for (const [tableName, tableConfig] of Object.entries(config)) {
+		if (!tableConfig || typeof tableConfig !== "object" || Array.isArray(tableConfig)) {
+			const triggerKey = `${tableName}`;
+			const existingSource = triggerOrigins.get(triggerKey);
+			if (existingSource) throw new Error(`defineSchema trigger '${triggerKey}' is defined more than once (${existingSource} and ${source}).`);
+			merged[tableName] = tableConfig;
+			triggerOrigins.set(triggerKey, source);
+			continue;
+		}
+		let mergedTable = merged[tableName];
+		if (!mergedTable) {
+			mergedTable = Object.create(null);
+			merged[tableName] = mergedTable;
+		}
+		for (const [hookKey, hookValue] of Object.entries(tableConfig)) {
+			if ((hookKey === "create" || hookKey === "update" || hookKey === "delete") && hookValue && typeof hookValue === "object" && !Array.isArray(hookValue)) {
+				let mergedOperation = mergedTable[hookKey];
+				if (!mergedOperation || typeof mergedOperation !== "object") {
+					mergedOperation = Object.create(null);
+					mergedTable[hookKey] = mergedOperation;
+				}
+				for (const [operationHookKey, operationHookValue] of Object.entries(hookValue)) {
+					const triggerKey = `${tableName}.${hookKey}.${operationHookKey}`;
+					const existingSource = triggerOrigins.get(triggerKey);
+					if (existingSource) throw new Error(`defineSchema trigger '${triggerKey}' is defined more than once (${existingSource} and ${source}).`);
+					mergedOperation[operationHookKey] = operationHookValue;
+					triggerOrigins.set(triggerKey, source);
+				}
+				continue;
+			}
+			const triggerKey = `${tableName}.${hookKey}`;
+			const existingSource = triggerOrigins.get(triggerKey);
+			if (existingSource) throw new Error(`defineSchema trigger '${triggerKey}' is defined more than once (${existingSource} and ${source}).`);
+			mergedTable[hookKey] = hookValue;
+			triggerOrigins.set(triggerKey, source);
+		}
+	}
+	return merged;
+}
+function defineMetadata(target, key, value) {
+	const existing = Object.getOwnPropertyDescriptor(target, key);
+	if (existing && !existing.configurable) return;
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: false,
+		configurable: true
+	});
+}
+const OrmSchemaComposerState = Symbol("kitcn:OrmSchemaComposerState");
+function getSchemaComposerState(schema) {
+	if (!schema || typeof schema !== "object") return;
+	return schema[OrmSchemaComposerState];
+}
+function finalizeSchemaMetadata(schema) {
+	if (!schema || typeof schema !== "object") return;
+	const composerState = getSchemaComposerState(schema);
+	if (!composerState) return;
+	const schemaObject = schema;
+	const resolvedExtensions = schemaObject[OrmSchemaExtensions] ?? resolveSchemaExtensions(composerState.extensions);
+	const extensionTableNames = schemaObject[OrmSchemaExtensionTables] ?? Object.freeze([]);
+	const options = schemaObject[OrmSchemaOptions];
+	const extensionRelationFactories = resolvedExtensions.map((extension) => ({
+		key: extension.key,
+		relations: extension[OrmSchemaExtensionRelations]
+	})).filter((entry) => entry.relations !== void 0);
+	const extensionTriggerFactories = resolvedExtensions.map((extension) => ({
+		key: extension.key,
+		triggers: extension[OrmSchemaExtensionTriggers]
+	})).filter((entry) => entry.triggers !== void 0);
+	const hasExtensionRelations = extensionRelationFactories.length > 0;
+	const hasExtensionTriggers = extensionTriggerFactories.length > 0;
+	const shouldBuildRelations = hasExtensionRelations || hasExtensionTriggers || Boolean(composerState.relations) || Boolean(composerState.triggers);
+	let relations = schemaObject[OrmSchemaRelations];
+	if (!relations && shouldBuildRelations) {
+		relations = hasExtensionRelations || composerState.relations ? defineRelations(schema, (helpers) => mergeRelationConfigs([...extensionRelationFactories.map((extension) => ({
+			source: `extension '${extension.key}'`,
+			config: extension.relations(helpers)
+		})), ...composerState.relations ? [{
+			source: "schema.relations()",
+			config: composerState.relations(helpers)
+		}] : []])) : defineRelations(schema);
+		defineMetadata(relations, OrmSchemaDefinition, schema);
+		if (options) defineMetadata(relations, OrmSchemaOptions, options);
+		defineMetadata(relations, OrmSchemaExtensionTables, extensionTableNames);
+		defineMetadata(relations, OrmSchemaExtensions, resolvedExtensions);
+		defineMetadata(schema, OrmSchemaRelations, relations);
+	}
+	if (!relations || schemaObject[OrmSchemaTriggers]) return;
+	const triggerSources = hasExtensionTriggers || composerState.triggers ? [...extensionTriggerFactories.map((extension) => ({
+		source: `extension '${extension.key}'`,
+		config: typeof extension.triggers === "function" ? extension.triggers(relations) : extension.triggers
+	})), ...composerState.triggers ? [{
+		source: "schema.triggers()",
+		config: composerState.triggers
+	}] : []] : [];
+	if (triggerSources.length === 0) return;
+	defineMetadata(schema, OrmSchemaTriggers, defineTriggers(relations, mergeTriggerConfigs(triggerSources)));
+}
+function getSchemaRelations(schema) {
+	if (!schema || typeof schema !== "object") return;
+	finalizeSchemaMetadata(schema);
+	return schema[OrmSchemaRelations];
+}
+function getSchemaTriggers(schema) {
+	if (!schema || typeof schema !== "object") return;
+	finalizeSchemaMetadata(schema);
+	return schema[OrmSchemaTriggers];
+}
+
+//#endregion
+//#region src/cli/utils/highlighter.ts
+const isTruthyEnvFlag = (value) => value !== void 0 && value !== "" && value !== "0";
+const isColorEnabled = () => {
+	if (process.env.FORCE_COLOR === "0") return false;
+	if (isTruthyEnvFlag(process.env.FORCE_COLOR)) return true;
+	if (isTruthyEnvFlag(process.env.NO_COLOR)) return false;
+	return Boolean(process.stdout.isTTY && process.env.TERM !== "dumb");
+};
+const withColors = (callback) => callback(createColors(isColorEnabled()));
+const highlighter = {
+	bold(value) {
+		return withColors((colors) => colors.bold(value));
+	},
+	dim(value) {
+		return withColors((colors) => colors.dim(value));
+	},
+	info(value) {
+		return withColors((colors) => colors.cyan(value));
+	},
+	success(value) {
+		return withColors((colors) => colors.green(value));
+	},
+	warn(value) {
+		return withColors((colors) => colors.yellow(value));
+	},
+	error(value) {
+		return withColors((colors) => colors.red(value));
+	},
+	path(value) {
+		return withColors((colors) => colors.bold(value));
+	}
+};
+
+//#endregion
+//#region src/cli/utils/lazy-deps.ts
+/**
+* Heavy CLI-only dependencies, resolved on first use instead of at module init.
+*
+* `kitcn --version`, `kitcn --help` and every `--json` call an agent makes must
+* not pay to boot esbuild's native service, Babel's parser, jiti, dotenv or the
+* interactive prompt stack — the CLI is non-interactive by default and most
+* commands touch none of them.
+*
+* Each accessor is memoized and stays synchronous so call sites keep their
+* current signatures, and each dependency is loaded through exactly one
+* mechanism: `@clack/prompts` compares against a module-private `Symbol` in
+* `isCancel`, so a second copy of the module would silently break cancellation.
+*/
+const require$1 = createRequire(import.meta.url);
+let babelParser;
+let clackPrompts;
+let dotenv;
+let esbuild;
+let jiti;
+const loadBabelParser = () => babelParser ??= require$1("@babel/parser");
+const loadClackPrompts = () => clackPrompts ??= require$1("@clack/prompts");
+const loadDotenv = () => dotenv ??= require$1("dotenv");
+const loadEsbuild = () => esbuild ??= require$1("esbuild");
+const loadJiti = () => jiti ??= require$1("jiti");
+
+//#endregion
+//#region src/cli/utils/crpc-builder-stub.ts
+const CRPC_BUILDER_STUB_SOURCE = `const createMiddleware = (handler = undefined) => ({
+  _handler: handler,
+  pipe(nextHandler = undefined) {
+    return createMiddleware(nextHandler);
+  },
+});
+
+const toMetaObject = (value = undefined) =>
+  value && typeof value === "object" ? value : {};
+
+const createProcedureExport = (type, state, handler) => ({
+  _crpcMeta: {
+    type,
+    internal: state.internal ?? false,
+    ...toMetaObject(state.meta),
+  },
+  ...(state.httpRoute ? { _crpcHttpRoute: state.httpRoute } : {}),
+  _handler: handler,
+});
+
+const createProcedureBuilder = (state = {}) => {
+  const builder = {
+    internal() {
+      return createProcedureBuilder({ ...state, internal: true });
+    },
+    use() {
+      return createProcedureBuilder(state);
+    },
+    meta(value = undefined) {
+      return createProcedureBuilder({
+        ...state,
+        meta: {
+          ...toMetaObject(state.meta),
+          ...toMetaObject(value),
+        },
+      });
+    },
+    input() {
+      return createProcedureBuilder(state);
+    },
+    params() {
+      return createProcedureBuilder(state);
+    },
+    searchParams() {
+      return createProcedureBuilder(state);
+    },
+    paginated(options = undefined) {
+      return createProcedureBuilder({
+        ...state,
+        meta:
+          typeof options?.limit === "number"
+            ? {
+                ...toMetaObject(state.meta),
+                limit: options.limit,
+              }
+            : state.meta,
+      });
+    },
+    output() {
+      return createProcedureBuilder(state);
+    },
+    form() {
+      return createProcedureBuilder(state);
+    },
+    route(path, method) {
+      return createProcedureBuilder({
+        ...state,
+        httpRoute:
+          typeof path === "string" && typeof method === "string"
+            ? { path, method: method.toUpperCase() }
+            : undefined,
+      });
+    },
+    get(path) {
+      return builder.route(path, "GET");
+    },
+    post(path) {
+      return builder.route(path, "POST");
+    },
+    put(path) {
+      return builder.route(path, "PUT");
+    },
+    patch(path) {
+      return builder.route(path, "PATCH");
+    },
+    delete(path) {
+      return builder.route(path, "DELETE");
+    },
+    query(handler = undefined) {
+      return createProcedureExport("query", state, handler);
+    },
+    mutation(handler = undefined) {
+      return createProcedureExport("mutation", state, handler);
+    },
+    action(handler = undefined) {
+      return createProcedureExport("action", state, handler);
+    },
+    middleware(handler = undefined) {
+      return createMiddleware(handler);
+    },
+  };
+
+  return builder;
+};
+
+const flattenRouterRecord = (record = {}, prefix = "") => {
+  const procedures = {};
+  for (const [key, value] of Object.entries(record)) {
+    const procedurePath = prefix ? prefix + "." + key : key;
+    if (value?._def?.router === true) {
+      Object.assign(
+        procedures,
+        flattenRouterRecord(value._def.record ?? {}, procedurePath)
+      );
+      continue;
+    }
+    procedures[procedurePath] = value;
+  }
+  return procedures;
+};
+
+const createRouter = (record = {}) => ({
+  _def: {
+    router: true,
+    procedures: flattenRouterRecord(record),
+    record,
+  },
+});
+
+export const initCRPC = {
+  meta() {
+    return this;
+  },
+  dataModel() {
+    return this;
+  },
+  context() {
+    return this;
+  },
+  middleware(handler = undefined) {
+    return createMiddleware(handler);
+  },
+  create() {
+    return {
+      query: createProcedureBuilder(),
+      mutation: createProcedureBuilder(),
+      action: createProcedureBuilder(),
+      httpAction: createProcedureBuilder(),
+      middleware: createMiddleware,
+      router: createRouter,
+    };
+  },
+};
+
+export const httpAction = createProcedureBuilder();
+`;
+
+//#endregion
+//#region src/cli/utils/project-jiti.ts
+const require = createRequire(import.meta.url);
+const JITI_EXPORT_CONDITION_PRIORITY = [
+	"bun",
+	"import",
+	"module",
+	"default",
+	"require"
+];
+const SERVER_PARSER_SHIM_SOURCE = `${CRPC_BUILDER_STUB_SOURCE}
+
+export class CRPCError extends Error {
+  constructor(options = {}) {
+    super(options.message ?? options.code ?? "CRPC error");
+    this.code = options.code;
+  }
+}
+
+export const createEnv = ({ schema }) => () =>
+  typeof schema?.parse === "function" ? schema.parse(process.env) : process.env;
+export const createHttpRouter = (_app, httpRouter) => httpRouter ?? {};
+export const createCallerFactory = () => () => ({});
+export const createApiLeaf = (fnOrRoot, pathOrMeta, maybeMeta) => {
+  const meta = maybeMeta ?? pathOrMeta;
+  const fn = Array.isArray(pathOrMeta)
+    ? pathOrMeta.reduce((current, segment) => current?.[segment], fnOrRoot)
+    : fnOrRoot;
+  return Object.assign(fn ?? {}, meta ?? {}, { functionRef: fn });
+};
+export const createGeneratedFunctionReference = (name) => ({
+  [Symbol.for("functionName")]: name,
+});
+export const registerProcedureNameLookup = () => {};
+export const typedProcedureResolver = (_functionRef, resolver) => resolver;
+export const createGeneratedRegistryRuntime = () => ({
+  getCallerFactory() {
+    return () => ({});
+  },
+  getHandlerFactory() {
+    return () => ({});
+  },
+});
+`;
+const resolveJitiExportTarget = (target) => {
+	if (typeof target === "string") return target;
+	if (Array.isArray(target)) {
+		for (const entry of target) {
+			const resolved = resolveJitiExportTarget(entry);
+			if (resolved) return resolved;
+		}
+		return null;
+	}
+	if (!target || typeof target !== "object") return null;
+	const record = target;
+	for (const condition of JITI_EXPORT_CONDITION_PRIORITY) {
+		const resolved = resolveJitiExportTarget(record[condition]);
+		if (resolved) return resolved;
+	}
+	for (const value of Object.values(record)) {
+		const resolved = resolveJitiExportTarget(value);
+		if (resolved) return resolved;
+	}
+	return null;
+};
+const buildLocalPackageExportAliases = (cwd, packageName) => {
+	const packageDir = path.join(cwd, "node_modules", ...packageName.split("/"));
+	const packageJsonPath = path.join(packageDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) return {};
+	const exportsField = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).exports;
+	if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField)) return {};
+	const aliases = {};
+	for (const [exportKey, exportTarget] of Object.entries(exportsField)) {
+		const resolvedTarget = resolveJitiExportTarget(exportTarget);
+		if (!resolvedTarget || !resolvedTarget.startsWith("./")) continue;
+		const specifier = exportKey === "." ? packageName : exportKey.startsWith("./") ? `${packageName}${exportKey.slice(1)}` : null;
+		if (!specifier) continue;
+		aliases[specifier] = path.join(packageDir, resolvedTarget);
+	}
+	return aliases;
+};
+const ensureServerParserShim = (cwd) => {
+	const shimDir = path.join(cwd, "node_modules", ".kitcn");
+	const shimPath = path.join(shimDir, "project-jiti-server-shim.mjs");
+	fs.mkdirSync(shimDir, { recursive: true });
+	if (!fs.existsSync(shimPath) || fs.readFileSync(shimPath, "utf8") !== SERVER_PARSER_SHIM_SOURCE) fs.writeFileSync(shimPath, SERVER_PARSER_SHIM_SOURCE, "utf8");
+	return shimPath;
+};
+const trimTsconfigWildcardSuffix = (value) => value.endsWith("/*") ? value.slice(0, -2) : value;
+const loadTypeScript = () => {
+	try {
+		return require("typescript");
+	} catch {
+		return null;
+	}
+};
+const buildTsconfigPathAliases = (cwd) => {
+	const typescript = loadTypeScript();
+	if (!typescript) return {};
+	const configPath = typescript.findConfigFile(cwd, fs.existsSync, "tsconfig.json");
+	if (!configPath) return {};
+	const readResult = typescript.readConfigFile(configPath, typescript.sys.readFile);
+	if (readResult.error) return {};
+	const parsedConfig = typescript.parseJsonConfigFileContent(readResult.config, typescript.sys, path.dirname(configPath));
+	const baseUrl = typeof parsedConfig.options.baseUrl === "string" && parsedConfig.options.baseUrl.length > 0 ? parsedConfig.options.baseUrl : path.dirname(configPath);
+	const paths = parsedConfig.options.paths;
+	if (!paths) return {};
+	const aliases = {};
+	for (const [specifier, targets] of Object.entries(paths)) {
+		const firstTarget = targets[0];
+		if (!firstTarget) continue;
+		const aliasKey = trimTsconfigWildcardSuffix(specifier);
+		const aliasTarget = trimTsconfigWildcardSuffix(firstTarget);
+		if (!aliasKey || aliasKey === "*") continue;
+		aliases[aliasKey] = path.resolve(baseUrl, aliasTarget);
+	}
+	return aliases;
+};
+const getProjectServerParserShimPath = (cwd = process.cwd()) => ensureServerParserShim(cwd);
+const createProjectJiti = (cwd = process.cwd()) => loadJiti().createJiti(cwd, {
+	interopDefault: true,
+	jsx: { runtime: "automatic" },
+	moduleCache: false,
+	tryNative: false,
+	alias: {
+		...buildTsconfigPathAliases(cwd),
+		...buildLocalPackageExportAliases(cwd, "kitcn"),
+		...buildLocalPackageExportAliases(cwd, "convex"),
+		"kitcn/server": getProjectServerParserShimPath(cwd)
+	}
+});
+
+//#endregion
+//#region src/shared/meta-utils.ts
+/**
+* Suffix of a parse snapshot — a mirror of a Convex module that kitcn builds
+* predating in-memory evaluation could strand in a project. Codegen writes no
+* snapshot, so this exists only so readers of the Convex functions directory
+* skip a stranded file rather than parse it as a real module. Nothing deletes
+* one: kitcn cannot prove it owns a file it did not write.
+*/
+const PARSE_SNAPSHOT_SUFFIX = ".kitcn-parse.ts";
+/** Files to exclude from meta generation */
+const EXCLUDED_FILES = new Set([
+	"schema.ts",
+	"auth.ts",
+	"generated.ts",
+	"convex.config.ts",
+	"auth.config.ts"
+]);
+const EXPORTED_CONST_CAPTURE_REGEX = /export\s+const\s+([a-zA-Z_$][\w$]*)\s*=/g;
+const CHAINED_PROCEDURE_CAPTURE_REGEX = /\.\s*(?:query|mutation|action)\s*\(/;
+const EXPORTED_NATIVE_HANDLER_CAPTURE_REGEX = /export\s+const\s+([a-zA-Z_$][\w$]*)\s*=\s*(?:[\w$]+\.)?(?:query|mutation|action|internalQuery|internalMutation|internalAction)\s*\(/g;
+const EXPORTED_ORM_API_DESTRUCTURE_CAPTURE_REGEX = /export\s+const\s*\{([^}]+)\}\s*=\s*orm\.api\s*\(\s*\)\s*;?/g;
+const DIRECT_CODEGEN_META_CAPTURE_REGEX = /\b_crpc(?:Meta|HttpRoute)\b/;
+/**
+* Check if a file path should be included in meta generation.
+* Filters out private files/directories (prefixed with _) and config files.
+*/
+function isValidConvexFile(file) {
+	if (file.endsWith(PARSE_SNAPSHOT_SUFFIX)) return false;
+	if (file.endsWith(".runtime.ts")) return false;
+	if (file.endsWith(".test.ts")) return false;
+	if (file.endsWith(".spec.ts")) return false;
+	if (file.endsWith(".testing.ts")) return false;
+	if (file.endsWith(".typecheck.ts")) return false;
+	if (file.startsWith("generated/")) return false;
+	if (file.startsWith("_") || file.includes("/_")) return false;
+	const basename = file.split("/").pop() ?? "";
+	if (EXCLUDED_FILES.has(basename)) return false;
+	return true;
+}
+function hasPotentialCodegenExports(source, filePath) {
+	const normalizedFilePath = filePath?.replace(/\\/g, "/");
+	if (normalizedFilePath === "http.ts" || normalizedFilePath?.endsWith("/http.ts")) return true;
+	if (DIRECT_CODEGEN_META_CAPTURE_REGEX.test(source)) return true;
+	if (Array.from(source.matchAll(EXPORTED_NATIVE_HANDLER_CAPTURE_REGEX)).length) return true;
+	if (Array.from(source.matchAll(EXPORTED_ORM_API_DESTRUCTURE_CAPTURE_REGEX)).length) return true;
+	const exportConstMatches = Array.from(source.matchAll(EXPORTED_CONST_CAPTURE_REGEX));
+	for (const [index, match] of exportConstMatches.entries()) {
+		const start = (match.index ?? 0) + match[0].length;
+		const end = exportConstMatches[index + 1]?.index ?? source.length;
+		if (CHAINED_PROCEDURE_CAPTURE_REGEX.test(source.slice(start, end))) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/cli/utils/logger.ts
+const joinArgs = (args) => args.map(String).join(" ");
+const logger = {
+	error(...args) {
+		console.error(highlighter.error(joinArgs(args)));
+	},
+	warn(...args) {
+		console.warn(highlighter.warn(joinArgs(args)));
+	},
+	info(...args) {
+		console.info(highlighter.info(joinArgs(args)));
+	},
+	success(...args) {
+		console.info(highlighter.success(joinArgs(args)));
+	},
+	log(...args) {
+		console.info(joinArgs(args));
+	},
+	write(value) {
+		console.info(value);
+	},
+	break() {
+		console.info("");
+	}
+};
+
+//#endregion
+//#region src/cli/codegen.ts
+/** Valid JS identifier pattern for object keys */
+const VALID_IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+/** Valid JS identifier start pattern */
+const IDENTIFIER_START_RE = /^[a-zA-Z_$]/;
+/** Pattern to strip .ts extension */
+const TS_EXTENSION_RE = /\.ts$/;
+/** Pattern to detect default exports in auth contract files. */
+const DEFAULT_EXPORT_RE = /\bexport\s+default\b/;
+const MISSING_KITCN_IMPORT_RE = /Cannot find (?:module|package) ['"]kitcn(?:\/[^'"]+)?['"]/;
+const RUNTIME_CALLER_RESERVED_EXPORTS = new Set(["actions", "schedule"]);
+const DEFAULT_TRIM_SEGMENTS = ["plugins", "generated"];
+const CODEGEN_SCOPES$1 = new Set([
+	"all",
+	"auth",
+	"orm"
+]);
+function normalizeCodegenScope(scope) {
+	const normalized = scope ?? "all";
+	if (CODEGEN_SCOPES$1.has(normalized)) return normalized;
+	throw new Error(`Invalid codegen scope "${normalized}". Expected one of: all, auth, orm.`);
+}
+function shouldGenerateApi(scope) {
+	return scope === "all";
+}
+function shouldGenerateAuth(scope) {
+	return scope !== "orm";
+}
+function resolveGenerationMode(options) {
+	const scope = normalizeCodegenScope(options?.scope);
+	return {
+		generateApi: shouldGenerateApi(scope),
+		generateAuth: shouldGenerateAuth(scope),
+		modeLabel: scope
+	};
+}
+const AUTH_RUNTIME_PROCEDURES = [
+	{
+		exportName: "create",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "deleteMany",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "deleteOne",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "findMany",
+		internal: true,
+		type: "query"
+	},
+	{
+		exportName: "findOne",
+		internal: true,
+		type: "query"
+	},
+	{
+		exportName: "getLatestJwks",
+		internal: true,
+		type: "action"
+	},
+	{
+		exportName: "rotateKeys",
+		internal: true,
+		type: "action"
+	},
+	{
+		exportName: "updateMany",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "updateOne",
+		internal: true,
+		type: "mutation"
+	}
+];
+const GENERATED_ORM_RUNTIME_PROCEDURES = [
+	{
+		exportName: "scheduledMutationBatch",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "scheduledDelete",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfill",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfillChunk",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfillStatus",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "migrationRun",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "migrationRunChunk",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "migrationStatus",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "migrationCancel",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "resetChunk",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "reset",
+		internal: true,
+		type: "action"
+	}
+];
+function listFilesRecursive(cwd, relDir = "") {
+	const absDir = path.join(cwd, relDir);
+	const entries = fs.readdirSync(absDir, { withFileTypes: true }).sort((a, b) => a.name > b.name ? 1 : -1);
+	const files = [];
+	for (const entry of entries) {
+		const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			files.push(...listFilesRecursive(cwd, relPath));
+			continue;
+		}
+		if (entry.isFile()) files.push(relPath);
+	}
+	return files;
+}
+function ensureRelativeImportPath(value) {
+	if (value.startsWith(".") || value.startsWith("/")) return value;
+	return `./${value}`;
+}
+function normalizeImportPath(value) {
+	return value.replace(/\\/g, "/");
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getIndexLineColumn(source, index) {
+	const lines = source.slice(0, index).split("\n");
+	return {
+		column: (lines.at(-1)?.length ?? 0) + 1,
+		line: lines.length
+	};
+}
+function findProcedureCallIndex(params) {
+	const exportMatch = (params.exportName === "default" ? /\bexport\s+default\b/g : new RegExp(`\\bexport\\s+const\\s+${escapeRegex(params.exportName)}\\s*=`, "g")).exec(params.source);
+	if (!exportMatch) return;
+	const tail = params.source.slice(exportMatch.index);
+	const callMatch = new RegExp(`\\.\\s*${params.type}\\s*\\(`, "g").exec(tail);
+	if (!callMatch || callMatch.index < 0) return;
+	return exportMatch.index + callMatch.index;
+}
+function buildProcedureNameLookupEntries(params) {
+	if (params.procedures.length === 0) return [];
+	const source = fs.readFileSync(params.filePath, "utf8");
+	return params.procedures.flatMap((procedure) => {
+		const callIndex = findProcedureCallIndex({
+			exportName: procedure.exportName,
+			source,
+			type: procedure.type
+		});
+		if (callIndex === void 0) return [];
+		const location = getIndexLineColumn(source, callIndex);
+		return [{
+			column: location.column,
+			line: location.line,
+			name: `${params.moduleName}:${procedure.exportName}`
+		}];
+	});
+}
+function emitProcedureNameLookupLiteral(lookup) {
+	const entries = Object.entries(lookup);
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map(([file, locations]) => {
+		const items = locations.map((location) => `{ column: ${location.column}, line: ${location.line}, name: ${JSON.stringify(location.name)} }`).join(", ");
+		return `  ${JSON.stringify(file)}: [${items}],`;
+	}).join("\n")}\n}`;
+}
+function formatKey(key) {
+	return VALID_IDENTIFIER_RE.test(key) ? key : `'${key}'`;
+}
+function toPascalCaseToken(token) {
+	if (token.length === 0) return "";
+	return `${token[0]?.toUpperCase() ?? ""}${token.slice(1)}`;
+}
+function getRuntimeNameHash(moduleName) {
+	return createHash("sha1").update(moduleName).digest("hex").slice(0, 6);
+}
+function normalizeTrimSegments(trimSegments) {
+	const source = [...DEFAULT_TRIM_SEGMENTS, ...trimSegments ?? []];
+	return [...new Set(source.map((segment) => segment.trim()).filter(Boolean))];
+}
+function toRuntimeExportBase(moduleSegments, fallbackSegments) {
+	const base = moduleSegments.filter((segment) => segment.length > 0).flatMap((segment) => segment.split(/[^a-zA-Z0-9]+/g).filter(Boolean).map((token) => toPascalCaseToken(token))).join("");
+	if (base.length === 0) {
+		if (fallbackSegments && fallbackSegments.length > 0) return toRuntimeExportBase(fallbackSegments);
+		return "Module";
+	}
+	return IDENTIFIER_START_RE.test(base) ? base : `M${base}`;
+}
+function getModuleRuntimeExportBase(moduleName, trimSegments) {
+	const moduleSegments = moduleName.split("/").filter(Boolean);
+	const trimSet = new Set(trimSegments);
+	const keptSegments = moduleSegments.filter((segment) => !trimSet.has(segment));
+	const removedSegments = moduleSegments.filter((segment) => trimSet.has(segment));
+	const primaryBase = toRuntimeExportBase(keptSegments, moduleSegments);
+	const removedBase = toRuntimeExportBase(removedSegments);
+	return {
+		primaryBase,
+		collisionBase: removedSegments.length > 0 ? `${primaryBase}${removedBase}` : primaryBase
+	};
+}
+function resolveModuleRuntimeExportNames(moduleNames, trimSegments) {
+	const resolvedNames = /* @__PURE__ */ new Map();
+	const byPrimaryBase = /* @__PURE__ */ new Map();
+	for (const moduleName of [...new Set(moduleNames)].sort((a, b) => a.localeCompare(b))) {
+		if (moduleName === "generated/server") {
+			resolvedNames.set(moduleName, {
+				callerExportName: "createServerCaller",
+				handlerExportName: "createServerHandler"
+			});
+			continue;
+		}
+		const { primaryBase, collisionBase } = getModuleRuntimeExportBase(moduleName, trimSegments);
+		const entries = byPrimaryBase.get(primaryBase);
+		if (entries) {
+			entries.push({
+				moduleName,
+				collisionBase
+			});
+			continue;
+		}
+		byPrimaryBase.set(primaryBase, [{
+			moduleName,
+			collisionBase
+		}]);
+	}
+	for (const [primaryBase, entries] of byPrimaryBase) {
+		if (entries.length === 1) {
+			const entry = entries[0];
+			if (!entry) continue;
+			resolvedNames.set(entry.moduleName, {
+				callerExportName: `create${primaryBase}Caller`,
+				handlerExportName: `create${primaryBase}Handler`
+			});
+			continue;
+		}
+		const usedBases = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			let exportBase = entry.collisionBase;
+			if (usedBases.has(exportBase)) exportBase = `${exportBase}_${getRuntimeNameHash(entry.moduleName)}`;
+			usedBases.add(exportBase);
+			resolvedNames.set(entry.moduleName, {
+				callerExportName: `create${exportBase}Caller`,
+				handlerExportName: `create${exportBase}Handler`
+			});
+		}
+	}
+	return resolvedNames;
+}
+function getModuleRuntimeExportNames(moduleName) {
+	const base = toRuntimeExportBase(moduleName.split("/").filter(Boolean));
+	return {
+		callerExportName: `create${base}Caller`,
+		handlerExportName: `create${base}Handler`
+	};
+}
+function getModuleImportPath(outputFile, functionsDir, moduleName) {
+	const moduleFile = path.join(functionsDir, moduleName);
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), moduleFile)));
+}
+function getRuntimeApiImportPath(outputFile, functionsDir) {
+	const runtimeApiFile = path.join(functionsDir, "_generated", "api.js");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), runtimeApiFile)));
+}
+function getRuntimeApiTypesImportPath(outputFile, functionsDir) {
+	const runtimeApiFile = path.join(functionsDir, "_generated", "api");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), runtimeApiFile)));
+}
+function moduleUsesOwnGeneratedRuntime(functionsDir, moduleName) {
+	if (moduleName === "generated/server") return true;
+	const moduleFilePath = path.join(functionsDir, `${moduleName}.ts`);
+	if (!fs.existsSync(moduleFilePath)) return false;
+	const source = fs.readFileSync(moduleFilePath, "utf8");
+	const escapedRuntimeImportPath = escapeRegex(ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(moduleFilePath), path.join(functionsDir, "generated", `${moduleName}.runtime`)))));
+	return [new RegExp(`from\\s+['"]${escapedRuntimeImportPath}(?:\\.[jt]s)?['"]`), new RegExp(`require\\(\\s*['"]${escapedRuntimeImportPath}(?:\\.[jt]s)?['"]\\s*\\)`)].some((pattern) => pattern.test(source));
+}
+function getBracketAccessPath(rootIdentifier, pathSegments) {
+	return pathSegments.reduce((accessPath, segment) => `${accessPath}[${JSON.stringify(segment)}]`, rootIdentifier);
+}
+function getSchemaImportPath(outputFile, functionsDir) {
+	const schemaFile = path.join(functionsDir, "schema");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), schemaFile)));
+}
+function getServerTypesImportPath(outputFile, functionsDir) {
+	const serverTypesFile = path.join(functionsDir, "_generated", "server");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), serverTypesFile)));
+}
+function getDataModelImportPath(outputFile, functionsDir) {
+	const dataModelFile = path.join(functionsDir, "_generated", "dataModel");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), dataModelFile)));
+}
+function getHttpImportPath(outputFile, functionsDir) {
+	const httpFile = path.join(functionsDir, "http");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), httpFile)));
+}
+const GENERATED_DIR = "generated";
+function getGeneratedServerOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "server.ts");
+}
+function getGeneratedOrmOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "orm.ts");
+}
+function getGeneratedCrpcOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "crpc.ts");
+}
+function getGeneratedAuthOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "auth.ts");
+}
+function getGeneratedMigrationsHelperOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "migrations.gen.ts");
+}
+function getLegacyGeneratedOutputFile(functionsDir) {
+	return path.join(functionsDir, "generated.ts");
+}
+function getModuleNameFromOutputFile(outputFile, functionsDir) {
+	return normalizeImportPath(path.relative(functionsDir, outputFile)).replace(TS_EXTENSION_RE, "");
+}
+function getGeneratedServerImportPath(outputFile, functionsDir) {
+	const generatedServerFile = getGeneratedServerOutputFile(functionsDir);
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), generatedServerFile)).replace(TS_EXTENSION_RE, ""));
+}
+function getGeneratedRuntimeOutputFile(functionsDir, moduleName) {
+	const runtimeModuleName = moduleName.startsWith(`${GENERATED_DIR}/`) ? moduleName.slice(10) : moduleName;
+	return path.join(functionsDir, GENERATED_DIR, `${runtimeModuleName}.runtime.ts`);
+}
+function emitGeneratedServerPlaceholderFile(functionsDir) {
+	const functionsDirHint = normalizeImportPath(path.relative(process.cwd(), functionsDir)) || "convex";
+	return `// @ts-nocheck
+// biome-ignore-all format: generated
+/* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unused-vars */
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import {
+  registerProcedureNameLookup,
+} from 'kitcn/server';
+import type {
+  ActionCtx as ServerActionCtx,
+  MutationCtx as ServerMutationCtx,
+  QueryCtx as ServerQueryCtx,
+} from '../_generated/server';
+
+export type QueryCtx = ServerQueryCtx;
+export type MutationCtx = ServerMutationCtx;
+export type ActionCtx = ServerActionCtx;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+
+${CRPC_BUILDER_STUB_SOURCE}
+
+registerProcedureNameLookup({}, ${JSON.stringify(functionsDirHint)});
+
+export function withOrm<Ctx>(ctx: Ctx): Ctx {
+  return ctx;
+}
+`;
+}
+function emitGeneratedAuthPlaceholderFile() {
+	return `// biome-ignore-all format: generated
+/* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unused-vars */
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+export function defineAuth<TDefinition>(definition: TDefinition): TDefinition {
+  return definition;
+}
+
+export const authEnabled = false;
+export const authClient = {} as Record<string, unknown>;
+export const getAuth = () => ({} as Record<string, unknown>);
+export const auth = {} as Record<string, unknown>;
+`;
+}
+function emitGeneratedMigrationsPlaceholderFile() {
+	return `// biome-ignore-all format: generated
+/* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unused-vars */
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+export { defineMigration } from 'kitcn/orm';
+`;
+}
+function writeFileIfChanged(filePath, content) {
+	if (fs.existsSync(filePath)) {
+		if (fs.readFileSync(filePath, "utf8") === content) return false;
+	}
+	fs.writeFileSync(filePath, content);
+	return true;
+}
+function ensureGeneratedSupportPlaceholders(functionsDir, options) {
+	const createdPlaceholderFiles = [];
+	const serverOutputFile = getGeneratedServerOutputFile(functionsDir);
+	const authOutputFile = getGeneratedAuthOutputFile(functionsDir);
+	const migrationsHelperOutputFile = getGeneratedMigrationsHelperOutputFile(functionsDir);
+	const generatedDir = path.dirname(serverOutputFile);
+	fs.mkdirSync(generatedDir, { recursive: true });
+	const includeAuth = options?.includeAuth ?? true;
+	if (!fs.existsSync(serverOutputFile)) {
+		writeFileIfChanged(serverOutputFile, emitGeneratedServerPlaceholderFile(functionsDir));
+		createdPlaceholderFiles.push(serverOutputFile);
+	}
+	if (includeAuth && !fs.existsSync(authOutputFile)) {
+		writeFileIfChanged(authOutputFile, emitGeneratedAuthPlaceholderFile());
+		createdPlaceholderFiles.push(authOutputFile);
+	}
+	if (!fs.existsSync(migrationsHelperOutputFile)) {
+		writeFileIfChanged(migrationsHelperOutputFile, emitGeneratedMigrationsPlaceholderFile());
+		createdPlaceholderFiles.push(migrationsHelperOutputFile);
+	}
+	return createdPlaceholderFiles;
+}
+function emitGeneratedRuntimePlaceholderFile(exportNames) {
+	const { callerExportName, handlerExportName } = exportNames;
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+export function ${callerExportName}(_ctx: unknown) {
+  throw new Error('[kitcn] Runtime caller is not generated yet. Run kitcn codegen.');
+}
+
+export function ${handlerExportName}(_ctx: unknown) {
+  throw new Error('[kitcn] Runtime handler is not generated yet. Run kitcn codegen.');
+}
+`;
+}
+function ensureGeneratedRuntimePlaceholders(functionsDir, moduleNames, runtimeExportNames) {
+	const createdPlaceholderFiles = [];
+	for (const moduleName of moduleNames) {
+		const runtimeOutputFile = getGeneratedRuntimeOutputFile(functionsDir, moduleName);
+		if (fs.existsSync(runtimeOutputFile)) continue;
+		const exportNames = runtimeExportNames.get(moduleName) ?? getModuleRuntimeExportNames(moduleName);
+		fs.mkdirSync(path.dirname(runtimeOutputFile), { recursive: true });
+		writeFileIfChanged(runtimeOutputFile, emitGeneratedRuntimePlaceholderFile(exportNames));
+		createdPlaceholderFiles.push(runtimeOutputFile);
+	}
+	return createdPlaceholderFiles;
+}
+function listGeneratedRuntimeFiles(functionsDir) {
+	const generatedDir = path.join(functionsDir, "generated");
+	if (!fs.existsSync(generatedDir)) return [];
+	return listFilesRecursive(generatedDir).filter((file) => file.endsWith(".runtime.ts")).map((file) => path.join(generatedDir, file));
+}
+async function resolveSchemaMetadataForCodegen(functionsDir, debug, createJitiInstance = createProjectJiti) {
+	const schemaPath = path.join(functionsDir, "schema.ts");
+	if (!fs.existsSync(schemaPath)) return {
+		hasOrmSchema: false,
+		hasRelations: false,
+		hasTriggers: false
+	};
+	const jitiInstance = createJitiInstance();
+	try {
+		const schemaModule = await jitiInstance.import(schemaPath);
+		const schemaValue = schemaModule && typeof schemaModule === "object" ? schemaModule.default ?? schemaModule : null;
+		if (!schemaValue || typeof schemaValue !== "object") return {
+			hasOrmSchema: false,
+			hasRelations: false,
+			hasTriggers: false
+		};
+		return {
+			hasOrmSchema: OrmSchemaOptions in schemaValue,
+			hasRelations: Boolean(getSchemaRelations(schemaValue)),
+			hasTriggers: Boolean(getSchemaTriggers(schemaValue))
+		};
+	} catch (error) {
+		if (debug) logger.warn(`⚠️  Failed to load schema extensions from ${schemaPath}: ${error.message}`);
+		return {
+			hasOrmSchema: false,
+			hasRelations: false,
+			hasTriggers: false
+		};
+	}
+}
+function cleanupGeneratedPluginArtifacts(functionsDir) {
+	fs.rmSync(path.join(functionsDir, GENERATED_DIR, "plugins"), {
+		recursive: true,
+		force: true
+	});
+}
+function emitGeneratedServerFile(outputFile, functionsDir, hasOrmSchema, hasMigrationsManifest, procedureNameLookup) {
+	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
+	const serverTypesImportPath = getServerTypesImportPath(outputFile, functionsDir);
+	const dataModelImportPath = getDataModelImportPath(outputFile, functionsDir);
+	const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+	const migrationsManifestImportPath = getModuleImportPath(outputFile, functionsDir, "migrations/manifest");
+	const serverTypesImportLiteral = asSingleQuotedImport(serverTypesImportPath);
+	const dataModelImportLiteral = asSingleQuotedImport(dataModelImportPath);
+	const schemaImportLiteral = asSingleQuotedImport(schemaImportPath);
+	const migrationsManifestImportLiteral = asSingleQuotedImport(migrationsManifestImportPath);
+	const migrationsImportLine = hasMigrationsManifest ? `import { migrations } from ${migrationsManifestImportLiteral};\n` : "";
+	const migrationsConfigLine = hasMigrationsManifest ? "  migrations,\n" : "";
+	const functionsDirHint = normalizeImportPath(path.relative(process.cwd(), functionsDir)) || "convex";
+	const procedureNameLookupLiteral = emitProcedureNameLookupLiteral(procedureNameLookup);
+	if (!hasOrmSchema) return `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import {
+  initCRPC as baseInitCRPC,
+  registerProcedureNameLookup,
+} from 'kitcn/server';
+import type { DataModel } from ${dataModelImportLiteral};
+import type {
+  ActionCtx as ServerActionCtx,
+  MutationCtx as ServerMutationCtx,
+  QueryCtx as ServerQueryCtx,
+} from ${serverTypesImportLiteral};
+import { httpAction, internalMutation } from ${serverTypesImportLiteral};
+
+export type QueryCtx = ServerQueryCtx;
+export type MutationCtx = ServerMutationCtx;
+export type ActionCtx = ServerActionCtx;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+export type OrmCtx<Ctx = QueryCtx> = Ctx;
+
+registerProcedureNameLookup(
+  ${procedureNameLookupLiteral},
+  ${JSON.stringify(functionsDirHint)}
+);
+
+export function withOrm<Ctx extends ServerQueryCtx | ServerMutationCtx>(ctx: Ctx): OrmCtx<Ctx> {
+  return ctx as OrmCtx<Ctx>;
+}
+
+export const initCRPC = baseInitCRPC.dataModel<DataModel>().context({
+  query: (ctx) => ctx,
+  mutation: (ctx) => ctx,
+  action: (ctx) => ctx,
+});
+export { httpAction, internalMutation };
+`;
+	const moduleNamespace = getModuleNameFromOutputFile(outputFile, functionsDir);
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import {
+  createOrm,
+  type GenericOrmCtx,
+  type OrmFunctions,
+} from 'kitcn/orm';
+import {
+  createGeneratedFunctionReference,
+  initCRPC as baseInitCRPC,
+  registerProcedureNameLookup,
+} from 'kitcn/server';
+import type { DataModel } from ${dataModelImportLiteral};
+import type {
+  ActionCtx as ServerActionCtx,
+  MutationCtx as ServerMutationCtx,
+  QueryCtx as ServerQueryCtx,
+} from ${serverTypesImportLiteral};
+import { httpAction, internalMutation } from ${serverTypesImportLiteral};
+import schema from ${schemaImportLiteral};
+${migrationsImportLine}
+
+${`const ormFunctions: OrmFunctions = {
+  scheduledMutationBatch: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:scheduledMutationBatch`)}),
+  scheduledDelete: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:scheduledDelete`)}),
+  aggregateBackfillChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:aggregateBackfillChunk`)}),
+  migrationRunChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:migrationRunChunk`)}),
+  resetChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:resetChunk`)}),
+};`}
+const ormSchema = schema;
+
+registerProcedureNameLookup(
+  ${procedureNameLookupLiteral},
+  ${JSON.stringify(functionsDirHint)}
+);
+
+export const orm = createOrm({
+  schema: ormSchema,
+  ormFunctions,
+${migrationsConfigLine}  internalMutation,
+});
+
+export type OrmCtx<Ctx extends ServerQueryCtx | ServerMutationCtx = ServerQueryCtx> = GenericOrmCtx<Ctx, typeof ormSchema>;
+export type QueryCtx = OrmCtx<ServerQueryCtx>;
+export type MutationCtx = OrmCtx<ServerMutationCtx>;
+export type ActionCtx = ServerActionCtx;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+
+export function withOrm<Ctx extends ServerQueryCtx | ServerMutationCtx>(ctx: Ctx) {
+  return orm.with(ctx) as OrmCtx<Ctx>;
+}
+
+export const initCRPC = baseInitCRPC.dataModel<DataModel>().context({
+  query: (ctx) => withOrm(ctx),
+  mutation: (ctx) => withOrm(ctx),
+  action: (ctx) => ctx,
+});
+export { httpAction, internalMutation };
+
+export const {
+  scheduledMutationBatch,
+  scheduledDelete,
+  aggregateBackfill,
+  aggregateBackfillChunk,
+  aggregateBackfillStatus,
+  migrationRun,
+  migrationRunChunk,
+  migrationStatus,
+  migrationCancel,
+  resetChunk,
+  reset,
+} = orm.api();
+`;
+}
+function emitGeneratedAuthFile(outputFile, functionsDir, hasOrmSchema, authContract) {
+	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
+	const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
+	const dataModelImportPath = getDataModelImportPath(outputFile, functionsDir);
+	const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+	const serverImportPath = getGeneratedServerImportPath(outputFile, functionsDir);
+	const moduleNamespace = getModuleNameFromOutputFile(outputFile, functionsDir);
+	const authDefinitionImportPath = getModuleImportPath(outputFile, functionsDir, "auth");
+	const runtimeApiImportLiteral = asSingleQuotedImport(runtimeApiImportPath);
+	const dataModelImportLiteral = asSingleQuotedImport(dataModelImportPath);
+	const schemaImportLiteral = asSingleQuotedImport(schemaImportPath);
+	const serverImportLiteral = asSingleQuotedImport(serverImportPath);
+	const authDefinitionImportLiteral = asSingleQuotedImport(authDefinitionImportPath);
+	const authDefinitionFilePath = normalizeImportPath(path.relative(process.cwd(), path.join(functionsDir, "auth.ts")));
+	const hasAuthFile = authContract.hasAuthFile;
+	const hasAuthDefaultExport = authContract.hasAuthDefaultExport;
+	const authRuntimeModule = hasAuthDefaultExport ? "kitcn/auth" : "kitcn/auth/generated";
+	const disabledAuthReasonKind = hasAuthFile ? hasAuthDefaultExport ? "default_export_unavailable" : "missing_default_export" : "missing_auth_file";
+	const authRuntimeImports = `import {
+  ${(hasAuthDefaultExport ? [
+		"type BetterAuthOptionsWithoutDatabase",
+		"type AuthRuntime",
+		"defineAuth as baseDefineAuth",
+		"createAuthRuntime",
+		"type GenericAuthDefinition",
+		"getInvalidAuthDefinitionExportReason",
+		"resolveGeneratedAuthDefinition"
+	] : [
+		"type BetterAuthOptionsWithoutDatabase",
+		"type AuthRuntime",
+		"defineAuth as baseDefineAuth",
+		"type GenericAuthDefinition",
+		"getGeneratedAuthDisabledReason",
+		"createDisabledAuthRuntime"
+	]).join(",\n  ")},
+} from '${authRuntimeModule}';`;
+	const authDefinitionImport = hasAuthDefaultExport ? `import * as authDefinitionModule from ${authDefinitionImportLiteral};` : "";
+	const runtimeApiImport = hasAuthDefaultExport ? `import { internal } from ${runtimeApiImportLiteral};` : "";
+	const withOrmImport = hasOrmSchema && hasAuthDefaultExport ? `import { withOrm } from ${serverImportLiteral};` : "";
+	const usesSchemaFallback = !hasOrmSchema && !hasAuthDefaultExport;
+	const schemaTypeImports = usesSchemaFallback ? `import type { GenericSchema, SchemaDefinition } from 'convex/server';` : "";
+	const generatedSchemaType = usesSchemaFallback ? "GeneratedSchema" : "typeof schema";
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+${authRuntimeImports}
+${runtimeApiImport}
+import type { DataModel } from ${dataModelImportLiteral};
+import type { GenericCtx, MutationCtx } from ${serverImportLiteral};
+${schemaTypeImports}
+${withOrmImport}
+${usesSchemaFallback ? "" : `import schema from ${schemaImportLiteral};`}
+${authDefinitionImport}
+
+${usesSchemaFallback ? "type GeneratedSchema = SchemaDefinition<GenericSchema, true>;" : ""}
+
+export function defineAuth<
+  AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase,
+>(
+  definition: GenericAuthDefinition<GenericCtx, DataModel, ${generatedSchemaType}, AuthOptions>
+) {
+  return baseDefineAuth(definition);
+}
+
+${hasAuthDefaultExport ? `type AuthDefinitionFromFile = typeof authDefinitionModule.default;
+
+const authDefinition = resolveGeneratedAuthDefinition<AuthDefinitionFromFile>(
+  authDefinitionModule,
+  getInvalidAuthDefinitionExportReason(${JSON.stringify(authDefinitionFilePath)})
+);
+` : ""}
+const authRuntime: ${hasAuthDefaultExport ? `AuthRuntime<
+  DataModel,
+  ${generatedSchemaType},
+  MutationCtx,
+  GenericCtx,
+  ReturnType<AuthDefinitionFromFile>
+> = createAuthRuntime<
+  DataModel,
+  ${generatedSchemaType},
+  MutationCtx,
+  GenericCtx,
+  ReturnType<AuthDefinitionFromFile>
+>({
+  internal,
+  moduleName: ${JSON.stringify(moduleNamespace)},
+  schema,
+  auth: authDefinition,${hasOrmSchema ? "\n  context: withOrm," : ""}
+})` : `AuthRuntime<
+  DataModel,
+  ${generatedSchemaType},
+  MutationCtx,
+  GenericCtx
+> = createDisabledAuthRuntime<DataModel, ${generatedSchemaType}, MutationCtx, GenericCtx>({
+  reason: getGeneratedAuthDisabledReason(
+    ${JSON.stringify(disabledAuthReasonKind)},
+    ${JSON.stringify(authDefinitionFilePath)}
+  ),
+})`};
+
+export const {
+  authEnabled,
+  authClient,
+  getAuth,
+  auth,
+  create,
+  deleteMany,
+  deleteOne,
+  findMany,
+  findOne,
+  updateMany,
+  updateOne,
+  getLatestJwks,
+  rotateKeys,
+} = authRuntime;
+`;
+}
+function emitGeneratedMigrationsFile(outputFile, functionsDir, hasRelationsMetadata) {
+	if (!hasRelationsMetadata) return emitGeneratedMigrationsPlaceholderFile();
+	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
+	const schemaImportLiteral = asSingleQuotedImport(getSchemaImportPath(outputFile, functionsDir));
+	const migrationSchemaImport = "schema";
+	const migrationSchemaType = "typeof schema";
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import {
+  defineMigration as baseDefineMigration,
+  type MigrationDefinition,
+} from 'kitcn/orm';
+import ${migrationSchemaImport} from ${schemaImportLiteral};
+
+export function defineMigration(
+  migration: MigrationDefinition<${migrationSchemaType}>
+): MigrationDefinition<${migrationSchemaType}> {
+  return baseDefineMigration<${migrationSchemaType}>(migration);
+}
+`;
+}
+function renderRuntimeApiTypesImport(entries, importPath) {
+	const specifiers = [];
+	if (entries.some((entry) => !entry.internal)) specifiers.push("api as generatedApi");
+	if (entries.some((entry) => entry.internal)) specifiers.push("internal as generatedInternal");
+	if (specifiers.length === 0) return "";
+	if (specifiers.length === 1) return `import type { ${specifiers[0]} } from '${importPath}';\n`;
+	return `import type {\n${specifiers.map((specifier) => `  ${specifier},\n`).join("")}} from '${importPath}';\n`;
+}
+function emitGeneratedModuleRuntimeFile(outputFile, functionsDir, moduleName, procedureEntries, runtimeExportNames) {
+	const { callerExportName, handlerExportName } = runtimeExportNames?.get(moduleName) ?? getModuleRuntimeExportNames(moduleName);
+	const useGeneratedApiTypes = moduleUsesOwnGeneratedRuntime(functionsDir, moduleName);
+	const runtimeApiTypesImportPath = useGeneratedApiTypes ? getRuntimeApiTypesImportPath(outputFile, functionsDir) : null;
+	const generatedServerImportPath = getGeneratedServerImportPath(outputFile, functionsDir);
+	const { callerEntries, handlerEntries } = partitionRuntimeEntriesForEmission(procedureEntries);
+	const runtimeApiTypesImport = runtimeApiTypesImportPath ? renderRuntimeApiTypesImport(callerEntries, runtimeApiTypesImportPath) : "";
+	const callerRegistryLines = emitProcedureRegistryEntries(callerEntries, outputFile, functionsDir, moduleName, useGeneratedApiTypes);
+	const callerRegistryBody = callerRegistryLines.length > 0 ? `\n${callerRegistryLines.join("\n")}\n` : "\n";
+	const hasHandlerRegistry = handlerEntries.length > 0;
+	const handlerRegistryLines = hasHandlerRegistry ? emitProcedureRegistryEntries(handlerEntries, outputFile, functionsDir, moduleName, useGeneratedApiTypes) : [];
+	const handlerRegistryBody = handlerRegistryLines.length > 0 ? `\n${handlerRegistryLines.join("\n")}\n` : "\n";
+	const allEntriesAreCrpc = callerEntries.length > 0 && callerEntries.length === handlerEntries.length;
+	const handlerRegistryDeclaration = hasHandlerRegistry ? allEntriesAreCrpc ? "\n  const handlerRegistry = procedureRegistry;\n" : `\n  const handlerRegistry = {${handlerRegistryBody}} as const;\n` : "";
+	const handlerTypeDeclarations = hasHandlerRegistry ? `
+type ProcedureHandlerContext = QueryCtx | MutationCtx;
+type GeneratedProcedureHandler<
+  TCtx extends ProcedureHandlerContext = ProcedureHandlerContext,
+> = GeneratedRegistryHandlerForContext<
+  ProcedureHandlerRegistry,
+  TCtx,
+  QueryCtx,
+  MutationCtx
+>;
+` : "";
+	const generatedRuntimeTypeArgs = hasHandlerRegistry ? `
+  QueryCtx,
+  MutationCtx,
+  ProcedureCallerRegistry,
+  ActionCtx,
+  ProcedureHandlerRegistry
+` : `
+  QueryCtx,
+  MutationCtx,
+  ProcedureCallerRegistry,
+  ActionCtx
+`;
+	const handlerExport = hasHandlerRegistry ? `
+export function ${handlerExportName}<TCtx extends ProcedureHandlerContext>(
+  ctx: TCtx
+): GeneratedProcedureHandler<TCtx> {
+  return generatedRuntime.getHandlerFactory()(ctx) as GeneratedProcedureHandler<TCtx>;
+}
+` : "";
+	return `// biome-ignore-all format: generated
+/* eslint-disable @typescript-eslint/no-require-imports, @typescript-eslint/no-unused-vars */
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import {
+  createGeneratedFunctionReference,
+  createGeneratedRegistryRuntime,
+  typedProcedureResolver,
+  type GeneratedRegistryCallerForContext,${hasHandlerRegistry ? "\n  type GeneratedRegistryHandlerForContext," : ""}
+} from 'kitcn/server';
+${runtimeApiTypesImport}import type { ActionCtx, MutationCtx, QueryCtx } from '${generatedServerImportPath}';
+import type { OrmTriggerContext } from 'kitcn/orm';
+
+const procedureRegistry = {${callerRegistryBody}} as const;
+${handlerRegistryDeclaration}
+type ProcedureCallerRegistry = typeof procedureRegistry;
+${hasHandlerRegistry ? `type ProcedureHandlerRegistry = typeof handlerRegistry;
+` : ""}
+
+const generatedRuntime = createGeneratedRegistryRuntime<${generatedRuntimeTypeArgs}>({
+  procedureRegistry,${hasHandlerRegistry ? "\n  handlerRegistry," : ""}
+});
+
+type MutationCallerContext = MutationCtx | OrmTriggerContext<any, MutationCtx>;
+type ProcedureCallerContext = QueryCtx | MutationCallerContext | ActionCtx;
+type GeneratedProcedureCaller<
+  TCtx extends ProcedureCallerContext = ProcedureCallerContext,
+> = GeneratedRegistryCallerForContext<
+  ProcedureCallerRegistry,
+  TCtx,
+  QueryCtx,
+  MutationCallerContext,
+  ActionCtx
+>;
+${handlerTypeDeclarations}
+
+export function ${callerExportName}<TCtx extends ProcedureCallerContext>(
+  ctx: TCtx
+): GeneratedProcedureCaller<TCtx> {
+  return generatedRuntime.getCallerFactory()(
+    ctx as any
+  ) as GeneratedProcedureCaller<TCtx>;
+}
+${handlerExport}
+`;
+}
+function hasNamedExport(filePath, exportName) {
+	if (!fs.existsSync(filePath)) return false;
+	const source = fs.readFileSync(filePath, "utf-8");
+	if (new RegExp(`\\bexport\\s+(?:const|let|var|function|class|type|interface)\\s+${exportName}\\b`).test(source)) return true;
+	for (const match of source.matchAll(/\bexport\s*{([^}]*)}/g)) {
+		const exportList = match[1] ?? "";
+		if (new RegExp(`\\b${exportName}\\b`).test(exportList)) return true;
+	}
+	return false;
+}
+function hasDefaultExport(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	const source = fs.readFileSync(filePath, "utf-8");
+	return DEFAULT_EXPORT_RE.test(source);
+}
+function createApiTree(meta) {
+	const root = {
+		children: {},
+		functions: []
+	};
+	for (const [moduleName, fns] of Object.entries(meta)) {
+		const pathSegments = moduleName.split("/").filter(Boolean);
+		let node = root;
+		for (const segment of pathSegments) {
+			node.children[segment] ??= {
+				children: {},
+				functions: []
+			};
+			node = node.children[segment];
+		}
+		for (const fnName of Object.keys(fns).sort()) {
+			const fnMeta = fns[fnName] ?? {};
+			const type = fnMeta.type;
+			const fnType = type === "query" || type === "mutation" || type === "action" ? type : "query";
+			node.functions.push({
+				fnName,
+				fnType,
+				moduleName,
+				fnMeta: {
+					...fnMeta,
+					type: fnType
+				}
+			});
+		}
+	}
+	return root;
+}
+function formatMetaValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	return null;
+}
+function emitFnMetaLiteral(fnMeta) {
+	const metaProps = [];
+	for (const [key, value] of Object.entries(fnMeta).sort(([a], [b]) => a.localeCompare(b))) {
+		if (value === void 0) continue;
+		const formatted = formatMetaValue(value);
+		if (formatted !== null) metaProps.push(`${key}: ${formatted}`);
+	}
+	return `{ ${metaProps.join(", ")} }`;
+}
+function emitHttpRoutes(dedupedRoutes, indentLevel) {
+	const indent = "  ".repeat(indentLevel);
+	const lines = [];
+	for (const [routeKey, route] of Object.entries(dedupedRoutes).sort(([a], [b]) => a.localeCompare(b))) lines.push(`${indent}${formatKey(routeKey)}: { path: ${JSON.stringify(route.path)}, method: ${JSON.stringify(route.method)} },`);
+	return lines;
+}
+function emitApiObject(tree, pathSegments, outputFile, functionsDir, indentLevel, dedupedRoutes, hasHttpRouterExport) {
+	const indent = "  ".repeat(indentLevel);
+	const lines = [];
+	const childKeys = Object.keys(tree.children).sort((a, b) => a.localeCompare(b));
+	const functionEntries = [...tree.functions].sort((a, b) => a.fnName.localeCompare(b.fnName));
+	const childSet = new Set(childKeys);
+	for (const entry of functionEntries) if (childSet.has(entry.fnName)) throw new Error(`Codegen conflict at ${pathSegments.join("/")}: export "${entry.fnName}" conflicts with directory of same name.`);
+	const mergedKeys = [...childKeys, ...functionEntries.map((entry) => entry.fnName)].sort((a, b) => a.localeCompare(b));
+	for (const key of mergedKeys) {
+		if (childSet.has(key)) {
+			const childNode = tree.children[key];
+			lines.push(`${indent}${formatKey(key)}: {`);
+			lines.push(...emitApiObject(childNode, [...pathSegments, key], outputFile, functionsDir, indentLevel + 1, dedupedRoutes, hasHttpRouterExport));
+			lines.push(`${indent}},`);
+			continue;
+		}
+		const fnEntry = functionEntries.find((entry) => entry.fnName === key);
+		if (!fnEntry) continue;
+		const moduleImportPath = getModuleImportPath(outputFile, functionsDir, fnEntry.moduleName);
+		const fnMetaLiteral = emitFnMetaLiteral(fnEntry.fnMeta);
+		const functionRef = `createGeneratedFunctionReference<${JSON.stringify(fnEntry.fnType)}, "public", typeof import(${JSON.stringify(moduleImportPath)}).${key}>(${JSON.stringify(getGeneratedFunctionName(fnEntry.moduleName, key))})`;
+		lines.push(`${indent}${formatKey(key)}: createApiLeaf<${JSON.stringify(fnEntry.fnType)}, typeof import(${JSON.stringify(moduleImportPath)}).${key}>(${functionRef}, ${fnMetaLiteral}),`);
+	}
+	if (pathSegments.length === 0) {
+		if (hasHttpRouterExport) lines.push(`${indent}http: undefined as unknown as typeof httpRouter,`);
+		lines.push(`${indent}_http: {`);
+		lines.push(...emitHttpRoutes(dedupedRoutes, indentLevel + 1));
+		lines.push(`${indent}},`);
+	}
+	return lines;
+}
+function emitProcedureRegistryEntries(entries, outputFile, functionsDir, moduleName, useGeneratedApiTypes) {
+	return entries.map((entry) => {
+		const pathKey = entry.moduleName === moduleName ? entry.exportName : [...entry.moduleName.split("/"), entry.exportName].join(".");
+		const moduleImportPath = getModuleImportPath(outputFile, functionsDir, entry.moduleName);
+		const functionRefTypeAccess = useGeneratedApiTypes ? getBracketAccessPath(entry.internal ? "generatedInternal" : "generatedApi", entry.exportName === "default" ? entry.moduleName.split("/") : [...entry.moduleName.split("/"), entry.exportName]) : `import(${JSON.stringify(moduleImportPath)}).${entry.exportName}`;
+		const functionRefAccess = `createGeneratedFunctionReference<${JSON.stringify(entry.type)}, ${JSON.stringify(entry.internal ? "internal" : "public")}, typeof ${functionRefTypeAccess}>(${JSON.stringify(getGeneratedFunctionName(entry.moduleName, entry.exportName))})`;
+		const resolver = `(require(${JSON.stringify(moduleImportPath)}) as Record<string, unknown>)[${JSON.stringify(entry.exportName)}]`;
+		return `  ${JSON.stringify(pathKey)}: [${JSON.stringify(entry.type)}, typedProcedureResolver(${functionRefAccess}, () => ${resolver})],`;
+	}).sort((a, b) => a.localeCompare(b));
+}
+function getGeneratedFunctionName(moduleName, exportName) {
+	return exportName === "default" ? moduleName : `${moduleName}:${exportName}`;
+}
+function buildAuthRuntimeProcedureEntries(moduleName) {
+	return AUTH_RUNTIME_PROCEDURES.map((entry) => ({
+		...entry,
+		moduleName,
+		kind: "crpc"
+	}));
+}
+function buildGeneratedOrmRuntimeProcedureEntries(moduleName) {
+	return GENERATED_ORM_RUNTIME_PROCEDURES.map((entry) => ({
+		...entry,
+		moduleName,
+		kind: "dispatch"
+	}));
+}
+function partitionRuntimeEntriesForEmission(entries) {
+	return {
+		callerEntries: entries,
+		handlerEntries: entries.filter((entry) => entry.kind === "crpc")
+	};
+}
+function dedupeProcedureEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		const key = `${entry.moduleName}.${entry.exportName}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+function shouldSuppressHttpParseWarning(error) {
+	return MISSING_KITCN_IMPORT_RE.test(String(error));
+}
+function getConvexConfig(sharedDir) {
+	const convexConfigPath = path.join(process.cwd(), "convex.json");
+	const functionsDir = (fs.existsSync(convexConfigPath) ? JSON.parse(fs.readFileSync(convexConfigPath, "utf-8")) : {}).functions || "convex";
+	return {
+		functionsDir: path.join(process.cwd(), functionsDir),
+		outputFile: path.join(process.cwd(), sharedDir || "convex/shared", "api.ts")
+	};
+}
+/**
+* Check if a value is a CRPCHttpRouter (has _def.router === true)
+*/
+function isCRPCHttpRouter(value) {
+	return typeof value === "object" && value !== null && "_def" in value && value._def?.router === true;
+}
+/**
+* Import a module using jiti and extract cRPC metadata from exports.
+*/
+async function parseModuleRuntime(filePath, jitiInstance, serverShimSpecifier) {
+	const source = fs.readFileSync(filePath, "utf8");
+	const rewrittenSource = source.replaceAll(/from\s+(['"])kitcn\/server\1/g, `from ${JSON.stringify(serverShimSpecifier)}`);
+	const result = {};
+	const httpRoutes = {};
+	const procedures = [];
+	const isHttp = filePath.endsWith("http.ts");
+	const module = rewrittenSource === source ? await jitiInstance.import(filePath) : await jitiInstance.evalModule(rewrittenSource, {
+		async: true,
+		ext: ".ts",
+		filename: filePath
+	});
+	if (!module || typeof module !== "object") {
+		if (isHttp) logger.error("  http.ts: module is empty or not an object");
+		return {
+			meta: null,
+			httpRoutes: {},
+			procedures: []
+		};
+	}
+	for (const [name, value] of Object.entries(module)) {
+		if (name.startsWith("_")) continue;
+		const meta = value?._crpcMeta;
+		if (meta?.type) {
+			procedures.push({
+				exportName: name,
+				internal: Boolean(meta.internal),
+				type: meta.type
+			});
+			if (meta.internal) continue;
+			const fnMeta = { type: meta.type };
+			if (meta.auth) fnMeta.auth = meta.auth;
+			for (const [key, val] of Object.entries(meta)) if (key !== "type" && key !== "internal" && val !== void 0) fnMeta[key] = val;
+			result[name] = fnMeta;
+		}
+		const httpRoute = value?._crpcHttpRoute;
+		if (httpRoute?.path && httpRoute?.method) httpRoutes[name] = {
+			path: httpRoute.path,
+			method: httpRoute.method
+		};
+		if (isCRPCHttpRouter(value)) for (const [procPath, procedure] of Object.entries(value._def.procedures)) {
+			const route = procedure._crpcHttpRoute;
+			if (route?.path && route?.method) httpRoutes[procPath] = {
+				path: route.path,
+				method: route.method
+			};
+		}
+	}
+	return {
+		meta: Object.keys(result).length > 0 ? result : null,
+		httpRoutes,
+		procedures
+	};
+}
+async function generateMeta(sharedDir, options) {
+	const startTime = Date.now();
+	const { functionsDir, outputFile } = getConvexConfig(sharedDir);
+	const serverOutputFile = getGeneratedServerOutputFile(functionsDir);
+	const ormOutputFile = getGeneratedOrmOutputFile(functionsDir);
+	const crpcOutputFile = getGeneratedCrpcOutputFile(functionsDir);
+	const authOutputFile = getGeneratedAuthOutputFile(functionsDir);
+	const migrationsHelperOutputFile = getGeneratedMigrationsHelperOutputFile(functionsDir);
+	const legacyGeneratedMigrationsOutputFile = path.join(functionsDir, GENERATED_DIR, "migrations.ts");
+	const legacyGeneratedMigrationsRuntimeOutputFile = path.join(functionsDir, GENERATED_DIR, "migrations.runtime.ts");
+	const legacyGeneratedMigrationsUnderscoreOutputFile = path.join(functionsDir, GENERATED_DIR, "_migrations.ts");
+	const generatedAuthModuleName = getModuleNameFromOutputFile(authOutputFile, functionsDir);
+	const debug = options?.debug ?? false;
+	const silent = options?.silent ?? false;
+	const { generateApi, generateAuth, modeLabel } = resolveGenerationMode(options);
+	const normalizedTrimSegments = normalizeTrimSegments(options?.trimSegments);
+	if (debug) if (generateApi) logger.info("Scanning Convex functions for cRPC metadata...\n");
+	else logger.info(`Running kitcn codegen (mode=${modeLabel})...\n`);
+	const meta = {};
+	const allHttpRoutes = {};
+	const procedureEntries = [];
+	const procedureNameLookup = {};
+	const fatalParseFailures = [];
+	let createdRuntimePlaceholders = [];
+	let createdSupportPlaceholders = [];
+	const runtimeFilesPreservedFromParseFailures = /* @__PURE__ */ new Set();
+	let totalFunctions = 0;
+	const authFilePath = path.join(functionsDir, "auth.ts");
+	const hasAuthFile = fs.existsSync(authFilePath);
+	const hasAuthDefaultExport = hasDefaultExport(authFilePath);
+	const authContract = {
+		hasAuthFile,
+		hasAuthDefaultExport
+	};
+	let sharedJitiInstance;
+	const getSharedJitiInstance = () => sharedJitiInstance ??= createProjectJiti();
+	const schemaMetadata = await resolveSchemaMetadataForCodegen(functionsDir, debug, getSharedJitiInstance);
+	const hasOrmSchemaMetadata = schemaMetadata.hasOrmSchema;
+	const hasRelationsMetadata = schemaMetadata.hasRelations;
+	const hasRelationsExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "relations");
+	const hasSchemaTriggersExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "triggers");
+	const hasDedicatedTriggersExport = hasNamedExport(path.join(functionsDir, "triggers.ts"), "triggers");
+	const hasMigrationsManifest = fs.existsSync(path.join(functionsDir, "migrations", "manifest.ts"));
+	if (hasRelationsExport) throw new Error("Codegen error: do not export `relations` from schema.ts. Chain relations on the default schema export with `defineSchema(...).relations(...)`.");
+	if (hasSchemaTriggersExport || hasDedicatedTriggersExport) throw new Error("Codegen error: do not export `triggers` from schema.ts or triggers.ts. Chain triggers on the default schema export with `defineSchema(...).relations(...).triggers(...)`.");
+	const hasOrmSchema = hasOrmSchemaMetadata;
+	createdSupportPlaceholders = ensureGeneratedSupportPlaceholders(functionsDir, { includeAuth: generateAuth });
+	if (generateApi) {
+		globalThis.__KITCN_CODEGEN__ = true;
+		try {
+			const jitiInstance = getSharedJitiInstance();
+			const serverShimSpecifier = normalizeImportPath(getProjectServerParserShimPath());
+			const files = listFilesRecursive(functionsDir).filter((file) => file.endsWith(".ts") && isValidConvexFile(file));
+			const parseCandidateFiles = files.filter((file) => hasPotentialCodegenExports(fs.readFileSync(path.join(functionsDir, file), "utf8"), file));
+			const existingRuntimeFilesBeforeParse = new Set(listGeneratedRuntimeFiles(functionsDir));
+			const runtimePlaceholderModules = [...new Set([
+				...files.map((file) => file.replace(TS_EXTENSION_RE, "")),
+				...hasOrmSchema ? ["generated/server"] : [],
+				...generateAuth ? [generatedAuthModuleName] : []
+			])];
+			createdRuntimePlaceholders = ensureGeneratedRuntimePlaceholders(functionsDir, runtimePlaceholderModules, resolveModuleRuntimeExportNames(runtimePlaceholderModules, normalizedTrimSegments));
+			for (const file of parseCandidateFiles) {
+				const filePath = path.join(functionsDir, file);
+				const moduleName = file.replace(TS_EXTENSION_RE, "");
+				try {
+					const { meta: moduleMeta, httpRoutes, procedures } = await parseModuleRuntime(filePath, jitiInstance, serverShimSpecifier);
+					if (moduleMeta) {
+						meta[moduleName] = moduleMeta;
+						const fnCount = Object.keys(moduleMeta).length;
+						totalFunctions += fnCount;
+						if (debug) logger.info(`  ✓ ${moduleName}: ${fnCount} functions`);
+					}
+					if (Object.keys(httpRoutes).length > 0 && debug) logger.info(`  ✓ ${moduleName}: ${Object.keys(httpRoutes).length} HTTP routes`);
+					Object.assign(allHttpRoutes, httpRoutes);
+					for (const procedure of procedures) procedureEntries.push({
+						moduleName,
+						exportName: procedure.exportName,
+						internal: procedure.internal,
+						type: procedure.type,
+						kind: "crpc"
+					});
+					const procedureNameEntries = buildProcedureNameLookupEntries({
+						file,
+						filePath,
+						moduleName,
+						procedures
+					});
+					if (procedureNameEntries.length > 0) procedureNameLookup[file] = procedureNameEntries;
+				} catch (error) {
+					const runtimeFile = getGeneratedRuntimeOutputFile(functionsDir, moduleName);
+					if (existingRuntimeFilesBeforeParse.has(runtimeFile)) runtimeFilesPreservedFromParseFailures.add(runtimeFile);
+					const shouldLogParseFailure = debug || file === "http.ts" && !shouldSuppressHttpParseWarning(error);
+					const shouldTreatParseFailureAsFatal = !(file === "http.ts" && shouldSuppressHttpParseWarning(error));
+					if (shouldLogParseFailure) logger.error(`  ⚠ Failed to parse ${file}:`, error);
+					if (shouldTreatParseFailureAsFatal) fatalParseFailures.push({
+						file,
+						error
+					});
+				}
+			}
+		} finally {
+			delete globalThis.__KITCN_CODEGEN__;
+		}
+	}
+	if (fatalParseFailures.length > 0) {
+		for (const createdRuntimePlaceholder of createdRuntimePlaceholders) fs.rmSync(createdRuntimePlaceholder, { force: true });
+		for (const createdSupportPlaceholder of createdSupportPlaceholders) fs.rmSync(createdSupportPlaceholder, { force: true });
+		const failureSummary = fatalParseFailures.map(({ file, error }) => `- ${file}: ${error instanceof Error ? error.message : String(error)}`).join("\n");
+		throw new Error(`kitcn codegen aborted because module parsing failed:\n${failureSummary}`);
+	}
+	cleanupGeneratedPluginArtifacts(functionsDir);
+	if (generateApi) {
+		const routesByPath = /* @__PURE__ */ new Map();
+		for (const [key, route] of Object.entries(allHttpRoutes)) {
+			const pathKey = `${route.path}:${route.method}`;
+			const existing = routesByPath.get(pathKey) || [];
+			existing.push({
+				key,
+				route
+			});
+			routesByPath.set(pathKey, existing);
+		}
+		const dedupedRoutes = {};
+		for (const entries of routesByPath.values()) {
+			const best = entries.reduce((a, b) => a.key.length >= b.key.length ? a : b);
+			dedupedRoutes[best.key] = best.route;
+		}
+		const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+		const httpImportPath = getHttpImportPath(outputFile, functionsDir);
+		const hasTablesExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "tables");
+		const needsInferSelectModelImport = hasTablesExport;
+		const needsInferInsertModelImport = hasTablesExport;
+		const hasHttpRouterExport = hasNamedExport(path.join(functionsDir, "http.ts"), "httpRouter");
+		const apiTree = createApiTree(meta);
+		if (Object.hasOwn(apiTree.children, "http") || apiTree.functions.some((entry) => entry.fnName === "http")) throw new Error("Codegen conflict: root \"http\" namespace is reserved for generated HTTP router types. Rename your Convex module/function.");
+		const apiObjectLines = emitApiObject(apiTree, [], outputFile, functionsDir, 1, dedupedRoutes, hasHttpRouterExport);
+		const apiObjectBody = apiObjectLines.length > 0 ? `\n${apiObjectLines.join("\n")}\n` : "\n";
+		const serverTypeImports = "import type { inferApiInputs, inferApiOutputs } from \"kitcn/server\";";
+		const ormTypeImports = [needsInferInsertModelImport ? "InferInsertModel" : null, needsInferSelectModelImport ? "InferSelectModel" : null].filter((item) => !!item);
+		const optionalImports = [
+			ormTypeImports.length > 0 ? `import type { ${ormTypeImports.join(", ")} } from "kitcn/orm";` : null,
+			hasHttpRouterExport ? `import type { httpRouter } from ${JSON.stringify(httpImportPath)};` : null,
+			hasTablesExport ? `import type { tables } from ${JSON.stringify(schemaImportPath)};` : null
+		].filter((line) => !!line).join("\n");
+		const apiTypeLine = "export type Api = typeof api;";
+		const optionalTypeExports = [hasTablesExport ? `
+export type TableName = keyof typeof tables;
+export type Select<T extends TableName> = InferSelectModel<(typeof tables)[T]>;
+export type Insert<T extends TableName> = InferInsertModel<(typeof tables)[T]>;` : null].filter((entry) => !!entry).join("\n");
+		const output = `// biome-ignore-all format: generated
+// This file is auto-generated by kitcn
+// Do not edit manually. Run \`kitcn codegen\` to regenerate.
+
+import { createApiLeaf, createGeneratedFunctionReference } from "kitcn/server";
+${serverTypeImports}
+${optionalImports ? `\n${optionalImports}` : ""}
+
+export const api = {${apiObjectBody}} as const;
+
+${apiTypeLine}
+export type ApiInputs = inferApiInputs<Api>;
+export type ApiOutputs = inferApiOutputs<Api>;
+${optionalTypeExports}
+`;
+		const outputDirname = path.dirname(outputFile);
+		if (!fs.existsSync(outputDirname)) fs.mkdirSync(outputDirname, { recursive: true });
+		writeFileIfChanged(outputFile, output);
+	} else fs.rmSync(outputFile, { force: true });
+	const serverOutput = emitGeneratedServerFile(serverOutputFile, functionsDir, hasOrmSchema, hasMigrationsManifest, procedureNameLookup);
+	const generatedOutputDirname = path.dirname(serverOutputFile);
+	if (!fs.existsSync(generatedOutputDirname)) fs.mkdirSync(generatedOutputDirname, { recursive: true });
+	writeFileIfChanged(serverOutputFile, serverOutput);
+	fs.rmSync(ormOutputFile, { force: true });
+	fs.rmSync(crpcOutputFile, { force: true });
+	writeFileIfChanged(migrationsHelperOutputFile, emitGeneratedMigrationsFile(migrationsHelperOutputFile, functionsDir, hasRelationsMetadata));
+	fs.rmSync(legacyGeneratedMigrationsOutputFile, { force: true });
+	fs.rmSync(legacyGeneratedMigrationsRuntimeOutputFile, { force: true });
+	fs.rmSync(legacyGeneratedMigrationsUnderscoreOutputFile, { force: true });
+	if (generateAuth) writeFileIfChanged(authOutputFile, emitGeneratedAuthFile(authOutputFile, functionsDir, hasOrmSchema, authContract));
+	else fs.rmSync(authOutputFile, { force: true });
+	fs.rmSync(getLegacyGeneratedOutputFile(functionsDir), { force: true });
+	const mergedProcedureEntries = dedupeProcedureEntries([
+		...hasOrmSchema ? buildGeneratedOrmRuntimeProcedureEntries("generated/server") : [],
+		...generateApi ? procedureEntries : [],
+		...generateAuth && hasAuthDefaultExport ? buildAuthRuntimeProcedureEntries(generatedAuthModuleName) : []
+	]);
+	const runtimeProcedureEntriesByModule = /* @__PURE__ */ new Map();
+	for (const entry of mergedProcedureEntries) {
+		if (RUNTIME_CALLER_RESERVED_EXPORTS.has(entry.exportName)) throw new Error(`Codegen conflict: "${entry.moduleName}.${entry.exportName}" uses reserved runtime caller namespace "${entry.exportName}". Rename the procedure export.`);
+		const existingEntries = runtimeProcedureEntriesByModule.get(entry.moduleName);
+		if (existingEntries) {
+			existingEntries.push(entry);
+			continue;
+		}
+		runtimeProcedureEntriesByModule.set(entry.moduleName, [entry]);
+	}
+	const runtimeOutputFiles = [];
+	const runtimeExportNames = resolveModuleRuntimeExportNames([...runtimeProcedureEntriesByModule.keys()], normalizedTrimSegments);
+	for (const [moduleName, moduleEntries] of [...runtimeProcedureEntriesByModule].sort(([moduleA], [moduleB]) => moduleA.localeCompare(moduleB))) {
+		const runtimeOutputFile = getGeneratedRuntimeOutputFile(functionsDir, moduleName);
+		const runtimeOutput = emitGeneratedModuleRuntimeFile(runtimeOutputFile, functionsDir, moduleName, moduleEntries, runtimeExportNames);
+		fs.mkdirSync(path.dirname(runtimeOutputFile), { recursive: true });
+		writeFileIfChanged(runtimeOutputFile, runtimeOutput);
+		runtimeOutputFiles.push(runtimeOutputFile);
+	}
+	const runtimeOutputFileSet = new Set(runtimeOutputFiles);
+	const existingRuntimeFiles = listGeneratedRuntimeFiles(functionsDir);
+	for (const existingRuntimeFile of existingRuntimeFiles) {
+		if (runtimeOutputFileSet.has(existingRuntimeFile) || runtimeFilesPreservedFromParseFailures.has(existingRuntimeFile)) continue;
+		fs.rmSync(existingRuntimeFile, { force: true });
+	}
+	for (const createdRuntimePlaceholder of createdRuntimePlaceholders) {
+		if (runtimeOutputFileSet.has(createdRuntimePlaceholder) || runtimeFilesPreservedFromParseFailures.has(createdRuntimePlaceholder)) continue;
+		fs.rmSync(createdRuntimePlaceholder, { force: true });
+	}
+	const elapsed = ((Date.now() - startTime) / 1e3).toFixed(2);
+	const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+	if (!silent) if (debug) {
+		if (generateApi) logger.success(`\nGenerated ${outputFile}`);
+		else logger.info(`\nRemoved ${outputFile}`);
+		logger.success(`Generated ${serverOutputFile}`);
+		logger.success(`Generated ${migrationsHelperOutputFile}`);
+		if (generateAuth) logger.success(`Generated ${authOutputFile}`);
+		else logger.info(`Removed ${authOutputFile}`);
+		for (const runtimeOutputFile of runtimeOutputFiles) logger.success(`Generated ${runtimeOutputFile}`);
+		if (generateApi) logger.info(`   ${Object.keys(meta).length} modules, ${totalFunctions} functions`);
+		else logger.info("   cRPC scan skipped for scoped generation");
+	} else logger.success(`${time} Convex api ready! (${elapsed}s)`);
+}
+
+//#endregion
+//#region src/cli/config.ts
+const DEFAULT_JSON_CONFIG_PATH = "kitcn.json";
+const LEGACY_JSON_CONFIG_PATH = "concave.json";
+const CODEGEN_SCOPES = new Set([
+	"all",
+	"auth",
+	"orm"
+]);
+const BACKFILL_ENABLED_VALUES = new Set([
+	"auto",
+	"on",
+	"off"
+]);
+const BACKEND_VALUES = new Set(["convex", "concave"]);
+function createDefaultConfig() {
+	return {
+		backend: "convex",
+		paths: {
+			lib: "convex/lib",
+			shared: "convex/shared"
+		},
+		hooks: { postAdd: [] },
+		dev: {
+			debug: false,
+			args: [],
+			aggregateBackfill: {
+				enabled: "auto",
+				wait: true,
+				batchSize: 1e3,
+				pollIntervalMs: 1e3,
+				timeoutMs: 9e5,
+				strict: false
+			},
+			migrations: {
+				enabled: "auto",
+				wait: true,
+				batchSize: 256,
+				pollIntervalMs: 1e3,
+				timeoutMs: 9e5,
+				strict: false,
+				allowDrift: true
+			}
+		},
+		codegen: {
+			debug: false,
+			args: [],
+			trimSegments: ["plugins"]
+		},
+		deploy: {
+			args: [],
+			aggregateBackfill: {
+				enabled: "auto",
+				wait: true,
+				batchSize: 1e3,
+				pollIntervalMs: 1e3,
+				timeoutMs: 9e5,
+				strict: true
+			},
+			migrations: {
+				enabled: "auto",
+				wait: true,
+				batchSize: 256,
+				pollIntervalMs: 1e3,
+				timeoutMs: 9e5,
+				strict: true,
+				allowDrift: false
+			}
+		}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseBoolean(value, fieldName, configPath) {
+	if (typeof value === "boolean") return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected boolean, got ${typeof value}.`);
+}
+function parseStringArray(value, fieldName, configPath) {
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) throw new Error(`Invalid ${fieldName} in ${configPath}: expected string array.`);
+	return [...value];
+}
+function parseTrimSegments(value, fieldName, configPath) {
+	const segments = parseStringArray(value, fieldName, configPath).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+	for (const segment of segments) if (segment.includes("/") || segment.includes("\\")) throw new Error(`Invalid ${fieldName} in ${configPath}: segment "${segment}" must not contain path separators.`);
+	return [...new Set(segments)];
+}
+function parsePositiveInteger(value, fieldName, configPath) {
+	if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected a positive integer.`);
+}
+function parseNonEmptyString(value, fieldName, configPath) {
+	if (typeof value === "string" && value.trim().length > 0) return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected non-empty string.`);
+}
+function parseSafeRelativePath(value, fieldName, configPath) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new Error(`Invalid ${fieldName} in ${configPath}: expected non-empty string.`);
+	if (value.includes("\0")) throw new Error(`Invalid ${fieldName} in ${configPath}: null byte is not allowed.`);
+	if (path.isAbsolute(value)) throw new Error(`Invalid ${fieldName} in ${configPath}: absolute paths are not allowed.`);
+	const normalizedPosix = path.posix.normalize(value.replace(/\\/g, "/"));
+	if (normalizedPosix === "." || normalizedPosix === ".." || normalizedPosix.startsWith("../") || normalizedPosix.startsWith("/")) throw new Error(`Invalid ${fieldName} in ${configPath}: path traversal is not allowed.`);
+	return normalizedPosix;
+}
+function parseScope(value, fieldName, configPath) {
+	if (typeof value === "string" && CODEGEN_SCOPES.has(value)) return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected one of all, auth, orm.`);
+}
+function parseBackend(value, fieldName, configPath) {
+	if (typeof value === "string" && BACKEND_VALUES.has(value)) return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected one of convex, concave.`);
+}
+function parseBackfillEnabled(value, fieldName, configPath) {
+	if (value === true) return "on";
+	if (value === false) return "off";
+	if (typeof value === "string" && BACKFILL_ENABLED_VALUES.has(value)) return value;
+	throw new Error(`Invalid ${fieldName} in ${configPath}: expected boolean or one of auto, on, off.`);
+}
+function parseAggregateBackfillConfig(value, fieldName, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid ${fieldName} in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, [
+		"enabled",
+		"wait",
+		"batchSize",
+		"pollIntervalMs",
+		"timeoutMs",
+		"strict"
+	], configPath, fieldName);
+	const parsed = {};
+	if ("enabled" in value) parsed.enabled = parseBackfillEnabled(value.enabled, `${fieldName}.enabled`, configPath);
+	if ("wait" in value) parsed.wait = parseBoolean(value.wait, `${fieldName}.wait`, configPath);
+	if ("batchSize" in value) parsed.batchSize = parsePositiveInteger(value.batchSize, `${fieldName}.batchSize`, configPath);
+	if ("pollIntervalMs" in value) parsed.pollIntervalMs = parsePositiveInteger(value.pollIntervalMs, `${fieldName}.pollIntervalMs`, configPath);
+	if ("timeoutMs" in value) parsed.timeoutMs = parsePositiveInteger(value.timeoutMs, `${fieldName}.timeoutMs`, configPath);
+	if ("strict" in value) parsed.strict = parseBoolean(value.strict, `${fieldName}.strict`, configPath);
+	return parsed;
+}
+function parseMigrationConfig(value, fieldName, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid ${fieldName} in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, [
+		"enabled",
+		"wait",
+		"batchSize",
+		"pollIntervalMs",
+		"timeoutMs",
+		"strict",
+		"allowDrift"
+	], configPath, fieldName);
+	const parsed = {};
+	if ("enabled" in value) parsed.enabled = parseBackfillEnabled(value.enabled, `${fieldName}.enabled`, configPath);
+	if ("wait" in value) parsed.wait = parseBoolean(value.wait, `${fieldName}.wait`, configPath);
+	if ("batchSize" in value) parsed.batchSize = parsePositiveInteger(value.batchSize, `${fieldName}.batchSize`, configPath);
+	if ("pollIntervalMs" in value) parsed.pollIntervalMs = parsePositiveInteger(value.pollIntervalMs, `${fieldName}.pollIntervalMs`, configPath);
+	if ("timeoutMs" in value) parsed.timeoutMs = parsePositiveInteger(value.timeoutMs, `${fieldName}.timeoutMs`, configPath);
+	if ("strict" in value) parsed.strict = parseBoolean(value.strict, `${fieldName}.strict`, configPath);
+	if ("allowDrift" in value) parsed.allowDrift = parseBoolean(value.allowDrift, `${fieldName}.allowDrift`, configPath);
+	return parsed;
+}
+function assertNoUnknownKeys(value, allowedKeys, configPath, scope) {
+	const allowed = new Set(allowedKeys);
+	for (const key of Object.keys(value)) {
+		if (allowed.has(key)) continue;
+		const qualifiedKey = scope ? `${scope}.${key}` : key;
+		throw new Error(`Unknown config key "${qualifiedKey}" in ${configPath}.`);
+	}
+}
+function parseCommandConfig(value, fieldName, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid ${fieldName} in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, fieldName === "dev" ? [
+		"debug",
+		"args",
+		"preRun",
+		"aggregateBackfill",
+		"migrations"
+	] : [
+		"debug",
+		"args",
+		"scope",
+		"trimSegments"
+	], configPath, fieldName);
+	const parsed = {};
+	if ("debug" in value) parsed.debug = parseBoolean(value.debug, `${fieldName}.debug`, configPath);
+	if ("args" in value) parsed.args = parseStringArray(value.args, `${fieldName}.args`, configPath);
+	if (fieldName === "dev" && "preRun" in value && value.preRun !== void 0) parsed.preRun = parseNonEmptyString(value.preRun, `${fieldName}.preRun`, configPath);
+	if (fieldName === "codegen" && "scope" in value && value.scope !== void 0) parsed.scope = parseScope(value.scope, `${fieldName}.scope`, configPath);
+	if (fieldName === "codegen" && "trimSegments" in value && value.trimSegments !== void 0) parsed.trimSegments = parseTrimSegments(value.trimSegments, `${fieldName}.trimSegments`, configPath);
+	if (fieldName === "dev" && "aggregateBackfill" in value && value.aggregateBackfill !== void 0) parsed.aggregateBackfill = parseAggregateBackfillConfig(value.aggregateBackfill, `${fieldName}.aggregateBackfill`, configPath);
+	if (fieldName === "dev" && "migrations" in value && value.migrations !== void 0) parsed.migrations = parseMigrationConfig(value.migrations, `${fieldName}.migrations`, configPath);
+	return parsed;
+}
+function parseDeployConfig(value, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid deploy in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, [
+		"args",
+		"aggregateBackfill",
+		"migrations"
+	], configPath, "deploy");
+	const parsed = {};
+	if ("args" in value) parsed.args = parseStringArray(value.args, "deploy.args", configPath);
+	if ("aggregateBackfill" in value && value.aggregateBackfill !== void 0) parsed.aggregateBackfill = parseAggregateBackfillConfig(value.aggregateBackfill, "deploy.aggregateBackfill", configPath);
+	if ("migrations" in value && value.migrations !== void 0) parsed.migrations = parseMigrationConfig(value.migrations, "deploy.migrations", configPath);
+	return parsed;
+}
+function parseHooksConfig(value, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid hooks in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, ["postAdd"], configPath, "hooks");
+	const parsed = {};
+	if ("postAdd" in value && value.postAdd !== void 0) parsed.postAdd = parseStringArray(value.postAdd, "hooks.postAdd", configPath).map((script) => script.trim()).filter((script) => script.length > 0);
+	return parsed;
+}
+function parsePathsConfig(value, configPath) {
+	if (!isRecord(value)) throw new Error(`Invalid paths in ${configPath}: expected object.`);
+	assertNoUnknownKeys(value, [
+		"lib",
+		"shared",
+		"env"
+	], configPath, "paths");
+	const parsed = {};
+	if ("lib" in value && value.lib !== void 0) parsed.lib = parseSafeRelativePath(value.lib, "paths.lib", configPath);
+	if ("shared" in value && value.shared !== void 0) parsed.shared = parseSafeRelativePath(value.shared, "paths.shared", configPath);
+	if ("env" in value && value.env !== void 0) parsed.env = parseSafeRelativePath(value.env, "paths.env", configPath);
+	return parsed;
+}
+function resolveDefaultConfigPath(configPathArg) {
+	if (typeof configPathArg === "string") return {
+		resolvedPath: path.resolve(process.cwd(), configPathArg),
+		explicit: true,
+		legacyPath: null
+	};
+	const jsonPath = path.resolve(process.cwd(), DEFAULT_JSON_CONFIG_PATH);
+	if (fs.existsSync(jsonPath)) return {
+		resolvedPath: jsonPath,
+		explicit: false,
+		legacyPath: null
+	};
+	const legacyPath = path.resolve(process.cwd(), LEGACY_JSON_CONFIG_PATH);
+	if (fs.existsSync(legacyPath)) return {
+		resolvedPath: null,
+		explicit: false,
+		legacyPath
+	};
+	return {
+		resolvedPath: null,
+		explicit: false,
+		legacyPath: null
+	};
+}
+function loadRawConfigFile(resolvedConfigPath) {
+	if (path.extname(resolvedConfigPath).toLowerCase() !== ".json") throw new Error(`Only JSON config files are supported. Received: ${resolvedConfigPath}`);
+	return JSON.parse(fs.readFileSync(resolvedConfigPath, "utf-8"));
+}
+function loadCliConfig(configPathArg) {
+	const { resolvedPath: resolvedConfigPath, explicit: hasExplicitConfigPath, legacyPath } = resolveDefaultConfigPath(configPathArg);
+	if (!hasExplicitConfigPath && legacyPath) throw new Error(`Legacy config file ${LEGACY_JSON_CONFIG_PATH} is no longer supported. Use ${DEFAULT_JSON_CONFIG_PATH}.`);
+	if (!resolvedConfigPath || !fs.existsSync(resolvedConfigPath)) {
+		if (hasExplicitConfigPath) throw new Error(`Config file not found: ${resolvedConfigPath ?? String(configPathArg)}`);
+		return createDefaultConfig();
+	}
+	let rawConfig;
+	try {
+		rawConfig = loadRawConfigFile(resolvedConfigPath);
+	} catch (error) {
+		throw new Error(`Failed to parse config file ${resolvedConfigPath}: ${error.message}`);
+	}
+	if (!isRecord(rawConfig)) throw new Error(`Invalid config file ${resolvedConfigPath}: expected top-level object.`);
+	const parsedConfig = rawConfig;
+	assertNoUnknownKeys(parsedConfig, [
+		"backend",
+		"paths",
+		"hooks",
+		"dev",
+		"codegen",
+		"deploy"
+	], resolvedConfigPath);
+	const config = createDefaultConfig();
+	if ("backend" in parsedConfig && parsedConfig.backend !== void 0) config.backend = parseBackend(parsedConfig.backend, "backend", resolvedConfigPath);
+	if ("hooks" in parsedConfig && parsedConfig.hooks !== void 0) {
+		const parsed = parseHooksConfig(parsedConfig.hooks, resolvedConfigPath);
+		if (parsed.postAdd !== void 0) config.hooks.postAdd = parsed.postAdd;
+	}
+	if ("paths" in parsedConfig && parsedConfig.paths !== void 0) {
+		const parsed = parsePathsConfig(parsedConfig.paths, resolvedConfigPath);
+		if (parsed.lib !== void 0) config.paths.lib = parsed.lib;
+		if (parsed.shared !== void 0) config.paths.shared = parsed.shared;
+		if (parsed.env !== void 0) config.paths.env = parsed.env;
+	}
+	if ("dev" in parsedConfig) {
+		const parsed = parseCommandConfig(parsedConfig.dev, "dev", resolvedConfigPath);
+		if (parsed.debug !== void 0) config.dev.debug = parsed.debug;
+		if (parsed.args !== void 0) config.dev.args = parsed.args;
+		if (parsed.preRun !== void 0) config.dev.preRun = parsed.preRun;
+		if (parsed.aggregateBackfill !== void 0) config.dev.aggregateBackfill = {
+			...config.dev.aggregateBackfill,
+			...parsed.aggregateBackfill
+		};
+		if (parsed.migrations !== void 0) config.dev.migrations = {
+			...config.dev.migrations,
+			...parsed.migrations
+		};
+	}
+	if ("codegen" in parsedConfig) {
+		const parsed = parseCommandConfig(parsedConfig.codegen, "codegen", resolvedConfigPath);
+		if (parsed.debug !== void 0) config.codegen.debug = parsed.debug;
+		if (parsed.args !== void 0) config.codegen.args = parsed.args;
+		if (parsed.scope !== void 0) config.codegen.scope = parsed.scope;
+		if (parsed.trimSegments !== void 0) config.codegen.trimSegments = parsed.trimSegments;
+	}
+	if ("deploy" in parsedConfig) {
+		const parsed = parseDeployConfig(parsedConfig.deploy, resolvedConfigPath);
+		if (parsed.args !== void 0) config.deploy.args = parsed.args;
+		if (parsed.aggregateBackfill !== void 0) config.deploy.aggregateBackfill = {
+			...config.deploy.aggregateBackfill,
+			...parsed.aggregateBackfill
+		};
+		if (parsed.migrations !== void 0) config.deploy.migrations = {
+			...config.deploy.migrations,
+			...parsed.migrations
+		};
+	}
+	return config;
+}
+function resolveConfiguredBackend(params) {
+	return params.backendArg ?? params.config?.backend ?? "convex";
+}
+
+//#endregion
+//#region src/cli/local-env.ts
+/**
+* Local `.env` resolution for codegen and backend spawns.
+*
+* Lives outside `backend-core.ts` so the long-lived `kitcn dev` watcher child
+* can reach it without pulling the CLI's full command graph (execa, the prompt
+* stack, the analyzer) into a process that only runs codegen.
+*/
+const resolveEnvPaths = (sharedDir) => {
+	const { functionsDir } = getConvexConfig(sharedDir);
+	return {
+		backendEnvPath: join(functionsDir, "..", ".env"),
+		rootEnvPath: join(process.cwd(), ".env")
+	};
+};
+const mergeEnvFiles = (envPaths) => {
+	const mergedEnv = {};
+	for (const envPath of envPaths) {
+		if (!fs.existsSync(envPath)) continue;
+		Object.assign(mergedEnv, loadDotenv().parse(fs.readFileSync(envPath, "utf8")));
+	}
+	return mergedEnv;
+};
+function getLocalParseEnvVars(sharedDir, backend) {
+	const { backendEnvPath, rootEnvPath } = resolveEnvPaths(sharedDir);
+	return mergeEnvFiles(backend === "concave" ? [backendEnvPath, rootEnvPath] : [rootEnvPath, backendEnvPath]);
+}
+function getLocalBackendEnvVars(sharedDir, backend) {
+	const { backendEnvPath, rootEnvPath } = resolveEnvPaths(sharedDir);
+	return mergeEnvFiles(backend === "concave" ? [backendEnvPath, rootEnvPath] : [backendEnvPath]);
+}
+async function withLocalCodegenEnv(sharedDir, backend, fn) {
+	const envVars = getLocalParseEnvVars(sharedDir, backend);
+	if (Object.keys(envVars).length === 0) return fn();
+	const previousValues = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(envVars)) {
+		previousValues.set(key, process.env[key]);
+		process.env[key] = value;
+	}
+	try {
+		return await fn();
+	} finally {
+		for (const [key, value] of previousValues.entries()) if (value === void 0) delete process.env[key];
+		else process.env[key] = value;
+	}
+}
+
+//#endregion
+export { createSystemFields as C, TableName as S, getSchemaRelations as _, generateMeta as a, OrmSchemaExtensions as b, PARSE_SNAPSHOT_SUFFIX as c, loadBabelParser as d, loadClackPrompts as f, isColorEnabled as g, highlighter as h, resolveConfiguredBackend as i, createProjectJiti as l, loadEsbuild as m, withLocalCodegenEnv as n, getConvexConfig as o, loadDotenv as p, loadCliConfig as r, logger as s, getLocalBackendEnvVars as t, CRPC_BUILDER_STUB_SOURCE as u, Columns as v, RlsPolicies as x, EnableRLS as y };