kitcn 0.24.0 → 0.25.0

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as createSystemFields, S as TableName, _ as getSchemaRelations, a as generateMeta, b as OrmSchemaExtensions, d as loadBabelParser, f as loadClackPrompts, g as isColorEnabled, h as highlighter, i as resolveConfiguredBackend, l as createProjectJiti, m as loadEsbuild, n as withLocalCodegenEnv, o as getConvexConfig, p as loadDotenv, r as loadCliConfig, s as logger, t as getLocalBackendEnvVars, u as CRPC_BUILDER_STUB_SOURCE, v as Columns, x as RlsPolicies, y as EnableRLS } from "./local-env-yFKub75x.mjs";
+import { C as Columns, D as TableName, E as RlsPolicies, O as createSystemFields, S as getRankIndexes, T as OrmSchemaExtensions, _ as loadEsbuild, a as generateMeta, b as getAggregateIndexes, c as resolveSchemaDefaultExport, f as createProjectJiti, g as loadDotenv, h as loadClackPrompts, i as resolveConfiguredBackend, l as schemaDeclaresAggregateIndexes, m as loadBabelParser, n as withLocalCodegenEnv, o as getConvexConfig, p as CRPC_BUILDER_STUB_SOURCE, r as loadCliConfig, s as collectSchemaTables, t as getLocalBackendEnvVars, u as logger, v as highlighter, w as EnableRLS, x as getIndexes, y as isColorEnabled } from "./local-env-Du24tdbp.mjs";
 import { createRequire } from "node:module";
 import fs, { existsSync, readFileSync } from "node:fs";
 import path, { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve } from "node:path";
@@ -12,21 +12,6 @@ import { diffWords, structuredPatch } from "diff";
 import { parseEnv } from "node:util";
 import { createServer } from "node:http";
 
-//#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/mutation-utils.ts
 const UTF8_ENCODER = new TextEncoder();
 function getTableName(table) {
@@ -12047,6 +12032,10 @@ function normalizeStringList(values) {
 	if (!Array.isArray(values)) return [];
 	return [...new Set(values.filter((value) => typeof value === "string"))].sort();
 }
+function normalizeOrderedStringList(values) {
+	if (!Array.isArray(values)) return [];
+	return [...new Set(values.filter((value) => typeof value === "string"))];
+}
 function readOptionalCliFlagValue(args, flag) {
 	for (let i = 0; i < args.length; i += 1) {
 		const arg = args[i];
@@ -12062,24 +12051,6 @@ function readOptionalCliFlagValue(args, flag) {
 		}
 	}
 }
-function resolveSchemaDefaultExport(schemaModule) {
-	const schemaValue = schemaModule.default !== void 0 ? schemaModule.default : schemaModule;
-	if (!schemaValue || typeof schemaValue !== "object") return null;
-	return schemaValue;
-}
-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];
-}
 function buildAggregateFingerprintPayload(tables) {
 	return tables.map((table) => getTableConfig(table)).map((tableConfig) => ({
 		tableName: tableConfig.name,
@@ -12091,18 +12062,60 @@ function buildAggregateFingerprintPayload(tables) {
 			avgFields: normalizeStringList(index.avgFields),
 			minFields: normalizeStringList(index.minFields),
 			maxFields: normalizeStringList(index.maxFields)
+		})).sort((a, b) => a.name.localeCompare(b.name)),
+		rankIndexes: tableConfig.rankIndexes.map((index) => ({
+			name: index.name,
+			partitionFields: normalizeOrderedStringList(index.partitionFields),
+			orderFields: (index.orderFields ?? []).map((field) => `${field.field}:${field.direction}`),
+			sumField: index.sumField ?? ""
 		})).sort((a, b) => a.name.localeCompare(b.name))
 	})).sort((a, b) => a.tableName.localeCompare(b.tableName));
 }
