kitcn 0.23.0 → 0.25.0

package/dist/{local-env-yFKub75x.mjs → local-env-Du24tdbp.mjs}

@@ -4,8 +4,8 @@ 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";
+import "convex/server";
 
 //#region src/orm/builders/column-builder.ts
 /**
@@ -220,2213 +220,2228 @@ 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";
-};
+//#region src/orm/index-utils.ts
+function getIndexes(table) {
+	const indexes = table.getIndexes?.();
+	return Array.isArray(indexes) ? indexes : [];
+}
+function getAggregateIndexes(table) {
+	const indexes = table.getAggregateIndexes?.();
+	return Array.isArray(indexes) ? indexes : [];
+}
+function getRankIndexes(table) {
+	const indexes = table.getRankIndexes?.();
+	return Array.isArray(indexes) ? indexes : [];
+}
 
 //#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;
+//#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));
 	}
 };
-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());
+//#region src/cli/utils/lazy-deps.ts
 /**
-* 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()
+* Heavy CLI-only dependencies, resolved on first use instead of at module init.
 *
-* // Already required validators are returned as-is
-* const alreadyRequired = v.string();
-* const stillRequired = vRequired(alreadyRequired); // v.string()
-* ```
+* `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.
 *
-* @param validator The validator to make required.
-* @returns A required version of the validator.
+* 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.
 */
-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);
-	}
-}
+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/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();
-}
+//#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);
+  },
+});
 
-//#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;
-	}
+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;
 };
-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;
-	}
+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;
 };
-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;
-	}
+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,
+    };
+  },
 };
-function text(name) {
-	return new ConvexTextBuilder(name ?? "");
-}
+
+export const httpAction = createProcedureBuilder();
+`;
 
 //#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
-	});
+//#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;
+  }
 }
 
-//#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);
-	}
+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 });
 };
-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;
+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;
 	}
-};
-var ConvexSearchIndexBuilderOn = class {
-	static [entityKind] = "ConvexSearchIndexBuilderOn";
-	[entityKind] = "ConvexSearchIndexBuilderOn";
-	constructor(name) {
-		this.name = name;
+	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;
 	}
-	on(searchField) {
-		return new ConvexSearchIndexBuilder(this.name, searchField);
+	for (const value of Object.values(record)) {
+		const resolved = resolveJitiExportTarget(value);
+		if (resolved) return resolved;
 	}
+	return null;
 };
-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;
+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);
 	}
-	staged() {
-		this.config.staged = true;
-		return this;
+	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;
 	}
 };
-var ConvexVectorIndexBuilderOn = class {
-	static [entityKind] = "ConvexVectorIndexBuilderOn";
-	[entityKind] = "ConvexVectorIndexBuilderOn";
-	constructor(name) {
-		this.name = name;
+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);
 	}
-	on(vectorField) {
-		return new ConvexVectorIndexBuilder(this.name, vectorField);
+	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/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";
 };
-var ConvexAggregateIndexBuilderOn = class {
-	static [entityKind] = "ConvexAggregateIndexBuilderOn";
-	[entityKind] = "ConvexAggregateIndexBuilderOn";
+
+//#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) {
-		this.name = name;
+		super(name, "boolean", "ConvexBoolean");
 	}
-	on(...columns) {
-		return new ConvexAggregateIndexBuilder(this.name, columns);
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.boolean();
+		return v.optional(v.union(v.null(), v.boolean()));
 	}
-	all() {
-		return new ConvexAggregateIndexBuilder(this.name, []);
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.boolean()
+	* nullable → v.optional(v.boolean())
+	*/
+	build() {
+		return this.convexValidator;
 	}
 };
-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";
+function boolean$1(name) {
+	return new ConvexBooleanBuilder(name ?? "");
 }
 
 //#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.`);
-}
+//#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());
 /**
-* Create a Convex object validator from column builders
+* Converts an optional validator to a required validator.
 *
-* Extracts .convexValidator from each column and creates v.object({...})
-* This is the core factory that bridges ORM columns to Convex validators.
+* This is the inverse of `v.optional()`. It takes a validator that may be optional
+* and returns the equivalent required validator.
 *
-* @param columns - Record of column name to column builder
-* @returns Convex object 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 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 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);
 	}
-};
-function isConvexIndexBuilder(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilder";
 }
-function isConvexIndexBuilderOn(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilderOn";
+
+//#endregion
+//#region src/orm/builders/custom.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isConvexAggregateIndexBuilder(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilder";
+function isValidator(value) {
+	return isRecord$2(value) && typeof value.kind === "string" && typeof value.isOptional === "string";
 }
-function isConvexAggregateIndexBuilderOn(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilderOn";
+function isColumnBuilder$1(value) {
+	return isRecord$2(value) && value[entityKind] === "ColumnBuilder";
 }
-function isConvexRankIndexBuilderOn(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilderOn";
+function toRequiredValidator(validator) {
+	return validator.isOptional === "optional" ? vRequired(validator) : validator;
 }
-function isConvexRankIndexBuilder(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilder";
+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 isConvexUniqueConstraintBuilderOn(value) {
-	return typeof value === "object" && value !== null && value[entityKind] === "ConvexUniqueConstraintBuilderOn";
+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 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 objectShapeToValidator(shape, path) {
+	const fields = {};
+	for (const [key, value] of Object.entries(shape)) fields[key] = nestedInputToValidator(value, `${path}.${key}`);
+	return v.object(fields);
 }
-function getColumnType(column) {
-	return column.config?.columnType;
+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));
 }
-function getColumnDimensions(column) {
-	return column.config?.dimensions;
+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);
 }
-function getColumnTableName(column) {
-	const config = column.config;
-	return config?.tableName ?? config?.referenceTable;
+/**
+* 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();
 }
-function getColumnTable(column) {
-	return column.config?.table;
+/**
+* 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();
 }
-function getUniqueIndexName(tableName, fields, explicitName) {
-	if (explicitName) return explicitName;
-	return `${tableName}_${fields.join("_")}_unique`;
+/**
+* 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();
 }
-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);
+
+//#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);
 }
-function assertNoReservedCreatedAtIndexFields(fields, context) {
-	if (fields.includes("createdAt")) throw new Error(`${context} cannot use 'createdAt'. 'createdAt' is reserved and maps to internal '_creationTime'.`);
+
+//#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 ?? "");
 }
-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}'.`);
+
+//#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 ?? "");
 }
-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}'.`);
+
+//#endregion
+//#region src/orm/extensions.ts
+function defineChainMethod(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: false,
+		configurable: true
+	});
 }
-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 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 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 defineSchemaExtension(key, tables) {
+	return createSchemaExtensionChain({
+		key,
+		tables,
+		relations: void 0,
+		triggers: void 0
+	}, {
+		canRelations: true,
+		canTriggers: true
+	});
 }
-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;
+
+//#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);
+	}
 };
-const getPolymorphicFieldSignature = (column) => {
-	const validator = column.convexValidator ?? column.build();
-	return JSON.stringify({
-		columnType: column.config?.columnType,
-		validator: validator?.json
-	});
+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;
+	}
 };
-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
-		});
+var ConvexSearchIndexBuilderOn = class {
+	static [entityKind] = "ConvexSearchIndexBuilderOn";
+	[entityKind] = "ConvexSearchIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
 	}
-	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);
+	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
+				};
 			}
-			variantRuntime[variantKey] = {
-				fieldNames,
-				requiredFieldNames
+			return {
+				column: entry,
+				direction: "asc"
 			};
-		}
-		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)
 		});
+		this.config.orderColumns = [...this.config.orderColumns, ...orderColumns];
+		return this;
 	}
-	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;
+	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;
 		}
-		throw new Error(`Unsupported extra config value in convexTable('${table.tableName}').`);
 	}
+	link(table) {
+		this._linkedTable = table;
+		return this;
+	}
+};
+function isRlsPolicy(value) {
+	return !!value && typeof value === "object" && value[entityKind] === "RlsPolicy";
 }
+
+//#endregion
+//#region src/orm/table.ts
 /**
-* 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)
+* Reserved Convex system table names that cannot be used
 */