-async function computeAggregateIndexFingerprint(functionsDir) {
+async function loadBackendSchemaValue(functionsDir) {
 	const schemaPath = join(functionsDir, "schema.ts");
 	if (!fs.existsSync(schemaPath)) return null;
 	const schemaModule = await createProjectJiti().import(schemaPath);
 	if (!schemaModule || typeof schemaModule !== "object") return null;
-	const schemaValue = resolveSchemaDefaultExport(schemaModule);
+	return resolveSchemaDefaultExport(schemaModule);
+}
+/**
+* Whether the deployed ORM can serve the aggregate procedures at all.
+*
+* `kitcn codegen` registers `aggregateCapability()` only for schemas that
+* declare an `aggregateIndex`/`rankIndex`, so calling `aggregateBackfill`
+* against a schema without one is a guaranteed error rather than a no-op.
+*
+* No schema file means no ORM and no aggregate procedures to call. A schema
+* that exists but fails to load is treated as using them, so a real backfill
+* is never skipped over a transient load error.
+*/
+async function backendUsesAggregateIndexes() {
+	try {
+		const { functionsDir } = getConvexConfig();
+		const schemaValue = await loadBackendSchemaValue(functionsDir);
+		if (!schemaValue) return false;
+		return schemaDeclaresAggregateIndexes(schemaValue);
+	} catch {
+		return true;
+	}
+}
+/**
+* Whether the deployed ORM registered `migrationCapability()`. Codegen keys
+* that off the generated manifest, so the flows key off the same file.
+*/
+function backendUsesMigrations() {
+	try {
+		const { functionsDir } = getConvexConfig();
+		return fs.existsSync(join(functionsDir, "migrations", "manifest.ts"));
+	} catch {
+		return true;
+	}
+}
+async function computeAggregateIndexFingerprint(functionsDir) {
+	const schemaValue = await loadBackendSchemaValue(functionsDir);
 	if (!schemaValue) return null;
 	const tables = collectSchemaTables(schemaValue);
-	if (tables.length === 0) return null;
+	if (tables.length === 0 || !schemaDeclaresAggregateIndexes(schemaValue)) return null;
 	const payload = buildAggregateFingerprintPayload(tables);
 	return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
 }
@@ -13000,7 +13013,8 @@ async function runAggregateBackfillFlow(params) {
 	const { execaFn, backendAdapter, backfillConfig, mode, targetArgs, env, signal, context } = params;
 	if (signal?.aborted) return 0;
 	if (backfillConfig.enabled === "off") return 0;
-	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfill", {
+	if (!await backendUsesAggregateIndexes()) return 0;
+	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfill", {
 		mode,
 		batchSize: backfillConfig.batchSize
 	}, targetArgs, {
@@ -13033,7 +13047,7 @@ async function runAggregateBackfillFlow(params) {
 	const deadline = Date.now() + backfillConfig.timeoutMs;
 	let lastProgress = "";
 	while (!signal?.aborted) {
-		const statusResult = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfillStatus", {}, targetArgs, {
+		const statusResult = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfillStatus", {}, targetArgs, {
 			echoOutput: false,
 			env
 		});
@@ -13067,7 +13081,7 @@ async function runAggregateBackfillFlow(params) {
 }
 async function runAggregatePruneFlow(params) {
 	const { execaFn, backendAdapter, targetArgs, env } = params;
-	const result = await runBackendFunction(execaFn, backendAdapter, "generated/server:aggregateBackfill", { mode: "prune" }, targetArgs, {
+	const result = await runBackendFunction(execaFn, backendAdapter, "generated/aggregate:aggregateBackfill", { mode: "prune" }, targetArgs, {
 		echoOutput: false,
 		env
 	});
@@ -13178,6 +13192,7 @@ export const migration = defineMigration({
 async function runMigrationFlow(params) {
 	const { execaFn, backendAdapter, migrationConfig, targetArgs, env, signal, context, direction, steps, to } = params;
 	if (signal?.aborted || migrationConfig.enabled === "off") return 0;
+	if (!backendUsesMigrations()) return 0;
 	const kickoff = await runBackendFunction(execaFn, backendAdapter, "generated/server:migrationRun", {
 		direction,
 		batchSize: migrationConfig.batchSize,
@@ -15394,6 +15409,10 @@ const handleMigrateCommand = async (argv, deps = {}) => {
 			to
 		});
 	}
+	if (!backendUsesMigrations()) {
+		logger.info("No migrations manifest. Run `kitcn migrate create <name>` to add one.");
+		return 0;
+	}
 	if (migrateArgs.subcommand === "status") return (await runBackendFunction(execaFn, backendAdapter, "generated/server:migrationStatus", {}, targetArgs, { env: commandEnv })).exitCode;
 	let runId;
 	const cancelArgs = [];

package/dist/{convex-plugin-D8B0oCFq.js → convex-plugin-DfOhBU9g.js}

@@ -1,4 +1,4 @@
-import { r as omit } from "./upstream-BR6sBLg3.js";
+import { r as omit } from "./upstream-BCgGZX6q.js";
 import { createAuthEndpoint, createAuthMiddleware, sessionMiddleware } from "better-auth/api";
 import { bearer } from "better-auth/plugins/bearer";
 import { jwt } from "better-auth/plugins/jwt";

package/dist/{create-schema-orm-B3f2Kc8O.js → create-schema-orm-Bu2JCiBS.js}

@@ -1,4 +1,4 @@
-import { augmentBetterAuthTables, indexFields } from "./create-schema-BXrKE2YY.js";
+import { augmentBetterAuthTables, indexFields } from "./create-schema-BRFjdgRr.js";
 
 //#region src/auth/create-schema-orm.ts
 const specialFields = (tables) => Object.fromEntries(Object.entries(tables).map(([key, table]) => {

package/dist/crpc/index.d.ts

@@ -1,5 +1,5 @@
-import { B as dateWireCodec, F as DATE_CODEC_TAG, G as identityTransformer, H as defaultCRPCTransformer, I as DataTransformer, L as DataTransformerOptions, P as CombinedDataTransformer, R as WireCodec, U as encodeWire, V as decodeWire, W as getTransformer, a as HttpErrorCode, c as HttpQueryKey, d as HttpRouteMap, f as InferHttpInput, g as isHttpClientError, h as buildHttpQueryPrefixKey, i as HttpClientFromRouter, l as HttpQueryPrefixKey, m as buildHttpQueryKey, n as HttpClient, o as HttpMutationKey, p as InferHttpOutput, r as HttpClientError, s as HttpProcedureCall, t as HTTP_DEFAULT_STALE_TIME, u as HttpRouteInfo, z as createTaggedTransformer } from "../http-types-DXOgaerG.js";
-import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-BHR7ZKKD.js";
+import { B as dateWireCodec, F as DATE_CODEC_TAG, G as identityTransformer, H as defaultCRPCTransformer, I as DataTransformer, L as DataTransformerOptions, P as CombinedDataTransformer, R as WireCodec, U as encodeWire, V as decodeWire, W as getTransformer, a as HttpErrorCode, c as HttpQueryKey, d as HttpRouteMap, f as InferHttpInput, g as isHttpClientError, h as buildHttpQueryPrefixKey, i as HttpClientFromRouter, l as HttpQueryPrefixKey, m as buildHttpQueryKey, n as HttpClient, o as HttpMutationKey, p as InferHttpOutput, r as HttpClientError, s as HttpProcedureCall, t as HTTP_DEFAULT_STALE_TIME, u as HttpRouteInfo, z as createTaggedTransformer } from "../http-types-90mapMP9.js";
+import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-In-ZZOsd.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
 //#region src/crpc/auth-error.d.ts

package/dist/crpc/index.js

@@ -1,6 +1,6 @@
-import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-Bvo7YEhk.js";
-import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-yZuBWo8v.js";
-import { a as buildSearchParams, c as HTTP_DEFAULT_STALE_TIME, d as buildHttpQueryPrefixKey, f as isHttpClientError, i as RESERVED_KEYS, l as HttpClientError, n as convexInfiniteQueryOptions, o as executeHttpRequest, r as convexQuery, s as replaceUrlParam, t as convexAction, u as buildHttpQueryKey } from "../query-options-CzRV4G4N.js";
+import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-CMLeCadS.js";
+import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-D8wO-kEj.js";
+import { a as buildSearchParams, c as HTTP_DEFAULT_STALE_TIME, d as buildHttpQueryPrefixKey, f as isHttpClientError, i as RESERVED_KEYS, l as HttpClientError, n as convexInfiniteQueryOptions, o as executeHttpRequest, r as convexQuery, s as replaceUrlParam, t as convexAction, u as buildHttpQueryKey } from "../query-options-DUiOj01a.js";
 
 //#region src/crpc/auth-error.ts
 /**

package/dist/{customFunctions-DxEEO4Dq.js → customFunctions-BbhgdRGl.js}

@@ -1,5 +1,5 @@
-import { i as pick, r as omit } from "./upstream-BR6sBLg3.js";
-import { t as addFieldsToValidator } from "./validators-C7LelqTN.js";
+import { i as pick, r as omit } from "./upstream-BCgGZX6q.js";
+import { t as addFieldsToValidator } from "./validators-Dmbhsd3U.js";
 
 //#region src/internal/upstream/server/customFunctions.ts
 /**

package/dist/definitions-D9vhJ6OV.js

@@ -0,0 +1,215 @@
+import { A as integer, C as index, I as ConvexColumnBuilder, L as entityKind, M as custom, O as text, t as convexTable } from "./table-rmJm5Qio.js";
+import { t as defineSchemaExtension } from "./extensions-DzjCJXYl.js";
+import { v } from "convex/values";
+
+//#region src/orm/builders/boolean.ts
+/**
+* Boolean column builder class
+* Compiles to v.boolean() or v.optional(v.boolean())
+*/
+var ConvexBooleanBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexBooleanBuilder";
+	constructor(name) {
+		super(name, "boolean", "ConvexBoolean");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.boolean();
+		return v.optional(v.union(v.null(), v.boolean()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.boolean()
+	* nullable → v.optional(v.boolean())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function boolean(name) {
+	return new ConvexBooleanBuilder(name ?? "");
+}
+
+//#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().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().notNull(),
+	allowDrift: boolean().notNull(),
+	migrationIds: custom(v.array(v.string())).notNull(),
+	currentIndex: integer().notNull(),
+	startedAt: integer().notNull(),
+	updatedAt: integer().notNull(),
+	completedAt: integer(),
+	cancelRequested: boolean().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
+};
+const MIGRATION_STORAGE_TABLE_NAMES = new Set([MIGRATION_STATE_TABLE, MIGRATION_RUN_TABLE]);
+function migrationExtension() {
+	return defineSchemaExtension("migration", migrationStorageTables);
+}
+function injectMigrationStorageTables(schema) {
+	const merged = { ...schema };
+	for (const [tableName, tableDef] of Object.entries(migrationStorageTables)) {
+		if (tableName in schema && schema[tableName] !== tableDef) throw new Error(`defineSchema cannot inject internal table '${tableName}' because the name is already in use.`);
+		merged[tableName] = tableDef;
+	}
+	return merged;
+}
+
+//#endregion
+//#region src/orm/migrations/definitions.ts
+const MIGRATION_ID_RE = /^[a-zA-Z0-9_:-]+$/;
+const FUNCTION_SOURCE_WHITESPACE_RE = /\s+/g;
+const FUNCTION_SOURCE_PUNCTUATION_SPACE_RE = /\s*([{}();,:])\s*/g;
+function defineMigration(migration) {
+	validateMigrationId(migration.id);
+	validateMigrationStep("up", migration.up);
+	if (migration.down) validateMigrationStep("down", migration.down);
+	return migration;
+}
+function defineMigrationSet(migrations) {
+	const normalized = [...migrations].map((migration) => {
+		const defined = defineMigration(migration);
+		return {
+			...defined,
+			checksum: defined.checksum ?? computeMigrationChecksum(defined)
+		};
+	});
+	normalized.sort((a, b) => a.id.localeCompare(b.id));
+	const byId = {};
+	for (const migration of normalized) {
+		if (byId[migration.id]) throw new Error(`defineMigrationSet received duplicate migration id '${migration.id}'.`);
+		byId[migration.id] = migration;
+	}
+	return {
+		migrations: normalized,
+		ids: normalized.map((migration) => migration.id),
+		byId
+	};
+}
+function detectMigrationDrift(params) {
+	const { migrationSet, appliedState } = params;
+	const issues = [];
+	for (const [migrationId, state] of Object.entries(appliedState)) {
+		if (!state.applied) continue;
+		const migration = migrationSet.byId[migrationId];
+		if (!migration) {
+			issues.push({
+				kind: "missing_from_manifest",
+				migrationId,
+				message: `Applied migration '${migrationId}' is missing from the current migration manifest.`
+			});
+			continue;
+		}
+		if (state.checksum && state.checksum !== migration.checksum) issues.push({
+			kind: "checksum_mismatch",
+			migrationId,
+			expectedChecksum: migration.checksum,
+			actualChecksum: state.checksum,
+			message: `Applied migration '${migrationId}' checksum drift detected.`
+		});
+	}
+	return issues;
+}
+function buildMigrationPlan(params) {
+	const { direction, migrationSet, appliedState, steps, to } = params;
+	if (direction === "up") return {
+		direction,
+		migrations: migrationSet.migrations.filter((migration) => !appliedState[migration.id]?.applied)
+	};
+	if (steps !== void 0 && to !== void 0) throw new Error("Use either down steps or down to, not both.");
+	const appliedInOrder = migrationSet.migrations.filter((migration) => appliedState[migration.id]?.applied);
+	const ensureDownSteps = (selected) => {
+		const missingDown = selected.find((migration) => !migration.down);
+		if (missingDown) throw new Error(`Cannot execute down migration for '${missingDown.id}': missing down migration handler.`);
+		return selected;
+	};
+	if (to) {
+		const targetIndex = migrationSet.ids.indexOf(to);
+		if (targetIndex === -1) throw new Error(`Unknown migration id '${to}' for down --to.`);
+		return {
+			direction,
+			migrations: ensureDownSteps(appliedInOrder.filter((migration) => {
+				return migrationSet.ids.indexOf(migration.id) > targetIndex;
+			})).reverse()
+		};
+	}
+	const resolvedSteps = steps ?? 1;
+	if (!Number.isInteger(resolvedSteps) || resolvedSteps < 1) throw new Error("Down steps must be a positive integer.");
+	return {
+		direction,
+		migrations: ensureDownSteps(appliedInOrder.slice(-resolvedSteps).reverse())
+	};
+}
+function validateMigrationId(id) {
+	if (!id || typeof id !== "string") throw new Error("Migration id must be a non-empty string.");
+	if (!MIGRATION_ID_RE.test(id)) throw new Error(`Migration id '${id}' is invalid. Use alphanumeric characters, '_' ':' or '-'.`);
+}
+function validateMigrationStep(direction, step) {
+	if (!step || typeof step !== "object") throw new Error(`Migration ${direction} step must be an object.`);
+	if (!step.table || typeof step.table !== "string") throw new Error(`Migration ${direction} step.table must be a string.`);
+	if (typeof step.migrateOne !== "function") throw new Error(`Migration ${direction} step.migrateOne must be a function.`);
+	if (step.batchSize !== void 0 && (!Number.isInteger(step.batchSize) || step.batchSize < 1)) throw new Error(`Migration ${direction} step.batchSize must be a positive integer.`);
+	if (step.writeMode !== void 0 && step.writeMode !== "safe_bypass" && step.writeMode !== "normal") throw new Error(`Migration ${direction} step.writeMode must be 'safe_bypass' or 'normal'.`);
+}
+function computeMigrationChecksum(migration) {
+	return simpleStableHash(JSON.stringify({
+		id: migration.id,
+		name: migration.name ?? null,
+		description: migration.description ?? null,
+		up: serializeStep(migration.up),
+		down: migration.down ? serializeStep(migration.down) : null
+	}));
+}
+function serializeStep(step) {
+	return {
+		table: step.table,
+		batchSize: step.batchSize ?? null,
+		writeMode: step.writeMode ?? "safe_bypass",
+		source: normalizeFunctionSource(step.migrateOne)
+	};
+}
+function normalizeFunctionSource(fn) {
+	return fn.toString().replace(FUNCTION_SOURCE_WHITESPACE_RE, " ").replace(FUNCTION_SOURCE_PUNCTUATION_SPACE_RE, "$1").trim();
+}
+function simpleStableHash(value) {
+	let hashA = 2166136261;
+	let hashB = 16777619;
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		hashA ^= code;
+		hashA = Math.imul(hashA, 16777619);
+		hashB ^= code + i;
+		hashB = Math.imul(hashB, 2246822507);
+	}
+	return `m_${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+//#endregion
+export { MIGRATION_RUN_TABLE as a, injectMigrationStorageTables as c, boolean as d, detectMigrationDrift as i, migrationExtension as l, defineMigration as n, MIGRATION_STATE_TABLE as o, defineMigrationSet as r, MIGRATION_STORAGE_TABLE_NAMES as s, buildMigrationPlan as t, migrationStorageTables as u };

package/dist/extensions-DzjCJXYl.js

@@ -0,0 +1,55 @@
+import { d as OrmSchemaExtensionTriggers, l as OrmSchemaExtensionRelations } from "./table-rmJm5Qio.js";
+
+//#region src/orm/extensions.ts
+function defineChainMethod(target, key, value) {
+	Object.defineProperty(target, key, {
+		value,
+		enumerable: false,
+		configurable: true
+	});
+}
+function createSchemaExtensionChain(state, capabilities) {
+	const extension = {
+		key: state.key,
+		tables: state.tables
+	};
+	Object.defineProperty(extension, OrmSchemaExtensionRelations, {
+		value: state.relations,
+		enumerable: false,
+		configurable: true
+	});
+	Object.defineProperty(extension, OrmSchemaExtensionTriggers, {
+		value: state.triggers,
+		enumerable: false,
+		configurable: true
+	});
+	if (capabilities.canRelations) defineChainMethod(extension, "relations", (relations) => createSchemaExtensionChain({
+		...state,
+		relations
+	}, {
+		canRelations: false,
+		canTriggers: true
+	}));
+	if (capabilities.canTriggers) defineChainMethod(extension, "triggers", (triggers) => createSchemaExtensionChain({
+		...state,
+		triggers
+	}, {
+		canRelations: false,
+		canTriggers: false
+	}));
+	return extension;
+}
+function defineSchemaExtension(key, tables) {
+	return createSchemaExtensionChain({
+		key,
+		tables,
+		relations: void 0,
+		triggers: void 0
+	}, {
+		canRelations: true,
+		canTriggers: true
+	});
+}
+
+//#endregion
+export { defineSchemaExtension as t };