-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
-		});
+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;
 	}
-	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
+};
+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
 		});
 	}
-	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);
+	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)
+		});
 	}
-	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}`);
+	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;
 			}
-			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],
+			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: [foreignColumnName],
-				onDelete: deferred.config.onDelete,
-				onUpdate: deferred.config.onUpdate
+				foreignColumns: foreignFields,
+				onDelete,
+				onUpdate
 			});
+			continue;
 		}
-		this.deferredForeignKeys = [];
+		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 {
 	/**
-	* Internal: expose foreign key metadata for mutation enforcement
+	* Required by TableDefinition
+	* Public validator property containing v.object({...}) with all column validators
 	*/
-	getForeignKeys() {
-		this.resolveDeferredForeignKeys();
-		return this.foreignKeys;
-	}
-	addCheck(name, expression) {
-		this.checks.push({
-			name,
-			expression
-		});
-	}
-	getChecks() {
-		return this.checks;
-	}
+	validator;
 	/**
-	* Internal: add search index to table from builder extraConfig
+	* TableDefinition private fields
+	* These satisfy structural typing requirements for defineSchema()
 	*/
-	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);
-	}
+	indexes = [];
+	uniqueIndexes = [];
+	aggregateIndexes = [];
+	rankIndexes = [];
+	foreignKeys = [];
+	deferredForeignKeys = [];
+	deferredForeignKeysResolved = false;
+	stagedDbIndexes = [];
+	searchIndexes = [];
+	stagedSearchIndexes = [];
+	vectorIndexes = [];
+	stagedVectorIndexes = [];
+	checks = [];
 	/**
-	* Internal: add vector index to table from builder extraConfig
+	* Symbol-based metadata storage
 	*/
-	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);
-	}
+	[TableName];
+	[Columns];
+	[Brand] = "ConvexTable";
+	[EnableRLS] = false;
+	[RlsPolicies] = [];
+	[TableDeleteConfig];
+	[TablePolymorphic];
 	/**
-	* Export the contents of this definition for Convex schema tooling.
-	* Mirrors convex/server TableDefinition.export().
+	* Public tableName for convenience
 	*/
-	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),
-	index("by_table_status").on(t.tableKey, 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);
+	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
+			});
 		}
-		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;
+	getPolymorphicConfigs() {
+		return this[TablePolymorphic];
 	}
-};
-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;
+	/**
+	* Internal: add index to table from builder extraConfig
+	*
+	*/
+	addIndex(name, fields) {
+		this.indexes.push({
+			indexDescriptor: name,
+			fields
 		});
-		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;
+	}
+	/**
+	* Internal: add unique index metadata for runtime enforcement
+	*/
+	addUniqueIndex(name, fields, nullsNotDistinct) {
+		this.uniqueIndexes.push({
+			name,
+			fields,
+			nullsNotDistinct
 		});
-		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;
+	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
 		});
-		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;
+	}
+	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
 		});
-		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;
+	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];
 	}
-	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`);
+	/**
+	* 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}`);
 			}
-			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}"`);
+			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
+			});
 		}
-		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;
+		this.deferredForeignKeys = [];
 	}
-	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);
+	/**
+	* Internal: expose foreign key metadata for mutation enforcement
+	*/
+	getForeignKeys() {
+		this.resolveDeferredForeignKeys();
+		return this.foreignKeys;
 	}
-	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);
-		}
+	addCheck(name, expression) {
+		this.checks.push({
+			name,
+			expression
+		});
 	}
-	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);
-		}
+	getChecks() {
+		return this.checks;
 	}
-	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);
+	/**
+	* 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);
 	}
-	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));
+	/**
+	* 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
+		};
 	}
 };
-
-//#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 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 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 convexTableWithRLS = (name, columns, extraConfig) => {
+	const table = convexTableInternal(name, columns, extraConfig);
+	table[EnableRLS] = true;
+	return table;
 };
+const convexTable = Object.assign(convexTableInternal, { withRLS: convexTableWithRLS });
 
-const createRouter = (record = {}) => ({
-  _def: {
-    router: true,
-    procedures: flattenRouterRecord(record),
-    record,
-  },
+//#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),
+	index("by_table_status").on(t.tableKey, 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()
 });
-
-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,
-    };
-  },
+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
 };
-
-export const httpAction = createProcedureBuilder();
-`;
+function aggregateExtension() {
+	return defineSchemaExtension("aggregate", aggregateStorageTables);
+}
 
 //#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;
-  }
+//#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);
 }
 
-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 });
+//#endregion
+//#region src/orm/relations.ts
+var RelationsBuilderTable = class {
+	static [entityKind] = "RelationsBuilderTable";
+	_;
+	constructor(table, name) {
+		this._ = {
+			name,
+			table
+		};
+	}
 };
-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;
+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);
 		}
-		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;
+		this.one = one;
+		this.many = many;
 	}
-	for (const value of Object.values(record)) {
-		const resolved = resolveJitiExportTarget(value);
-		if (resolved) return resolved;
+	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;
 	}
-	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);
+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;
 	}
-	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;
+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)
+		};
+	}
 };
-const trimTsconfigWildcardSuffix = (value) => value.endsWith("/*") ? value.slice(0, -2) : value;
-const loadTypeScript = () => {
-	try {
-		return require("typescript");
-	} catch {
-		return null;
+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);
 	}
-};
-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 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 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)
+	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/shared/meta-utils.ts
@@ -2510,6 +2525,56 @@ const logger = {
 	}
 };
 
+//#endregion
+//#region src/cli/utils/schema-tables.ts
+/**
+* Schema introspection shared by codegen and the backend flows.
+*
+* Both need the same answer to "does this app use aggregate/rank indexes?":
+* codegen registers `aggregateCapability()` on it, and the CLI skips the
+* backfill flows on it. Two implementations would drift into a state where the
+* generated ORM refuses a call the CLI still makes.
+*/
+/** The `defineSchema(...)` value behind a loaded `schema.ts` module. */
+function resolveSchemaDefaultExport(schemaModule) {
+	const schemaValue = schemaModule.default !== void 0 ? schemaModule.default : schemaModule;
+	if (!schemaValue || typeof schemaValue !== "object") return null;
+	return schemaValue;
+}
+/**
+* Every live table behind a schema value.
+*
+* `SchemaDefinition.tables` is the merged base + plugin-extension map, so auth,
+* ratelimit and the built-in aggregate/migration bookkeeping tables are all
+* covered. The relations config is unioned in because a `.relations()` chain
+* re-materializes the definition, and it is absent for schemas that declare
+* neither relations nor triggers.
+*/
+function collectSchemaTables(schemaValue) {
+	const allTables = /* @__PURE__ */ new Set();
+	const relations = getSchemaRelations(schemaValue);
+	if (relations && typeof relations === "object" && !Array.isArray(relations)) for (const relationConfig of Object.values(relations)) {
+		const table = relationConfig?.table;
+		if (table) allTables.add(table);
+	}
+	const tables = schemaValue.tables;
+	if (tables && typeof tables === "object" && !Array.isArray(tables)) {
+		for (const table of Object.values(tables)) if (table) allTables.add(table);
+	}
+	return [...allTables];
+}
+/**
+* Whether the schema needs the aggregate-index runtime.
+*
+* `aggregateIndex(...)` / `rankIndex(...)` register synchronously inside
+* `convexTable(...)`, so the answer is final once `schema.ts` has evaluated.
+* Duck-typed rather than routed through `getTableConfig`, which throws on a
+* raw Convex `defineTable()` in a mixed schema.
+*/
+function schemaDeclaresAggregateIndexes(schemaValue) {
+	return collectSchemaTables(schemaValue).some((table) => getAggregateIndexes(table).length > 0 || getRankIndexes(table).length > 0);
+}
+
 //#endregion
 //#region src/cli/codegen.ts
 /** Valid JS identifier pattern for object keys */
@@ -2606,49 +2671,51 @@ const GENERATED_ORM_RUNTIME_PROCEDURES = [
 		type: "mutation"
 	},
 	{
-		exportName: "aggregateBackfill",
+		exportName: "migrationRun",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "aggregateBackfillChunk",
+		exportName: "migrationRunChunk",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "aggregateBackfillStatus",
+		exportName: "migrationStatus",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "migrationRun",
+		exportName: "migrationCancel",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "migrationRunChunk",
+		exportName: "resetChunk",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "migrationStatus",
+		exportName: "reset",
 		internal: true,
-		type: "mutation"
-	},
+		type: "action"
+	}
+];
+const GENERATED_AGGREGATE_RUNTIME_PROCEDURES = [
 	{
-		exportName: "migrationCancel",
+		exportName: "aggregateBackfill",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "resetChunk",
+		exportName: "aggregateBackfillChunk",
 		internal: true,
 		type: "mutation"
 	},
 	{
-		exportName: "reset",
+		exportName: "aggregateBackfillStatus",
 		internal: true,
-		type: "action"
+		type: "mutation"
 	}
 ];
 function listFilesRecursive(cwd, relDir = "") {
@@ -2848,6 +2915,9 @@ const GENERATED_DIR = "generated";
 function getGeneratedServerOutputFile(functionsDir) {
 	return path.join(functionsDir, GENERATED_DIR, "server.ts");
 }
+function getGeneratedAggregateOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "aggregate.ts");
+}
 function getGeneratedOrmOutputFile(functionsDir) {
 	return path.join(functionsDir, GENERATED_DIR, "orm.ts");
 }
@@ -2991,34 +3061,44 @@ function listGeneratedRuntimeFiles(functionsDir) {
 	if (!fs.existsSync(generatedDir)) return [];
 	return listFilesRecursive(generatedDir).filter((file) => file.endsWith(".runtime.ts")).map((file) => path.join(generatedDir, file));
 }
+const EMPTY_SCHEMA_METADATA = {
+	hasOrmSchema: false,
+	hasAggregateIndexes: false,
+	hasRelations: false,
+	hasTriggers: false
+};
 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
-	};
+	if (!fs.existsSync(schemaPath)) return EMPTY_SCHEMA_METADATA;
 	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
-		};
+		if (!schemaValue || typeof schemaValue !== "object") return EMPTY_SCHEMA_METADATA;
+		const hasOrmSchema = OrmSchemaOptions in schemaValue;
+		const hasRelations = Boolean(getSchemaRelations(schemaValue));
+		const hasTriggers = Boolean(getSchemaTriggers(schemaValue));
 		return {
-			hasOrmSchema: OrmSchemaOptions in schemaValue,
-			hasRelations: Boolean(getSchemaRelations(schemaValue)),
-			hasTriggers: Boolean(getSchemaTriggers(schemaValue))
+			hasOrmSchema,
+			hasAggregateIndexes: hasOrmSchema && resolveHasAggregateIndexes(schemaValue, schemaPath, debug),
+			hasRelations,
+			hasTriggers
 		};
 	} catch (error) {
 		if (debug) logger.warn(`⚠️  Failed to load schema extensions from ${schemaPath}: ${error.message}`);
-		return {
-			hasOrmSchema: false,
-			hasRelations: false,
-			hasTriggers: false
-		};
+		return EMPTY_SCHEMA_METADATA;
+	}
+}
+/**
+* Fails open: registering an unused capability only costs bundle size, while
+* omitting a needed one breaks `createOrm()` for every function in the app.
+*/
+function resolveHasAggregateIndexes(schemaValue, schemaPath, debug) {
+	try {
+		return schemaDeclaresAggregateIndexes(schemaValue);
+	} catch (error) {
+		if (debug) logger.warn(`⚠️  Failed to inspect aggregate indexes in ${schemaPath}: ${error.message}`);
+		return true;
 	}
 }
 function cleanupGeneratedPluginArtifacts(functionsDir) {
@@ -3027,7 +3107,7 @@ function cleanupGeneratedPluginArtifacts(functionsDir) {
 		force: true
 	});
 }
-function emitGeneratedServerFile(outputFile, functionsDir, hasOrmSchema, hasMigrationsManifest, procedureNameLookup) {
+function emitGeneratedServerFile(outputFile, functionsDir, hasOrmSchema, hasAggregateIndexes, hasMigrationsManifest, procedureNameLookup) {
 	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
 	const serverTypesImportPath = getServerTypesImportPath(outputFile, functionsDir);
 	const dataModelImportPath = getDataModelImportPath(outputFile, functionsDir);
@@ -3039,6 +3119,9 @@ function emitGeneratedServerFile(outputFile, functionsDir, hasOrmSchema, hasMigr
 	const migrationsManifestImportLiteral = asSingleQuotedImport(migrationsManifestImportPath);
 	const migrationsImportLine = hasMigrationsManifest ? `import { migrations } from ${migrationsManifestImportLiteral};\n` : "";
 	const migrationsConfigLine = hasMigrationsManifest ? "  migrations,\n" : "";
+	const capabilityImportLines = [hasAggregateIndexes ? "import { aggregateCapability } from 'kitcn/orm/aggregate-index';\n" : "", hasMigrationsManifest ? "import { migrationCapability } from 'kitcn/orm/migrations';\n" : ""].join("");
+	const capabilityEntries = [...hasAggregateIndexes ? ["aggregateCapability()"] : [], ...hasMigrationsManifest ? ["migrationCapability()"] : []];
+	const capabilitiesConfigLine = capabilityEntries.length > 0 ? `  capabilities: [${capabilityEntries.join(", ")}],\n` : "";
 	const functionsDirHint = normalizeImportPath(path.relative(process.cwd(), functionsDir)) || "convex";
 	const procedureNameLookupLiteral = emitProcedureNameLookupLiteral(procedureNameLookup);
 	if (!hasOrmSchema) return `// biome-ignore-all format: generated
@@ -3080,6 +3163,7 @@ export const initCRPC = baseInitCRPC.dataModel<DataModel>().context({
 export { httpAction, internalMutation };
 `;
 	const moduleNamespace = getModuleNameFromOutputFile(outputFile, functionsDir);
+	const aggregateModuleNamespace = getModuleNameFromOutputFile(getGeneratedAggregateOutputFile(functionsDir), functionsDir);
 	return `// biome-ignore-all format: generated
 // This file is auto-generated by kitcn
 // Do not edit manually. Run \`kitcn codegen\` to regenerate.
@@ -3089,7 +3173,7 @@ import {
   type GenericOrmCtx,
   type OrmFunctions,
 } from 'kitcn/orm';
-import {
+${capabilityImportLines}import {
   createGeneratedFunctionReference,
   initCRPC as baseInitCRPC,
   registerProcedureNameLookup,
@@ -3107,7 +3191,7 @@ ${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`)}),
+  aggregateBackfillChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${aggregateModuleNamespace}:aggregateBackfillChunk`)}),
   migrationRunChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:migrationRunChunk`)}),
   resetChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:resetChunk`)}),
 };`}
@@ -3121,7 +3205,7 @@ registerProcedureNameLookup(
 export const orm = createOrm({
   schema: ormSchema,
   ormFunctions,
-${migrationsConfigLine}  internalMutation,
+${capabilitiesConfigLine}${migrationsConfigLine}  internalMutation,
 });
 
 export type OrmCtx<Ctx extends ServerQueryCtx | ServerMutationCtx = ServerQueryCtx> = GenericOrmCtx<Ctx, typeof ormSchema>;
@@ -3144,9 +3228,6 @@ export { httpAction, internalMutation };
 export const {
   scheduledMutationBatch,
   scheduledDelete,
-  aggregateBackfill,
-  aggregateBackfillChunk,
-  aggregateBackfillStatus,
   migrationRun,
   migrationRunChunk,
   migrationStatus,
@@ -3156,6 +3237,41 @@ export const {
 } = orm.api();
 `;
 }
+function emitGeneratedAggregateFile(outputFile, functionsDir) {
+	const schemaImportLiteral = JSON.stringify(getSchemaImportPath(outputFile, functionsDir));
+	const serverTypesImportLiteral = JSON.stringify(getServerTypesImportPath(outputFile, functionsDir));
+	const moduleNamespace = getModuleNameFromOutputFile(outputFile, functionsDir);
+	const serverModuleNamespace = getModuleNameFromOutputFile(getGeneratedServerOutputFile(functionsDir), 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 OrmFunctions } from 'kitcn/orm';
+import { aggregateCapability } from 'kitcn/orm/aggregate-index';
+import { createGeneratedFunctionReference } from 'kitcn/server';
+import { internalMutation } from ${serverTypesImportLiteral};
+import schema from ${schemaImportLiteral};
+
+const ormFunctions: OrmFunctions = {
+  scheduledMutationBatch: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${serverModuleNamespace}:scheduledMutationBatch`)}),
+  scheduledDelete: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${serverModuleNamespace}:scheduledDelete`)}),
+  aggregateBackfillChunk: createGeneratedFunctionReference<"mutation", "internal", unknown>(${JSON.stringify(`${moduleNamespace}:aggregateBackfillChunk`)}),
+};
+
+const orm = createOrm({
+  schema,
+  ormFunctions,
+  capabilities: [aggregateCapability()],
+  internalMutation,
+});
+
+export const {
+  aggregateBackfill,
+  aggregateBackfillChunk,
+  aggregateBackfillStatus,
+} = orm.api();
+`;
+}
 function emitGeneratedAuthFile(outputFile, functionsDir, hasOrmSchema, authContract) {
 	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
 	const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
@@ -3521,6 +3637,13 @@ function buildGeneratedOrmRuntimeProcedureEntries(moduleName) {
 		kind: "dispatch"
 	}));
 }
+function buildGeneratedAggregateRuntimeProcedureEntries(moduleName) {
+	return GENERATED_AGGREGATE_RUNTIME_PROCEDURES.map((entry) => ({
+		...entry,
+		moduleName,
+		kind: "dispatch"
+	}));
+}
 function partitionRuntimeEntriesForEmission(entries) {
 	return {
 		callerEntries: entries,
@@ -3616,6 +3739,7 @@ async function generateMeta(sharedDir, options) {
 	const startTime = Date.now();
 	const { functionsDir, outputFile } = getConvexConfig(sharedDir);
 	const serverOutputFile = getGeneratedServerOutputFile(functionsDir);
+	const aggregateOutputFile = getGeneratedAggregateOutputFile(functionsDir);
 	const ormOutputFile = getGeneratedOrmOutputFile(functionsDir);
 	const crpcOutputFile = getGeneratedCrpcOutputFile(functionsDir);
 	const authOutputFile = getGeneratedAuthOutputFile(functionsDir);
@@ -3670,6 +3794,7 @@ async function generateMeta(sharedDir, options) {
 			const runtimePlaceholderModules = [...new Set([
 				...files.map((file) => file.replace(TS_EXTENSION_RE, "")),
 				...hasOrmSchema ? ["generated/server"] : [],
+				...hasOrmSchema ? ["generated/aggregate"] : [],
 				...generateAuth ? [generatedAuthModuleName] : []
 			])];
 			createdRuntimePlaceholders = ensureGeneratedRuntimePlaceholders(functionsDir, runtimePlaceholderModules, resolveModuleRuntimeExportNames(runtimePlaceholderModules, normalizedTrimSegments));
@@ -3780,10 +3905,12 @@ ${optionalTypeExports}
 		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 serverOutput = emitGeneratedServerFile(serverOutputFile, functionsDir, hasOrmSchema, schemaMetadata.hasAggregateIndexes, hasMigrationsManifest, procedureNameLookup);
 	const generatedOutputDirname = path.dirname(serverOutputFile);
 	if (!fs.existsSync(generatedOutputDirname)) fs.mkdirSync(generatedOutputDirname, { recursive: true });
 	writeFileIfChanged(serverOutputFile, serverOutput);
+	if (hasOrmSchema) writeFileIfChanged(aggregateOutputFile, emitGeneratedAggregateFile(aggregateOutputFile, functionsDir));
+	else fs.rmSync(aggregateOutputFile, { force: true });
 	fs.rmSync(ormOutputFile, { force: true });
 	fs.rmSync(crpcOutputFile, { force: true });
 	writeFileIfChanged(migrationsHelperOutputFile, emitGeneratedMigrationsFile(migrationsHelperOutputFile, functionsDir, hasRelationsMetadata));
@@ -3795,6 +3922,7 @@ ${optionalTypeExports}
 	fs.rmSync(getLegacyGeneratedOutputFile(functionsDir), { force: true });
 	const mergedProcedureEntries = dedupeProcedureEntries([
 		...hasOrmSchema ? buildGeneratedOrmRuntimeProcedureEntries("generated/server") : [],
+		...hasOrmSchema ? buildGeneratedAggregateRuntimeProcedureEntries("generated/aggregate") : [],
 		...generateApi ? procedureEntries : [],
 		...generateAuth && hasAuthDefaultExport ? buildAuthRuntimeProcedureEntries(generatedAuthModuleName) : []
 	]);
@@ -3838,6 +3966,8 @@ ${optionalTypeExports}
 		if (generateApi) logger.success(`\nGenerated ${outputFile}`);
 		else logger.info(`\nRemoved ${outputFile}`);
 		logger.success(`Generated ${serverOutputFile}`);
+		if (hasOrmSchema) logger.success(`Generated ${aggregateOutputFile}`);
+		else logger.info(`Removed ${aggregateOutputFile}`);
 		logger.success(`Generated ${migrationsHelperOutputFile}`);
 		if (generateAuth) logger.success(`Generated ${authOutputFile}`);
 		else logger.info(`Removed ${authOutputFile}`);
@@ -4220,4 +4350,4 @@ async function withLocalCodegenEnv(sharedDir, backend, fn) {
 }
 
 //#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 };
+export { Columns as C, TableName as D, RlsPolicies as E, createSystemFields as O, getRankIndexes as S, OrmSchemaExtensions as T, loadEsbuild as _, generateMeta as a, getAggregateIndexes as b, resolveSchemaDefaultExport as c, PARSE_SNAPSHOT_SUFFIX as d, createProjectJiti as f, loadDotenv as g, loadClackPrompts as h, resolveConfiguredBackend as i, schemaDeclaresAggregateIndexes as l, loadBabelParser as m, withLocalCodegenEnv as n, getConvexConfig as o, CRPC_BUILDER_STUB_SOURCE as p, loadCliConfig as r, collectSchemaTables as s, getLocalBackendEnvVars as t, logger as u, highlighter as v, EnableRLS as w, getIndexes as x, isColorEnabled as y };