arkormx 2.11.13 → 2.12.0

package/dist/{relationship-CBYK5LE3.cjs → relationship-BoQDV6gx.cjs}

@@ -26,17 +26,17 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let _h3ravel_collect_js = require("@h3ravel/collect.js");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_crypto = require("node:crypto");
 let async_hooks = require("async_hooks");
 let jiti = require("jiti");
 let node_url = require("node:url");
-let node_path = require("node:path");
 let module$1 = require("module");
 let fs = require("fs");
 let url = require("url");
 let path = require("path");
 path = __toESM(path, 1);
-let node_fs = require("node:fs");
-let node_crypto = require("node:crypto");
 let _h3ravel_support = require("@h3ravel/support");
 let node_async_hooks = require("node:async_hooks");
 let node_child_process = require("node:child_process");
@@ -92,1309 +92,981 @@ var RelationResolutionException = class extends ArkormException {
 };
 
 //#endregion
-//#region src/relationship/RelationTableLoader.ts
-/**
-* Utility class responsible for loading data from relation tables, which are used to
-* manage relationships between models in Arkorm.
-*
-* @author Legacy (3m1n3nc3)
-* @since 2.0.0-next.0
-*/
-var RelationTableLoader = class {
-	constructor(adapter) {
-		this.adapter = adapter;
-	}
-	async selectRows(spec) {
-		return await this.adapter.select({
-			target: { table: spec.table },
-			where: spec.where,
-			columns: spec.columns,
-			orderBy: spec.orderBy,
-			limit: spec.limit,
-			offset: spec.offset
-		});
-	}
-	async selectRow(spec) {
-		return await this.adapter.selectOne({
-			target: { table: spec.table },
-			where: spec.where,
-			columns: spec.columns,
-			orderBy: spec.orderBy,
-			limit: spec.limit ?? 1,
-			offset: spec.offset
-		});
+//#region src/helpers/migration-history.ts
+const createEmptyAppliedMigrationsState = () => ({
+	version: 1,
+	migrations: [],
+	runs: []
+});
+const supportsDatabaseMigrationState = (adapter) => {
+	return typeof adapter?.readAppliedMigrationsState === "function" && typeof adapter?.writeAppliedMigrationsState === "function";
+};
+const resolveMigrationStateFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return (0, node_path.resolve)(configuredPath);
+	return (0, node_path.join)(cwd, ".arkormx", "migrations.applied.json");
+};
+const buildMigrationIdentity = (filePath, className) => {
+	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
+	return `${fileName.slice(0, fileName.length - (0, node_path.extname)(fileName).length)}:${className}`;
+};
+const computeMigrationChecksum = (filePath) => {
+	if (!(0, node_fs.existsSync)(filePath)) return (0, node_crypto.createHash)("sha256").update(filePath).digest("hex");
+	const source = (0, node_fs.readFileSync)(filePath, "utf-8");
+	return (0, node_crypto.createHash)("sha256").update(source).digest("hex");
+};
+const readAppliedMigrationsState = (stateFilePath) => {
+	if (!(0, node_fs.existsSync)(stateFilePath)) return createEmptyAppliedMigrationsState();
+	try {
+		const parsed = JSON.parse((0, node_fs.readFileSync)(stateFilePath, "utf-8"));
+		if (!Array.isArray(parsed.migrations)) return createEmptyAppliedMigrationsState();
+		return {
+			version: 1,
+			migrations: parsed.migrations.filter((migration) => {
+				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
+			}),
+			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
+				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
+			}) : []
+		};
+	} catch {
+		return createEmptyAppliedMigrationsState();
 	}
-	async selectColumnValues(spec) {
-		return (await this.selectRows({
-			...spec.lookup,
-			columns: [{ column: spec.column }]
-		})).map((row) => row[spec.column]);
+};
+const readAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) return await adapter.readAppliedMigrationsState();
+	return readAppliedMigrationsState(stateFilePath);
+};
+const writeAppliedMigrationsState = (stateFilePath, state) => {
+	const directory = (0, node_path.dirname)(stateFilePath);
+	if (!(0, node_fs.existsSync)(directory)) (0, node_fs.mkdirSync)(directory, { recursive: true });
+	(0, node_fs.writeFileSync)(stateFilePath, JSON.stringify(state, null, 2));
+};
+const writeAppliedMigrationsStateToStore = async (adapter, stateFilePath, state) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(state);
+		return;
 	}
-	async selectColumnValue(spec) {
-		return (await this.selectRow({
-			...spec.lookup,
-			columns: [{ column: spec.column }],
-			limit: 1
-		}))?.[spec.column] ?? null;
+	writeAppliedMigrationsState(stateFilePath, state);
+};
+const deleteAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
+		return "database";
 	}
+	if (!(0, node_fs.existsSync)(stateFilePath)) return "missing-file";
+	writeAppliedMigrationsState(stateFilePath, createEmptyAppliedMigrationsState());
+	return "file";
+};
+const isMigrationApplied = (state, identity, checksum) => {
+	const matched = state.migrations.find((migration) => migration.id === identity);
+	if (!matched) return false;
+	if (checksum && matched.checksum) return matched.checksum === checksum;
+	if (checksum && !matched.checksum) return false;
+	return true;
+};
+const findAppliedMigration = (state, identity) => {
+	return state.migrations.find((migration) => migration.id === identity);
+};
+const markMigrationApplied = (state, entry) => {
+	const next = state.migrations.filter((migration) => migration.id !== entry.id);
+	next.push(entry);
+	return {
+		version: 1,
+		migrations: next,
+		runs: state.runs ?? []
+	};
+};
+const removeAppliedMigration = (state, identity) => {
+	return {
+		version: 1,
+		migrations: state.migrations.filter((migration) => migration.id !== identity),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			migrationIds: run.migrationIds.filter((id) => id !== identity)
+		})).filter((run) => run.migrationIds.length > 0)
+	};
+};
+const buildMigrationRunId = () => {
+	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+};
+const markMigrationRun = (state, run) => {
+	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
+	nextRuns.push(run);
+	return {
+		version: 1,
+		migrations: state.migrations,
+		runs: nextRuns
+	};
+};
+const getLastMigrationRun = (state) => {
+	const runs = state.runs ?? [];
+	if (runs.length === 0) return void 0;
+	return runs.map((run, index) => ({
+		run,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	})[0]?.run;
+};
+const getLatestAppliedMigrations = (state, steps) => {
+	return state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
+};
+/**
+* Groups the applied migrations into batches, oldest batch first, each batch
+* holding its migration ids in application order.
+*
+* A "batch" is one `migrate` run. When no runs were recorded (e.g. legacy state
+* written before run tracking), each applied migration is treated as its own
+* batch so `--step` still behaves predictably.
+*
+* @param state
+* @returns
+*/
+const resolveAppliedBatches = (state) => {
+	const runs = state.runs ?? [];
+	if (runs.length > 0) return runs.map((run, index) => ({
+		run,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = left.run.appliedAt.localeCompare(right.run.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return left.index - right.index;
+	}).map((entry) => entry.run.migrationIds);
+	return state.migrations.map((migration) => [migration.id]);
+};
+/**
+* Resolves the migrations belonging to the most recent `batches` batches, ordered
+* for rollback — **reverse of the order they were applied** (most recent batch
+* first, and within each batch the migration that ran `up()` last runs `down()`
+* first), so a rollback exactly reverses how the migrations were applied.
+*
+* Defaults to a single batch (`migrate:rollback` with no `--step`); `--step=N`
+* rolls back the last N batches.
+*
+* @param state
+* @param batches
+* @returns
+*/
+const getLastBatchMigrations = (state, batches = 1) => {
+	if (batches < 1) return [];
+	const allBatches = resolveAppliedBatches(state);
+	const selected = allBatches.slice(Math.max(0, allBatches.length - batches));
+	const byId = new Map(state.migrations.map((migration) => [migration.id, migration]));
+	return selected.reverse().flatMap((migrationIds) => [...migrationIds].reverse()).map((id) => byId.get(id)).filter((migration) => Boolean(migration));
 };
 
 //#endregion
-//#region src/relationship/SetBasedEagerLoader.ts
+//#region src/database/ForeignKeyBuilder.ts
 /**
-* Utility class responsible for performing set-based eager loading of relationships for
-* a collection of models.
+* The ForeignKeyBuilder class provides a fluent interface for defining
+* foreign key constraints in a migration. It allows you to specify
+* the referenced table and column, as well as actions to take on
+* delete and aliases for the relation.
 *
 * @author Legacy (3m1n3nc3)
-* @since 2.0.0-next.2
+* @since 0.2.2
 */
-var SetBasedEagerLoader = class SetBasedEagerLoader {
-	constructor(models, relations) {
-		this.models = models;
-		this.relations = relations;
+var ForeignKeyBuilder = class {
+	constructor(foreignKey) {
+		this.foreignKey = foreignKey;
 	}
 	/**
-	* Performs eager loading of all specified relationships for the set of models.
+	* Defines the referenced table and column for this foreign key constraint.
 	*
+	* @param table
+	* @param column
 	* @returns
 	*/
-	async load() {
-		if (this.models.length === 0) return;
-		const relationTree = this.buildRelationTree(this.relations);
-		await Promise.all(Array.from(relationTree.entries()).map(async ([name, node]) => {
-			await this.loadRelationNode(name, node);
-		}));
-	}
-	async loadRelationNode(name, node) {
-		await this.loadRelation(name, node.constraint);
-		if (node.children.size === 0) return;
-		const relatedModels = this.collectLoadedRelationModels(name);
-		if (relatedModels.length === 0) return;
-		await new SetBasedEagerLoader(relatedModels, this.relationTreeToMap(node.children)).load();
+	references(table, column) {
+		this.foreignKey.referencesTable = table;
+		this.foreignKey.referencesColumn = column;
+		return this;
 	}
 	/**
-	* Loads a specific relationship for the set of models based on the relationship name
-	* and an optional constraint.
+	* Defines the action to take when a referenced record is deleted, such
+	* as "CASCADE", "SET NULL", or "RESTRICT".
 	*
-	* @param name          The name of the relationship to load.
-	* @param constraint    An optional constraint to apply to the query.
-	* @returns             A promise that resolves when the relationship is loaded.
+	* @param action
+	* @returns
 	*/
-	async loadRelation(name, constraint) {
-		const resolver = this.resolveRelationResolver(name);
-		if (!resolver) return;
-		const metadata = resolver.call(this.models[0]).getMetadata();
-		switch (metadata.type) {
-			case "belongsTo":
-				await this.loadBelongsTo(name, resolver, metadata, constraint);
-				return;
-			case "belongsToMany":
-				await this.loadBelongsToMany(name, metadata, constraint);
-				return;
-			case "hasMany":
-				await this.loadHasMany(name, metadata, constraint);
-				return;
-			case "hasOne":
-				await this.loadHasOne(name, resolver, metadata, constraint);
-				return;
-			case "hasManyThrough":
-				await this.loadHasManyThrough(name, metadata, constraint);
-				return;
-			case "hasOneThrough":
-				await this.loadHasOneThrough(name, resolver, metadata, constraint);
-				return;
-			case "morphTo":
-				await this.loadMorphTo(name, metadata, constraint);
-				return;
-			case "morphOne":
-				await this.loadMorphOne(name, resolver, metadata, constraint);
-				return;
-			case "morphMany":
-				await this.loadMorphMany(name, metadata, constraint);
-				return;
-			case "morphToMany":
-			case "morphedByMany":
-				await this.loadPolymorphicManyToMany(name, metadata, constraint);
-				return;
-			default: await this.loadIndividually(name, resolver, constraint);
-		}
+	onDelete(action) {
+		this.foreignKey.onDelete = action;
+		return this;
 	}
 	/**
-	* Resolves the relation resolver function for a given relationship name by inspecting
-	* the first model in the set.
+	* Defines an alias for the relation represented by this foreign key, which
+	* can be used in the ORM for more intuitive access to related models.
 	*
-	* @param name  The name of the relationship to resolve.
-	* @returns     The relation resolver function or null if not found.
+	* @param name
+	* @returns
 	*/
-	resolveRelationResolver(name) {
-		const resolver = this.models[0][name];
-		if (typeof resolver !== "function") {
-			const modelName = this.models[0].constructor?.name ?? "Model";
-			throw new RelationResolutionException(`Relation [${name}] is not defined on the model.`, {
-				operation: "eagerLoad",
-				model: modelName,
-				relation: name
-			});
-		}
-		return resolver;
-	}
-	buildRelationTree(relations) {
-		const tree = /* @__PURE__ */ new Map();
-		Object.entries(relations).forEach(([path, constraint]) => {
-			const segments = path.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
-			if (segments.length === 0) return;
-			let current = tree;
-			segments.forEach((segment, index) => {
-				const existing = current.get(segment) ?? {
-					constraint: void 0,
-					children: /* @__PURE__ */ new Map()
-				};
-				if (index === segments.length - 1 && constraint) existing.constraint = constraint;
-				current.set(segment, existing);
-				current = existing.children;
-			});
-		});
-		return tree;
-	}
-	relationTreeToMap(tree, prefix = "") {
-		return Array.from(tree.entries()).reduce((all, [name, node]) => {
-			const path = prefix ? `${prefix}.${name}` : name;
-			all[path] = node.constraint;
-			Object.assign(all, this.relationTreeToMap(node.children, path));
-			return all;
-		}, {});
-	}
-	collectLoadedRelationModels(name) {
-		return this.models.reduce((all, model) => {
-			const loaded = model.getAttribute(name);
-			if (loaded instanceof ArkormCollection) {
-				loaded.all().forEach((item) => {
-					if (this.isEagerLoadableModel(item)) all.push(item);
-				});
-				return all;
-			}
-			if (this.isEagerLoadableModel(loaded)) all.push(loaded);
-			return all;
-		}, []);
-	}
-	isEagerLoadableModel(value) {
-		return typeof value === "object" && value !== null && typeof value.getAttribute === "function" && typeof value.setLoadedRelation === "function";
+	alias(name) {
+		this.foreignKey.relationAlias = name;
+		return this;
 	}
 	/**
-	* Loads a "belongs to" relationship for the set of models.
+	* Defines an alias for the inverse relation represented by this foreign key.
 	*
-	* @param name          The name of the relationship to load.
-	* @param resolver      The relation resolver function.
-	* @param metadata      The metadata for the relationship.
-	* @param constraint    An optional constraint to apply to the query.
-	* @returns             A promise that resolves when the relationship is loaded.
+	* @param name
+	* @returns
 	*/
-	async loadBelongsTo(name, resolver, metadata, constraint) {
-		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.foreignKey));
-		if (keys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.ownerKey, keys);
-		query = this.applyConstraint(query, constraint);
-		const relatedModels = await this.getPartitionedModels(query, metadata.ownerKey, keys);
-		const relatedByOwnerKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const value = this.readModelAttribute(related, metadata.ownerKey);
-			if (value == null) return;
-			const lookupKey = this.toLookupKey(value);
-			if (!relatedByOwnerKey.has(lookupKey)) relatedByOwnerKey.set(lookupKey, related);
-		});
-		this.models.forEach((model) => {
-			const foreignValue = model.getAttribute(metadata.foreignKey);
-			const relationValue = foreignValue == null ? void 0 : relatedByOwnerKey.get(this.toLookupKey(foreignValue));
-			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
-		});
+	inverseAlias(name) {
+		this.foreignKey.inverseRelationAlias = name;
+		return this;
 	}
 	/**
-	* Loads a "has many" relationship for the set of models.
+	* Defines an alias for the foreign key field itself, which can be
+	* used in the ORM for more intuitive access to the foreign key value.
 	*
-	* @param name
-	* @param metadata
-	* @param constraint
+	* @param fieldName
 	* @returns
 	*/
-	async loadHasMany(name, metadata, constraint) {
-		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
-		if (keys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, new ArkormCollection([]));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
-		query = this.applyConstraint(query, constraint);
-		const relatedModels = await this.getPartitionedModels(query, metadata.foreignKey, keys);
-		const relatedByForeignKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const value = this.readModelAttribute(related, metadata.foreignKey);
-			if (value == null) return;
-			const lookupKey = this.toLookupKey(value);
-			const bucket = relatedByForeignKey.get(lookupKey) ?? [];
-			bucket.push(related);
-			relatedByForeignKey.set(lookupKey, bucket);
-		});
-		this.models.forEach((model) => {
-			const localValue = model.getAttribute(metadata.localKey);
-			const related = localValue == null ? [] : relatedByForeignKey.get(this.toLookupKey(localValue)) ?? [];
-			model.setLoadedRelation(name, new ArkormCollection(related));
-		});
+	as(fieldName) {
+		this.foreignKey.fieldAlias = fieldName;
+		return this;
+	}
+};
+
+//#endregion
+//#region src/helpers/PrimaryKeyGenerationPlanner.ts
+var PrimaryKeyGenerationPlanner = class {
+	static plan(column) {
+		if (!column.primary || column.default !== void 0) return void 0;
+		if (column.type === "uuid" || column.type === "string") return {
+			strategy: "uuid",
+			prismaDefault: "@default(uuid())",
+			databaseDefault: column.type === "uuid" ? "gen_random_uuid()" : "gen_random_uuid()::text",
+			runtimeFactory: "uuid"
+		};
+	}
+	static generate(generation) {
+		if (generation?.runtimeFactory === "uuid") return (0, node_crypto.randomUUID)();
+	}
+};
+
+//#endregion
+//#region src/helpers/runtime-module-loader.ts
+var RuntimeModuleLoader = class {
+	static async load(filePath, useDefault = false) {
+		const resolvedPath = (0, node_path.resolve)(filePath);
+		return await (0, jiti.createJiti)((0, node_url.pathToFileURL)(resolvedPath).href, {
+			interopDefault: false,
+			tsconfigPaths: true,
+			sourceMaps: true
+		}).import(resolvedPath, useDefault ? { default: true } : {});
 	}
 	/**
-	* Loads a "belongs to many" relationship for the set of models.
+	* Load many modules through a single shared jiti context, retrying files
+	* that fail until no further progress is made.
 	*
-	* @param name
-	* @param metadata
-	* @param constraint
+	* A shared module cache resolves circular imports consistently: a file that
+	* fails because one of its dependencies was not yet cached (for example a
+	* trait whose module imports a model which imports the class that uses the
+	* trait) succeeds on a later pass, once a sibling load has populated that
+	* dependency. A fresh per-file context cannot do this, so the same set of
+	* files can load or fail depending purely on which file is the entry point.
+	*
+	* Each returned entry carries either the loaded module or the last error,
+	* so callers can surface genuine failures instead of silently dropping them.
+	*
+	* @param filePaths
+	* @param useDefault
 	* @returns
 	*/
-	async loadBelongsToMany(name, metadata, constraint) {
-		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.parentKey));
-		if (parentKeys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, new ArkormCollection([]));
-			});
-			return;
-		}
-		const pivotRows = await this.createRelationTableLoader().selectRows({
-			table: metadata.throughTable,
-			where: this.buildBelongsToManyPivotWhere(metadata, parentKeys),
-			columns: this.getBelongsToManyPivotColumns(metadata).map((column) => ({ column }))
+	static async loadAll(filePaths, useDefault = false) {
+		const jiti$1 = (0, jiti.createJiti)(`${(0, node_url.pathToFileURL)((0, node_path.resolve)(".")).href}/`, {
+			interopDefault: false,
+			tsconfigPaths: true,
+			sourceMaps: true
 		});
-		const relatedIds = this.collectUniqueRowValues(pivotRows, metadata.relatedPivotKey);
-		if (relatedIds.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, new ArkormCollection([]));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.relatedKey, relatedIds);
-		query = this.applyConstraint(query, constraint);
-		if (query.hasEagerLoadPagination() && parentKeys.length > 1 && await this.loadLimitedBelongsToMany(name, metadata, query, parentKeys, pivotRows)) return;
-		const relatedModels = (await query.get()).all();
-		const relatedByKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const relatedValue = this.readModelAttribute(related, metadata.relatedKey);
-			if (relatedValue == null) return;
-			relatedByKey.set(this.toLookupKey(relatedValue), related);
-		});
-		const relatedKeysByParent = /* @__PURE__ */ new Map();
-		const pivotByParentAndRelated = /* @__PURE__ */ new Map();
-		pivotRows.forEach((row) => {
-			const parentValue = row[metadata.foreignPivotKey];
-			const relatedValue = row[metadata.relatedPivotKey];
-			if (parentValue == null || relatedValue == null) return;
-			const bucket = relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? [];
-			bucket.push(relatedValue);
-			relatedKeysByParent.set(this.toLookupKey(parentValue), bucket);
-			pivotByParentAndRelated.set(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`, row);
-		});
-		this.models.forEach((model) => {
-			const parentValue = model.getAttribute(metadata.parentKey);
-			const related = (parentValue == null ? [] : relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? []).reduce((all, relatedValue) => {
-				const candidate = relatedByKey.get(this.toLookupKey(relatedValue));
-				if (candidate) all.push(this.attachBelongsToManyPivot(metadata, candidate, pivotByParentAndRelated.get(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`)));
-				return all;
-			}, []);
-			model.setLoadedRelation(name, new ArkormCollection(related));
-		});
-	}
-	async loadLimitedBelongsToMany(name, metadata, query, parentKeys, pivotRows) {
-		if (metadata.pivotWhere) {
-			await this.loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows);
-			return true;
-		}
-		const pivotColumns = this.getBelongsToManyPivotColumns(metadata);
-		const pivotAliases = new Map(pivotColumns.map((column, index) => [column, `__arkorm_pivot_${index}`]));
-		const parentAlias = pivotAliases.get(metadata.foreignPivotKey);
-		const throughTable = metadata.throughTable;
-		const relatedTable = metadata.relatedModel.getTable();
-		const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.relatedKey)}`, "=", `${throughTable}.${metadata.relatedPivotKey}`).whereIn(`${throughTable}.${metadata.foreignPivotKey}`, parentKeys).addSelect({ ...Object.fromEntries([...pivotAliases].map(([column, alias]) => [`${throughTable}.${column}`, alias])) }).getRowsForEagerLoad([`${throughTable}.${metadata.foreignPivotKey}`]);
-		if (!rows) {
-			await this.loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows);
-			return true;
-		}
-		const selectedIds = this.collectUniqueRowValues(rows, metadata.relatedKey);
-		const relatedModels = (await query.clone().withoutPagination().whereIn(metadata.relatedKey, selectedIds).get()).all();
-		const relatedByKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const key = this.readModelAttribute(related, metadata.relatedKey);
-			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
-		});
-		const relatedByParent = /* @__PURE__ */ new Map();
-		rows.forEach((row) => {
-			const parentKey = row[parentAlias];
-			const relatedKey = row[metadata.relatedKey];
-			if (parentKey == null || relatedKey == null) return;
-			const related = relatedByKey.get(this.toLookupKey(relatedKey));
-			if (!related) return;
-			const pivot = Object.fromEntries([...pivotAliases].map(([column, alias]) => [column, row[alias]]));
-			const bucket = relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
-			bucket.push(this.attachBelongsToManyPivot(metadata, related, pivot));
-			relatedByParent.set(this.toLookupKey(parentKey), bucket);
-		});
-		this.models.forEach((model) => {
-			const parentKey = model.getAttribute(metadata.parentKey);
-			const related = parentKey == null ? [] : relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
-			model.setLoadedRelation(name, new ArkormCollection(related));
-		});
-		return true;
-	}
-	async loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows) {
-		const rowsByParent = /* @__PURE__ */ new Map();
-		pivotRows.forEach((row) => {
-			const parentKey = row[metadata.foreignPivotKey];
-			if (parentKey == null) return;
-			const bucket = rowsByParent.get(this.toLookupKey(parentKey)) ?? [];
-			bucket.push(row);
-			rowsByParent.set(this.toLookupKey(parentKey), bucket);
-		});
-		await Promise.all(this.models.map(async (model) => {
-			const parentKey = model.getAttribute(metadata.parentKey);
-			const rows = parentKey == null ? [] : rowsByParent.get(this.toLookupKey(parentKey)) ?? [];
-			const relatedIds = this.collectUniqueRowValues(rows, metadata.relatedPivotKey);
-			const related = relatedIds.length ? (await query.clone().whereIn(metadata.relatedKey, relatedIds).get()).all() : [];
-			const pivotByRelated = new Map(rows.map((row) => [this.toLookupKey(row[metadata.relatedPivotKey]), row]));
-			model.setLoadedRelation(name, new ArkormCollection(related.map((entry) => this.attachBelongsToManyPivot(metadata, entry, pivotByRelated.get(this.toLookupKey(this.readModelAttribute(entry, metadata.relatedKey)))))));
-		}));
-	}
-	buildBelongsToManyPivotWhere(metadata, parentKeys) {
-		const baseCondition = {
-			type: "comparison",
-			column: metadata.foreignPivotKey,
-			operator: "in",
-			value: parentKeys
-		};
-		if (!metadata.pivotWhere) return baseCondition;
-		return {
-			type: "group",
-			operator: "and",
-			conditions: [baseCondition, metadata.pivotWhere]
-		};
-	}
-	getBelongsToManyPivotColumns(metadata) {
-		return [
-			metadata.foreignPivotKey,
-			metadata.relatedPivotKey,
-			...metadata.pivotColumns ?? []
-		].filter((column, index, all) => all.indexOf(column) === index);
-	}
-	shouldAttachBelongsToManyPivot(metadata) {
-		return Boolean(metadata.pivotModel) || Boolean(metadata.pivotCreatedAtColumn) || Boolean(metadata.pivotUpdatedAtColumn) || (metadata.pivotColumns?.length ?? 0) > 0 || Boolean(metadata.pivotAccessor);
-	}
-	createBelongsToManyPivotRecord(metadata, row) {
-		const attributes = this.getBelongsToManyPivotColumns(metadata).reduce((all, column) => {
-			all[column] = row[column];
-			return all;
-		}, {});
-		if (!metadata.pivotModel) return attributes;
-		if (typeof metadata.pivotModel.hydrate === "function") return metadata.pivotModel.hydrate(attributes);
-		return new metadata.pivotModel(attributes);
-	}
-	attachBelongsToManyPivot(metadata, related, row) {
-		if (!row || !this.shouldAttachBelongsToManyPivot(metadata)) return related;
-		const rawReader = related;
-		if (typeof rawReader.getRawAttributes !== "function" || typeof rawReader.setAttribute !== "function") return related;
-		const cloned = metadata.relatedModel.hydrate(rawReader.getRawAttributes());
-		cloned.setAttribute(metadata.pivotAccessor ?? "pivot", this.createBelongsToManyPivotRecord(metadata, row));
-		return cloned;
-	}
-	/**
-	* Loads a "belongs to many" relationship for the set of models.
-	*
-	* @param name
-	* @param resolver
-	* @param metadata
-	* @param constraint
-	* @returns
-	*/
-	async loadHasOne(name, resolver, metadata, constraint) {
-		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
-		if (keys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
-		query = this.applyConstraint(query, constraint);
-		const relatedModels = await this.getPartitionedModels(query, metadata.foreignKey, keys);
-		const relatedByForeignKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const value = this.readModelAttribute(related, metadata.foreignKey);
-			if (value == null) return;
-			const lookupKey = this.toLookupKey(value);
-			if (!relatedByForeignKey.has(lookupKey)) relatedByForeignKey.set(lookupKey, related);
-		});
-		this.models.forEach((model) => {
-			const localValue = model.getAttribute(metadata.localKey);
-			const relationValue = localValue == null ? void 0 : relatedByForeignKey.get(this.toLookupKey(localValue));
-			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
-		});
-	}
-	/**
-	* Loads a "has many through" relationship for the set of models.
-	*
-	* @param name
-	* @param metadata
-	* @param constraint
-	* @returns
-	*/
-	async loadHasManyThrough(name, metadata, constraint) {
-		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
-		if (parentKeys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, new ArkormCollection([]));
-			});
-			return;
-		}
-		const throughRows = await this.createRelationTableLoader().selectRows({
-			table: metadata.throughTable,
-			where: {
-				type: "comparison",
-				column: metadata.firstKey,
-				operator: "in",
-				value: parentKeys
+		const results = /* @__PURE__ */ new Map();
+		let pending = filePaths.map((file) => (0, node_path.resolve)(file));
+		while (pending.length > 0) {
+			const failed = [];
+			for (const file of pending) try {
+				const module = await jiti$1.import(file, useDefault ? { default: true } : {});
+				results.set(file, {
+					file,
+					module
+				});
+			} catch (error) {
+				failed.push(file);
+				results.set(file, {
+					file,
+					module: null,
+					error
+				});
 			}
-		});
-		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
-		if (intermediateKeys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, new ArkormCollection([]));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
-		query = this.applyConstraint(query, constraint);
-		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
-			const limited = await this.loadLimitedThrough(metadata, query, parentKeys, throughRows);
-			this.models.forEach((model) => {
-				const parentKey = model.getAttribute(metadata.localKey);
-				const related = parentKey == null ? [] : limited.get(this.toLookupKey(parentKey)) ?? [];
-				model.setLoadedRelation(name, new ArkormCollection(related));
-			});
-			return;
+			if (failed.length === pending.length) break;
+			pending = failed;
 		}
-		const relatedModels = (await query.get()).all();
-		const relatedByIntermediate = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
-			if (relatedValue == null) return;
-			const bucket = relatedByIntermediate.get(this.toLookupKey(relatedValue)) ?? [];
-			bucket.push(related);
-			relatedByIntermediate.set(this.toLookupKey(relatedValue), bucket);
-		});
-		const intermediateByParent = /* @__PURE__ */ new Map();
-		throughRows.forEach((row) => {
-			const parentValue = row[metadata.firstKey];
-			const intermediateValue = row[metadata.secondLocalKey];
-			if (parentValue == null || intermediateValue == null) return;
-			const bucket = intermediateByParent.get(this.toLookupKey(parentValue)) ?? [];
-			bucket.push(intermediateValue);
-			intermediateByParent.set(this.toLookupKey(parentValue), bucket);
-		});
-		this.models.forEach((model) => {
-			const parentValue = model.getAttribute(metadata.localKey);
-			const related = (parentValue == null ? [] : intermediateByParent.get(this.toLookupKey(parentValue)) ?? []).flatMap((intermediateValue) => relatedByIntermediate.get(this.toLookupKey(intermediateValue)) ?? []);
-			model.setLoadedRelation(name, new ArkormCollection(related));
+		return filePaths.map((file) => results.get((0, node_path.resolve)(file)));
+	}
+};
+
+//#endregion
+//#region src/Exceptions/UnsupportedAdapterFeatureException.ts
+var UnsupportedAdapterFeatureException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "UNSUPPORTED_ADAPTER_FEATURE",
+			...context
 		});
+		this.name = "UnsupportedAdapterFeatureException";
 	}
-	/**
-	* Loads a "has one through" relationship for the set of models.
-	*
-	* @param name
-	* @param resolver
-	* @param metadata
-	* @param constraint
-	* @returns
-	*/
-	async loadHasOneThrough(name, resolver, metadata, constraint) {
-		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
-		if (parentKeys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
-			});
-			return;
-		}
-		const throughRows = await this.createRelationTableLoader().selectRows({
-			table: metadata.throughTable,
-			where: {
-				type: "comparison",
-				column: metadata.firstKey,
-				operator: "in",
-				value: parentKeys
-			}
-		});
-		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
-		if (intermediateKeys.length === 0) {
-			this.models.forEach((model) => {
-				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
-			});
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
-		query = this.applyConstraint(query, constraint);
-		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
-			const limited = await this.loadLimitedThrough(metadata, query, parentKeys, throughRows);
-			this.models.forEach((model) => {
-				const parentKey = model.getAttribute(metadata.localKey);
-				const related = parentKey == null ? void 0 : limited.get(this.toLookupKey(parentKey))?.[0];
-				model.setLoadedRelation(name, related ?? this.resolveSingleDefault(resolver, model));
-			});
-			return;
-		}
-		const relatedModels = (await query.get()).all();
-		const relatedByIntermediate = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
-			if (relatedValue == null) return;
-			const lookupKey = this.toLookupKey(relatedValue);
-			if (!relatedByIntermediate.has(lookupKey)) relatedByIntermediate.set(lookupKey, related);
-		});
-		const intermediateByParent = /* @__PURE__ */ new Map();
-		throughRows.forEach((row) => {
-			const parentValue = row[metadata.firstKey];
-			const intermediateValue = row[metadata.secondLocalKey];
-			if (parentValue == null || intermediateValue == null) return;
-			const lookupKey = this.toLookupKey(parentValue);
-			if (!intermediateByParent.has(lookupKey)) intermediateByParent.set(lookupKey, intermediateValue);
-		});
-		this.models.forEach((model) => {
-			const parentValue = model.getAttribute(metadata.localKey);
-			const intermediateValue = parentValue == null ? void 0 : intermediateByParent.get(this.toLookupKey(parentValue));
-			const relationValue = intermediateValue == null ? void 0 : relatedByIntermediate.get(this.toLookupKey(intermediateValue));
-			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
-		});
-	}
-	async loadLimitedThrough(metadata, query, parentKeys, throughRows) {
-		const parentAlias = "__arkorm_parent_key";
-		const throughTable = metadata.throughTable;
-		const relatedTable = metadata.relatedModel.getTable();
-		const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.secondKey)}`, "=", `${throughTable}.${metadata.secondLocalKey}`).whereIn(`${throughTable}.${metadata.firstKey}`, parentKeys).addSelect({ [`${throughTable}.${metadata.firstKey}`]: parentAlias }).getRowsForEagerLoad([`${throughTable}.${metadata.firstKey}`]);
-		if (!rows) return await this.loadLimitedThroughIndividually(metadata, query, throughRows);
-		const relatedKey = metadata.relatedModel.getPrimaryKey();
-		const selectedIds = this.collectUniqueRowValues(rows, relatedKey);
-		const relatedModels = (await query.clone().withoutPagination().whereIn(relatedKey, selectedIds).get()).all();
-		const relatedByKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const key = this.readModelAttribute(related, relatedKey);
-			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
-		});
-		return rows.reduce((all, row) => {
-			const parentKey = row[parentAlias];
-			const key = row[relatedKey];
-			if (parentKey == null || key == null) return all;
-			const related = relatedByKey.get(this.toLookupKey(key));
-			if (!related) return all;
-			const lookup = this.toLookupKey(parentKey);
-			const bucket = all.get(lookup) ?? [];
-			bucket.push(related);
-			all.set(lookup, bucket);
-			return all;
-		}, /* @__PURE__ */ new Map());
-	}
-	async loadLimitedThroughIndividually(metadata, query, throughRows) {
-		const intermediateByParent = /* @__PURE__ */ new Map();
-		throughRows.forEach((row) => {
-			const parentKey = row[metadata.firstKey];
-			const intermediateKey = row[metadata.secondLocalKey];
-			if (parentKey == null || intermediateKey == null) return;
-			const lookup = this.toLookupKey(parentKey);
-			const bucket = intermediateByParent.get(lookup) ?? [];
-			bucket.push(intermediateKey);
-			intermediateByParent.set(lookup, bucket);
-		});
-		const entries = await Promise.all([...intermediateByParent].map(async ([parentKey, intermediateKeys]) => {
-			return [parentKey, (await query.clone().whereIn(metadata.secondKey, intermediateKeys).get()).all()];
-		}));
-		return new Map(entries);
-	}
-	/**
-	* Loads an inverse polymorphic ("morph to") relationship for the set of
-	* models. Parents are grouped by their morph type, so each distinct type
-	* runs a single batched query instead of one query per parent row.
-	*
-	* @param name
-	* @param metadata
-	* @param constraint
-	* @returns
-	*/
-	async loadMorphTo(name, metadata, constraint) {
-		const idsByType = /* @__PURE__ */ new Map();
-		const seenByType = /* @__PURE__ */ new Map();
-		this.models.forEach((model) => {
-			const morphType = this.readModelAttribute(model, metadata.morphTypeColumn);
-			const morphId = this.readModelAttribute(model, metadata.morphIdColumn);
-			if (typeof morphType !== "string" || morphType.length === 0 || morphId == null) return;
-			const ids = idsByType.get(morphType) ?? [];
-			const seen = seenByType.get(morphType) ?? /* @__PURE__ */ new Set();
-			const lookupKey = this.toLookupKey(morphId);
-			if (!seen.has(lookupKey)) {
-				seen.add(lookupKey);
-				ids.push(morphId);
-			}
-			idsByType.set(morphType, ids);
-			seenByType.set(morphType, seen);
-		});
-		const relatedByTypeAndKey = /* @__PURE__ */ new Map();
-		await Promise.all(Array.from(idsByType.entries()).map(async ([morphType, ids]) => {
-			const relatedModel = metadata.resolveModel(morphType);
-			const ownerKey = metadata.ownerKey ?? relatedModel.getPrimaryKey();
-			let query = relatedModel.query().whereIn(ownerKey, ids);
-			query = this.applyConstraint(query, constraint);
-			(await this.getPartitionedModels(query, ownerKey, ids)).forEach((related) => {
-				const value = this.readModelAttribute(related, ownerKey);
-				if (value == null) return;
-				relatedByTypeAndKey.set(`${morphType}:${this.toLookupKey(value)}`, related);
-			});
-		}));
-		this.models.forEach((model) => {
-			const morphType = this.readModelAttribute(model, metadata.morphTypeColumn);
-			const morphId = this.readModelAttribute(model, metadata.morphIdColumn);
-			const relationValue = typeof morphType !== "string" || morphId == null ? null : relatedByTypeAndKey.get(`${morphType}:${this.toLookupKey(morphId)}`) ?? null;
-			model.setLoadedRelation(name, relationValue);
-		});
-	}
-	/**
-	* Loads a polymorphic one-to-one ("morph one") relationship for the set of
-	* models. See {@link loadMorphChildren} for the batching strategy.
-	*
-	* @param name
-	* @param resolver
-	* @param metadata
-	* @param constraint
-	*/
-	async loadMorphOne(name, resolver, metadata, constraint) {
-		const relatedByKey = await this.loadMorphChildren(metadata, constraint);
-		this.models.forEach((model) => {
-			const bucket = relatedByKey.get(this.morphParentKey(model, metadata.localKey));
-			model.setLoadedRelation(name, bucket?.[0] ?? this.resolveSingleDefault(resolver, model));
-		});
-	}
-	/**
-	* Loads a polymorphic one-to-many ("morph many") relationship for the set of
-	* models. See {@link loadMorphChildren} for the batching strategy.
-	*
-	* @param name
-	* @param metadata
-	* @param constraint
-	*/
-	async loadMorphMany(name, metadata, constraint) {
-		const relatedByKey = await this.loadMorphChildren(metadata, constraint);
-		this.models.forEach((model) => {
-			const bucket = relatedByKey.get(this.morphParentKey(model, metadata.localKey)) ?? [];
-			model.setLoadedRelation(name, new ArkormCollection(bucket));
-		});
-	}
-	async loadPolymorphicManyToMany(name, metadata, constraint) {
-		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.parentKey));
-		if (parentKeys.length === 0) {
-			this.models.forEach((model) => model.setLoadedRelation(name, new ArkormCollection([])));
-			return;
-		}
-		const parentPivotKey = metadata.type === "morphToMany" ? metadata.morphIdColumn : metadata.foreignPivotKey;
-		const morphType = metadata.type === "morphToMany" ? this.morphTypeOf(this.models[0]) : metadata.relatedModel.name;
-		const pivotRows = await this.createRelationTableLoader().selectRows({
-			table: metadata.throughTable,
-			where: {
-				type: "group",
-				operator: "and",
-				conditions: [{
-					type: "comparison",
-					column: parentPivotKey,
-					operator: "in",
-					value: parentKeys
-				}, {
-					type: "comparison",
-					column: metadata.morphTypeColumn,
-					operator: "=",
-					value: morphType
-				}]
-			},
-			columns: [parentPivotKey, metadata.relatedPivotKey].map((column) => ({ column }))
-		});
-		const relatedIds = this.collectUniqueRowValues(pivotRows, metadata.relatedPivotKey);
-		if (relatedIds.length === 0) {
-			this.models.forEach((model) => model.setLoadedRelation(name, new ArkormCollection([])));
-			return;
-		}
-		let query = metadata.relatedModel.query().whereIn(metadata.relatedKey, relatedIds);
-		query = this.applyConstraint(query, constraint);
-		let pairs = pivotRows.map((row) => ({
-			parent: row[parentPivotKey],
-			related: row[metadata.relatedPivotKey]
-		}));
-		let relatedModels;
-		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
-			const parentAlias = "__arkorm_parent_key";
-			const throughTable = metadata.throughTable;
-			const relatedTable = metadata.relatedModel.getTable();
-			const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.relatedKey)}`, "=", `${throughTable}.${metadata.relatedPivotKey}`).whereIn(`${throughTable}.${parentPivotKey}`, parentKeys).where({ [`${throughTable}.${metadata.morphTypeColumn}`]: morphType }).addSelect({ [`${throughTable}.${parentPivotKey}`]: parentAlias }).getRowsForEagerLoad([`${throughTable}.${parentPivotKey}`]);
-			if (rows) {
-				pairs = rows.map((row) => ({
-					parent: row[parentAlias],
-					related: row[metadata.relatedKey]
-				}));
-				const selectedIds = this.collectUniqueRowValues(rows, metadata.relatedKey);
-				relatedModels = (await query.clone().withoutPagination().whereIn(metadata.relatedKey, selectedIds).get()).all();
-			} else {
-				await this.loadPolymorphicManyToManyIndividually(name, metadata, query, parentPivotKey, pivotRows);
-				return;
-			}
-		} else relatedModels = (await query.get()).all();
-		const relatedByKey = /* @__PURE__ */ new Map();
-		relatedModels.forEach((related) => {
-			const key = this.readModelAttribute(related, metadata.relatedKey);
-			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
-		});
-		const relatedByParent = /* @__PURE__ */ new Map();
-		pairs.forEach(({ parent, related }) => {
-			if (parent == null || related == null) return;
-			const model = relatedByKey.get(this.toLookupKey(related));
-			if (!model) return;
-			const lookup = this.toLookupKey(parent);
-			const bucket = relatedByParent.get(lookup) ?? [];
-			bucket.push(model);
-			relatedByParent.set(lookup, bucket);
-		});
-		this.models.forEach((model) => {
-			const parentKey = model.getAttribute(metadata.parentKey);
-			const related = parentKey == null ? [] : relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
-			model.setLoadedRelation(name, new ArkormCollection(related));
-		});
-	}
-	async loadPolymorphicManyToManyIndividually(name, metadata, query, parentPivotKey, pivotRows) {
-		await Promise.all(this.models.map(async (model) => {
-			const parentKey = model.getAttribute(metadata.parentKey);
-			const ids = pivotRows.filter((row) => this.toLookupKey(row[parentPivotKey]) === this.toLookupKey(parentKey)).map((row) => row[metadata.relatedPivotKey]);
-			const related = ids.length ? (await query.clone().whereIn(metadata.relatedKey, ids).get()).all() : [];
-			model.setLoadedRelation(name, new ArkormCollection(related));
-		}));
-	}
-	/**
-	* Batch-loads the children for a morphOne/morphMany relationship. Parents are
-	* grouped by their own morph type (constructor name), so each distinct type
-	* runs a single query constrained by `idColumn IN (...) AND typeColumn = type`
-	* instead of one query per parent row. This also supports a heterogeneous
-	* parent set (e.g. the result of a nested load after a morphTo).
-	*
-	* @param metadata
-	* @param constraint
-	* @returns A map of `"{type}:{localKey}" -> related[]`.
-	*/
-	async loadMorphChildren(metadata, constraint) {
-		const keysByType = /* @__PURE__ */ new Map();
-		const seenByType = /* @__PURE__ */ new Map();
-		this.models.forEach((model) => {
-			const morphType = this.morphTypeOf(model);
-			const localValue = model.getAttribute(metadata.localKey);
-			if (morphType.length === 0 || localValue == null) return;
-			const keys = keysByType.get(morphType) ?? [];
-			const seen = seenByType.get(morphType) ?? /* @__PURE__ */ new Set();
-			const lookupKey = this.toLookupKey(localValue);
-			if (!seen.has(lookupKey)) {
-				seen.add(lookupKey);
-				keys.push(localValue);
-			}
-			keysByType.set(morphType, keys);
-			seenByType.set(morphType, seen);
-		});
-		const relatedByKey = /* @__PURE__ */ new Map();
-		await Promise.all(Array.from(keysByType.entries()).map(async ([morphType, keys]) => {
-			let query = metadata.relatedModel.query().whereIn(metadata.morphIdColumn, keys).where({ [metadata.morphTypeColumn]: morphType });
-			query = this.applyConstraint(query, constraint);
-			(await this.getPartitionedModels(query, metadata.morphIdColumn, keys)).forEach((related) => {
-				const value = this.readModelAttribute(related, metadata.morphIdColumn);
-				if (value == null) return;
-				const key = `${morphType}:${this.toLookupKey(value)}`;
-				const bucket = relatedByKey.get(key) ?? [];
-				bucket.push(related);
-				relatedByKey.set(key, bucket);
-			});
-		}));
-		return relatedByKey;
-	}
-	morphParentKey(model, localKey) {
-		return `${this.morphTypeOf(model)}:${this.toLookupKey(model.getAttribute(localKey))}`;
-	}
-	morphTypeOf(model) {
-		return model.constructor?.name ?? "";
-	}
-	/**
-	* Fallback method to load relationships individually for each model when the
-	* relationship type is not supported for set-based loading.
-	*
-	* @param name
-	* @param resolver
-	* @param constraint
-	*/
-	async loadIndividually(name, resolver, constraint) {
-		await Promise.all(this.models.map(async (model) => {
-			const relation = resolver.call(model);
-			if (constraint) relation.constrain(constraint);
-			model.setLoadedRelation(name, await relation.getResults());
-		}));
-	}
-	/**
-	* Applies an eager load constraint to a query if provided.
-	*
-	* @param query
-	* @param constraint
-	* @returns
-	*/
-	applyConstraint(query, constraint) {
-		if (!constraint) return query;
-		return constraint(query) ?? query;
-	}
-	async getPartitionedModels(query, partitionColumn, partitionValues) {
-		if (partitionValues.length <= 1) return (await query.get()).all();
-		const partitioned = await query.getForEagerLoad([partitionColumn]);
-		if (partitioned) return partitioned.all();
-		return (await Promise.all(partitionValues.map(async (value) => {
-			return (await query.clone().where({ [partitionColumn]: value }).get()).all();
-		}))).flat();
-	}
-	/**
-	* Collects unique values from the set of models based on a resolver function, which
-	* is used to extract the value from each model.
-	*
-	* @param resolve   A function that takes a model and returns the value to be collected.
-	* @returns         An array of unique values.
-	*/
-	collectUniqueKeys(resolve) {
-		const seen = /* @__PURE__ */ new Set();
-		const values = [];
-		this.models.forEach((model) => {
-			const value = resolve(model);
-			if (value == null) return;
-			const lookupKey = this.toLookupKey(value);
-			if (seen.has(lookupKey)) return;
-			seen.add(lookupKey);
-			values.push(value);
-		});
-		return values;
-	}
-	/**
-	* Collects unique values from an array of database rows based on a specified key, which
-	* is used to extract the value from each row.
-	*
-	* @param rows  An array of database rows.
-	* @param key   The key to extract values from each row.
-	* @returns     An array of unique values.
-	*/
-	collectUniqueRowValues(rows, key) {
-		const seen = /* @__PURE__ */ new Set();
-		const values = [];
-		rows.forEach((row) => {
-			const value = row[key];
-			if (value == null) return;
-			const lookupKey = this.toLookupKey(value);
-			if (seen.has(lookupKey)) return;
-			seen.add(lookupKey);
-			values.push(value);
-		});
-		return values;
-	}
-	/**
-	* Loads a "belongs to many" relationship for the set of models.
-	*
-	* @returns
-	*/
-	createRelationTableLoader() {
-		return new RelationTableLoader(this.resolveAdapter());
-	}
-	/**
-	* Loads a "belongs to many" relationship for the set of models.
-	*
-	* @returns
-	*/
-	resolveAdapter() {
-		const adapter = this.models[0].constructor.getAdapter?.();
-		if (!adapter) throw new Error("Set-based eager loading requires a configured adapter.");
-		return adapter;
-	}
-	/**
-	* Reads an attribute value from a model using the getAttribute method, which is used
-	* to access model attributes in a way that is compatible with Arkorm's internal model structure.
-	*
-	* @param model The model to read the attribute from.
-	* @param key The name of the attribute to read.
-	* @returns
-	*/
-	readModelAttribute(model, key) {
-		const readable = model;
-		const value = readable.getAttribute?.(key);
-		if (value !== void 0) return value;
-		try {
-			const attribute = Object.entries(readable.constructor?.getColumnMap?.() ?? {}).find(([, column]) => column === key)?.[0];
-			return attribute ? readable.getAttribute?.(attribute) : value;
-		} catch {
-			return value;
-		}
-	}
-	/**
-	* Resolves the default result for a relationship when no related models are found.
-	*
-	* @param resolver
-	* @param model
-	* @returns
-	*/
-	resolveSingleDefault(resolver, model) {
-		return resolver.call(model).resolveDefaultResult?.() ?? null;
-	}
-	/**
-	* Generates a unique lookup key for a given value, which is used to store and retrieve
-	* values in maps during the eager loading process.
-	*
-	* @param value     The value to generate a lookup key for.
-	* @returns         A unique string representing the value.
-	*/
-	toLookupKey(value) {
-		if (value instanceof Date) return `date:${value.toISOString()}`;
-		return `${typeof value}:${String(value)}`;
-	}
 };
-
-//#endregion
-//#region src/Exceptions/UnsupportedAdapterFeatureException.ts
-var UnsupportedAdapterFeatureException = class extends ArkormException {
-	constructor(message, context = {}) {
-		super(message, {
-			code: "UNSUPPORTED_ADAPTER_FEATURE",
-			...context
-		});
-		this.name = "UnsupportedAdapterFeatureException";
-	}
+
+//#endregion
+//#region src/helpers/runtime-registry.ts
+const createEmptyRegistry = () => ({
+	paths: {
+		models: [],
+		seeders: [],
+		migrations: [],
+		factories: []
+	},
+	migrations: [],
+	seeders: [],
+	models: [],
+	factories: []
+});
+const registry = createEmptyRegistry();
+const pushUnique = (items, values) => {
+	values.forEach((value) => {
+		if (!items.includes(value)) items.push(value);
+	});
+};
+const normalizePathInput = (paths) => {
+	if (paths === void 0) return [];
+	return (Array.isArray(paths) ? paths : [paths]).filter((path) => typeof path === "string" && path.trim().length > 0);
+};
+const normalizeConstructors = (items) => items.flatMap((item) => Array.isArray(item) ? item : [item]).filter(Boolean);
+/**
+* Register additional runtime discovery paths without replacing configured paths.
+*
+* @param paths
+*/
+const registerPaths = (paths) => {
+	Object.entries(paths).forEach(([key, value]) => {
+		pushUnique(registry.paths[key], normalizePathInput(value));
+	});
+};
+/**
+* Register additional runtime discovery paths for migrations without replacing configured paths.
+*
+* @param paths
+* @returns
+*/
+const loadMigrationsFrom = (paths) => registerPaths({ migrations: paths });
+/**
+* Register additional runtime discovery paths for seeders without replacing configured paths.
+*
+* @param paths
+* @returns
+*/
+const loadSeedersFrom = (paths) => registerPaths({ seeders: paths });
+/**
+* Register additional runtime discovery paths for models without replacing configured paths.
+*
+* @param paths
+* @returns
+*/
+const loadModelsFrom = (paths) => registerPaths({ models: paths });
+/**
+* Register additional runtime discovery paths for factories without replacing configured paths.
+*
+* @param paths
+* @returns
+*/
+const loadFactoriesFrom = (paths) => registerPaths({ factories: paths });
+/**
+* Register migration constructors directly without relying on runtime discovery.
+*
+* @param migrations
+*/
+const registerMigrations = (...migrations) => {
+	pushUnique(registry.migrations, normalizeConstructors(migrations));
+};
+/**
+* Register seeder constructors directly without relying on runtime discovery.
+*
+* @param seeders
+*/
+const registerSeeders = (...seeders) => {
+	pushUnique(registry.seeders, normalizeConstructors(seeders));
+};
+/**
+* Register model constructors directly without relying on runtime discovery.
+*
+* @param models
+*/
+const registerModels = (...models) => {
+	pushUnique(registry.models, normalizeConstructors(models));
+};
+/**
+* Register factory constructors or instances directly without relying on runtime discovery.
+*
+* @param factories
+*/
+const registerFactories = (...factories) => {
+	pushUnique(registry.factories, normalizeConstructors(factories));
+};
+/**
+* Get registered runtime discovery paths or registered constructors for a specific type.
+*
+* @param key
+* @returns
+*/
+const getRegisteredPaths = (key) => {
+	if (key) return [...registry.paths[key]];
+	return {
+		models: [...registry.paths.models],
+		seeders: [...registry.paths.seeders],
+		migrations: [...registry.paths.migrations],
+		factories: [...registry.paths.factories]
+	};
+};
+/**
+* Get registered migration constructors instances.
+*
+* @returns
+*/
+const getRegisteredMigrations = () => [...registry.migrations];
+/**
+* Get registered seeder constructors instances.
+*
+* @returns
+*/
+const getRegisteredSeeders = () => [...registry.seeders];
+/**
+* Get registered model constructors instances.
+*
+* @returns
+*/
+const getRegisteredModels = () => [...registry.models];
+const resolveRegisteredModel = (modelName, context = {}) => {
+	const normalized = modelName.trim();
+	const model = registry.models.find((registered) => registered.name === normalized);
+	if (!model) throw new RelationResolutionException(`Model [${normalized}] is not registered. Register it with Arkorm.registerModels() or load it through configured model paths.`, {
+		operation: context.operation ?? "relationship.resolveModel",
+		model: normalized,
+		relation: context.relation
+	});
+	return model;
+};
+/**
+* Get registered factory constructors or instances.
+*
+* @returns
+*/
+const getRegisteredFactories = () => [...registry.factories];
+const resetRuntimeRegistryForTests = () => {
+	const empty = createEmptyRegistry();
+	registry.paths = empty.paths;
+	registry.migrations = empty.migrations;
+	registry.seeders = empty.seeders;
+	registry.models = empty.models;
+	registry.factories = empty.factories;
 };
 
 //#endregion
-//#region src/helpers/runtime-module-loader.ts
-var RuntimeModuleLoader = class {
-	static async load(filePath, useDefault = false) {
-		const resolvedPath = (0, node_path.resolve)(filePath);
-		return await (0, jiti.createJiti)((0, node_url.pathToFileURL)(resolvedPath).href, {
-			interopDefault: false,
-			tsconfigPaths: true,
-			sourceMaps: true
-		}).import(resolvedPath, useDefault ? { default: true } : {});
+//#region src/helpers/runtime-config.ts
+const resolveDefaultStubsPath = () => {
+	let current = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+	while (true) {
+		const packageJsonPath = path.default.join(current, "package.json");
+		const stubsPath = path.default.join(current, "stubs");
+		if ((0, fs.existsSync)(packageJsonPath) && (0, fs.existsSync)(stubsPath)) return stubsPath;
+		const parent = path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
 	}
-	/**
-	* Load many modules through a single shared jiti context, retrying files
-	* that fail until no further progress is made.
-	*
-	* A shared module cache resolves circular imports consistently: a file that
-	* fails because one of its dependencies was not yet cached (for example a
-	* trait whose module imports a model which imports the class that uses the
-	* trait) succeeds on a later pass, once a sibling load has populated that
-	* dependency. A fresh per-file context cannot do this, so the same set of
-	* files can load or fail depending purely on which file is the entry point.
-	*
-	* Each returned entry carries either the loaded module or the last error,
-	* so callers can surface genuine failures instead of silently dropping them.
-	*
-	* @param filePaths
-	* @param useDefault
-	* @returns
-	*/
-	static async loadAll(filePaths, useDefault = false) {
-		const jiti$1 = (0, jiti.createJiti)(`${(0, node_url.pathToFileURL)((0, node_path.resolve)(".")).href}/`, {
-			interopDefault: false,
-			tsconfigPaths: true,
-			sourceMaps: true
-		});
-		const results = /* @__PURE__ */ new Map();
-		let pending = filePaths.map((file) => (0, node_path.resolve)(file));
-		while (pending.length > 0) {
-			const failed = [];
-			for (const file of pending) try {
-				const module = await jiti$1.import(file, useDefault ? { default: true } : {});
-				results.set(file, {
-					file,
-					module
-				});
-			} catch (error) {
-				failed.push(file);
-				results.set(file, {
-					file,
-					module: null,
-					error
-				});
-			}
-			if (failed.length === pending.length) break;
-			pending = failed;
-		}
-		return filePaths.map((file) => results.get((0, node_path.resolve)(file)));
+	return path.default.join(process.cwd(), "stubs");
+};
+const baseConfig = {
+	naming: { case: "snake" },
+	features: {
+		persistedColumnMappings: true,
+		persistedEnums: true
+	},
+	paths: {
+		stubs: resolveDefaultStubsPath(),
+		seeders: path.default.join(process.cwd(), "database", "seeders"),
+		models: path.default.join(process.cwd(), "src", "models"),
+		migrations: path.default.join(process.cwd(), "database", "migrations"),
+		factories: path.default.join(process.cwd(), "database", "factories"),
+		buildOutput: path.default.join(process.cwd(), "dist")
+	},
+	outputExt: "ts"
+};
+const userConfig = {
+	...baseConfig,
+	naming: { ...baseConfig.naming ?? {} },
+	features: { ...baseConfig.features ?? {} },
+	paths: { ...baseConfig.paths ?? {} }
+};
+let runtimeConfigLoaded = false;
+let runtimeConfigLoadingPromise;
+let runtimeModelRegistrationPromise;
+let runtimeModelRegistrationGeneration = 0;
+let runtimeClientResolver;
+let runtimeAdapter;
+let runtimePaginationURLDriverFactory;
+let runtimePaginationCurrentPageResolver;
+let runtimeDebugHandler;
+const transactionClientStorage = new async_hooks.AsyncLocalStorage();
+const transactionAdapterStorage = new async_hooks.AsyncLocalStorage();
+const defaultDebugHandler = (event) => {
+	const prefix = `[arkorm:${event.adapter}] ${event.operation}${event.target ? ` [${event.target}]` : ""}`;
+	const payload = {
+		phase: event.phase,
+		durationMs: event.durationMs,
+		inspection: event.inspection ?? void 0,
+		meta: event.meta,
+		error: event.error
+	};
+	if (event.phase === "error") {
+		console.error(prefix, payload);
+		return;
 	}
+	console.debug(prefix, payload);
 };
-
-//#endregion
-//#region src/helpers/migration-history.ts
-const createEmptyAppliedMigrationsState = () => ({
-	version: 1,
-	migrations: [],
-	runs: []
-});
-const supportsDatabaseMigrationState = (adapter) => {
-	return typeof adapter?.readAppliedMigrationsState === "function" && typeof adapter?.writeAppliedMigrationsState === "function";
+const resolveDebugHandler = (debug) => {
+	if (debug === true) return defaultDebugHandler;
+	return typeof debug === "function" ? debug : void 0;
+};
+const mergeNamingConfig = (naming) => {
+	const defaults = baseConfig.naming ?? {};
+	const current = userConfig.naming ?? {};
+	const resolvedCase = naming?.case ?? naming?.modelTableCase ?? current.case ?? current.modelTableCase ?? defaults.case ?? defaults.modelTableCase ?? "snake";
+	return {
+		...defaults,
+		...current,
+		...naming ?? {},
+		case: resolvedCase
+	};
+};
+const mergePathConfig = (paths) => {
+	const defaults = baseConfig.paths ?? {};
+	const current = userConfig.paths ?? {};
+	const incoming = Object.entries(paths ?? {}).reduce((all, [key, value]) => {
+		if (typeof value === "string" && value.trim().length > 0) all[key] = path.default.isAbsolute(value) ? value : path.default.resolve(process.cwd(), value);
+		return all;
+	}, {});
+	return {
+		...defaults,
+		...current,
+		...incoming
+	};
+};
+/**
+* Merge the feature configuration from the base defaults, user configuration, and provided options.
+*
+* @param features
+* @returns
+*/
+const mergeFeatureConfig = (features) => {
+	const defaults = baseConfig.features ?? {};
+	const current = userConfig.features ?? {};
+	return {
+		...defaults,
+		...current,
+		...features ?? {}
+	};
+};
+const resolveRuntimeModelsDirectory = (directory) => {
+	if ((0, fs.existsSync)(directory)) return directory;
+	const buildOutput = userConfig.paths?.buildOutput;
+	if (typeof buildOutput !== "string" || buildOutput.trim().length === 0) return directory;
+	const relativeSource = path.default.relative(process.cwd(), directory);
+	if (!relativeSource || relativeSource.startsWith("..")) return directory;
+	const mappedDirectory = path.default.join(buildOutput, relativeSource);
+	return (0, fs.existsSync)(mappedDirectory) ? mappedDirectory : directory;
+};
+const collectRuntimeModelFiles = (directory) => {
+	if (!(0, fs.existsSync)(directory)) return [];
+	return (0, fs.readdirSync)(directory, { withFileTypes: true }).flatMap((entry) => {
+		const entryPath = path.default.join(directory, entry.name);
+		if (entry.isDirectory()) return collectRuntimeModelFiles(entryPath);
+		if (!entry.isFile() || !/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i.test(entry.name)) return [];
+		if (/\.d\.(ts|mts|cts)$/i.test(entry.name)) return [];
+		return [entryPath];
+	});
+};
+const isModelConstructor = (value) => {
+	if (typeof value !== "function") return false;
+	const candidate = value;
+	return typeof candidate.query === "function" && typeof candidate.hydrate === "function" && typeof candidate.getTable === "function" && typeof candidate.getPrimaryKey === "function";
+};
+const registerConfiguredModels = async (generation) => {
+	const configured = userConfig.paths?.models;
+	const additional = getRegisteredPaths("models");
+	const files = [...typeof configured === "string" ? [configured] : [], ...additional].map((directory) => resolveRuntimeModelsDirectory(path.default.isAbsolute(directory) ? directory : path.default.resolve(process.cwd(), directory))).filter((directory, index, all) => all.indexOf(directory) === index).flatMap(collectRuntimeModelFiles);
+	const loaded = await RuntimeModuleLoader.loadAll(files);
+	loaded.forEach(({ file, error }) => {
+		if (error !== void 0) console.warn(`[arkorm] Failed to load model file for registration: ${file}\n        ${error instanceof Error ? error.message : String(error)}\n        Models in this file will not be registered (morphTo resolution may fail). This is often a circular import — avoid importing models at the top level of trait modules.`);
+	});
+	const models = loaded.flatMap(({ module }) => module ? Object.values(module).filter(isModelConstructor) : []);
+	if (generation === runtimeModelRegistrationGeneration) registerModels(models);
+};
+const scheduleConfiguredModelRegistration = () => {
+	const generation = runtimeModelRegistrationGeneration;
+	runtimeModelRegistrationPromise = (runtimeModelRegistrationPromise ?? Promise.resolve()).then(async () => await registerConfiguredModels(generation));
+	return runtimeModelRegistrationPromise;
+};
+const awaitConfiguredModelsRegistration = async () => {
+	if (runtimeModelRegistrationPromise) await runtimeModelRegistrationPromise;
+};
+/**
+* Define the ArkORM runtime configuration. This function can be used to provide.
+*
+* @param config The ArkORM configuration object.
+* @returns The same configuration object.
+*/
+const defineConfig = (config) => {
+	return config;
+};
+/**
+* Bind a database adapter instance to an array of models that support adapter binding.
+*
+* @param adapter
+* @param models
+* @returns
+*/
+const bindAdapterToModels = (adapter, models) => {
+	models.forEach((model) => {
+		model.setAdapter(adapter);
+	});
+	return adapter;
 };
-const resolveMigrationStateFilePath = (cwd, configuredPath) => {
-	if (configuredPath && configuredPath.trim().length > 0) return (0, node_path.resolve)(configuredPath);
-	return (0, node_path.join)(cwd, ".arkormx", "migrations.applied.json");
+/**
+* Get the user-provided ArkORM configuration.
+*
+* @param key Optional specific configuration key to retrieve. If omitted, the entire configuration object is returned.
+* @returns The user-provided ArkORM configuration object.
+*/
+const getUserConfig = (key) => {
+	if (key) return userConfig[key];
+	return userConfig;
 };
-const buildMigrationIdentity = (filePath, className) => {
-	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
-	return `${fileName.slice(0, fileName.length - (0, node_path.extname)(fileName).length)}:${className}`;
+/**
+* Configure the ArkORM runtime with the provided runtime client resolver and
+* adapter-first options.
+*
+* @param client
+* @param options
+*/
+const configureArkormRuntime = (client, options = {}) => {
+	const resolvedClient = client ?? options.client;
+	const nextConfig = {
+		...userConfig,
+		naming: mergeNamingConfig(options.naming),
+		features: mergeFeatureConfig(options.features),
+		paths: mergePathConfig(options.paths)
+	};
+	nextConfig.client = resolvedClient;
+	nextConfig.prisma = resolvedClient;
+	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
+	if (options.adapter !== void 0) nextConfig.adapter = options.adapter;
+	if (options.boot !== void 0) nextConfig.boot = options.boot;
+	if (options.debug !== void 0) nextConfig.debug = options.debug;
+	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
+	Object.assign(userConfig, { ...nextConfig });
+	runtimeClientResolver = resolvedClient;
+	runtimeAdapter = options.adapter;
+	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
+	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+	runtimeDebugHandler = resolveDebugHandler(nextConfig.debug);
+	scheduleConfiguredModelRegistration();
+	const bootClient = resolveClient(resolvedClient);
+	options.boot?.({
+		client: bootClient,
+		prisma: bootClient,
+		bindAdapter: bindAdapterToModels
+	});
 };
-const computeMigrationChecksum = (filePath) => {
-	if (!(0, node_fs.existsSync)(filePath)) return (0, node_crypto.createHash)("sha256").update(filePath).digest("hex");
-	const source = (0, node_fs.readFileSync)(filePath, "utf-8");
-	return (0, node_crypto.createHash)("sha256").update(source).digest("hex");
+/**
+* Reset the ArkORM runtime configuration.
+* This is primarily intended for testing purposes.
+*/
+const resetArkormRuntimeForTests = () => {
+	Object.assign(userConfig, {
+		...baseConfig,
+		naming: { ...baseConfig.naming ?? {} },
+		features: { ...baseConfig.features ?? {} },
+		paths: { ...baseConfig.paths ?? {} }
+	});
+	runtimeConfigLoaded = false;
+	runtimeConfigLoadingPromise = void 0;
+	runtimeModelRegistrationPromise = void 0;
+	runtimeModelRegistrationGeneration++;
+	runtimeClientResolver = void 0;
+	runtimeAdapter = void 0;
+	runtimePaginationURLDriverFactory = void 0;
+	runtimePaginationCurrentPageResolver = void 0;
+	runtimeDebugHandler = void 0;
+	resetPersistedColumnMappingsCache();
+	resetRuntimeRegistryForTests();
 };
-const readAppliedMigrationsState = (stateFilePath) => {
-	if (!(0, node_fs.existsSync)(stateFilePath)) return createEmptyAppliedMigrationsState();
-	try {
-		const parsed = JSON.parse((0, node_fs.readFileSync)(stateFilePath, "utf-8"));
-		if (!Array.isArray(parsed.migrations)) return createEmptyAppliedMigrationsState();
-		return {
-			version: 1,
-			migrations: parsed.migrations.filter((migration) => {
-				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
-			}),
-			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
-				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
-			}) : []
-		};
-	} catch {
-		return createEmptyAppliedMigrationsState();
-	}
+/**
+* Resolve a runtime client instance from the provided resolver, which can be either
+* a direct client instance or a function that returns a client instance.
+*
+* @param resolver
+* @returns
+*/
+const resolveClient = (resolver) => {
+	if (!resolver) return void 0;
+	const client = typeof resolver === "function" ? resolver() : resolver;
+	if (!client || typeof client !== "object") return void 0;
+	return client;
 };
-const readAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
-	if (supportsDatabaseMigrationState(adapter)) return await adapter.readAppliedMigrationsState();
-	return readAppliedMigrationsState(stateFilePath);
+/**
+* Resolve and apply the ArkORM configuration from an imported module.
+* This function checks for a default export and falls back to the module itself, then validates
+* the configuration object and applies it to the runtime if valid.
+*
+* @param imported
+* @returns
+*/
+const resolveAndApplyConfig = (imported) => {
+	const config = imported?.default ?? imported;
+	if (!config || typeof config !== "object") return;
+	const runtimeClient = config.client ?? config.prisma;
+	configureArkormRuntime(runtimeClient, {
+		client: runtimeClient,
+		adapter: config.adapter,
+		boot: config.boot,
+		debug: config.debug,
+		naming: config.naming,
+		features: config.features,
+		pagination: config.pagination,
+		paths: config.paths,
+		outputExt: config.outputExt
+	});
+	runtimeConfigLoaded = true;
 };
-const writeAppliedMigrationsState = (stateFilePath, state) => {
-	const directory = (0, node_path.dirname)(stateFilePath);
-	if (!(0, node_fs.existsSync)(directory)) (0, node_fs.mkdirSync)(directory, { recursive: true });
-	(0, node_fs.writeFileSync)(stateFilePath, JSON.stringify(state, null, 2));
+/**
+* Dynamically import a configuration file.
+* A cache-busting query parameter is appended to ensure the latest version is loaded.
+*
+* @param configPath
+* @returns A promise that resolves to the imported configuration module.
+*/
+const importConfigFile = (configPath) => {
+	return RuntimeModuleLoader.load(configPath);
 };
-const writeAppliedMigrationsStateToStore = async (adapter, stateFilePath, state) => {
-	if (supportsDatabaseMigrationState(adapter)) {
-		await adapter.writeAppliedMigrationsState(state);
-		return;
+const loadRuntimeConfigSync = () => {
+	const require = (0, module$1.createRequire)(require("url").pathToFileURL(__filename).href);
+	const syncConfigPaths = [path.default.join(process.cwd(), "arkormx.config.cjs")];
+	for (const configPath of syncConfigPaths) {
+		if (!(0, fs.existsSync)(configPath)) continue;
+		try {
+			resolveAndApplyConfig(require(configPath));
+			return true;
+		} catch {
+			continue;
+		}
 	}
-	writeAppliedMigrationsState(stateFilePath, state);
+	return false;
 };
-const deleteAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
-	if (supportsDatabaseMigrationState(adapter)) {
-		await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
-		return "database";
+/**
+* Load the ArkORM configuration by searching for configuration files in the
+* current working directory.
+* @returns
+*/
+const loadArkormConfig = async () => {
+	if (runtimeConfigLoaded) {
+		await awaitConfiguredModelsRegistration();
+		return;
 	}
-	if (!(0, node_fs.existsSync)(stateFilePath)) return "missing-file";
-	writeAppliedMigrationsState(stateFilePath, createEmptyAppliedMigrationsState());
-	return "file";
+	if (runtimeConfigLoadingPromise) return await runtimeConfigLoadingPromise;
+	if (loadRuntimeConfigSync()) {
+		await awaitConfiguredModelsRegistration();
+		return;
+	}
+	runtimeConfigLoadingPromise = (async () => {
+		const configPaths = [path.default.join(process.cwd(), "arkormx.config.js"), path.default.join(process.cwd(), "arkormx.config.ts")];
+		for (const configPath of configPaths) {
+			if (!(0, fs.existsSync)(configPath)) continue;
+			try {
+				resolveAndApplyConfig(await importConfigFile(configPath));
+				await awaitConfiguredModelsRegistration();
+				return;
+			} catch {
+				continue;
+			}
+		}
+		runtimeConfigLoaded = true;
+		await scheduleConfiguredModelRegistration();
+		await awaitConfiguredModelsRegistration();
+	})();
+	await runtimeConfigLoadingPromise;
 };
-const isMigrationApplied = (state, identity, checksum) => {
-	const matched = state.migrations.find((migration) => migration.id === identity);
-	if (!matched) return false;
-	if (checksum && matched.checksum) return matched.checksum === checksum;
-	if (checksum && !matched.checksum) return false;
-	return true;
+/**
+* Ensure that the ArkORM configuration is loaded.
+* This function can be called to trigger the loading process if it hasn't already been initiated.
+* If the configuration is already loaded, it will return immediately.
+*
+* @returns
+*/
+const ensureArkormConfigLoading = () => {
+	if (runtimeConfigLoaded) return;
+	if (!runtimeConfigLoadingPromise) loadArkormConfig();
 };
-const findAppliedMigration = (state, identity) => {
-	return state.migrations.find((migration) => migration.id === identity);
+const getDefaultStubsPath = () => {
+	return resolveDefaultStubsPath();
 };
-const markMigrationApplied = (state, entry) => {
-	const next = state.migrations.filter((migration) => migration.id !== entry.id);
-	next.push(entry);
-	return {
-		version: 1,
-		migrations: next,
-		runs: state.runs ?? []
-	};
+/**
+* Get the runtime compatibility client.
+* This function will trigger the loading of the ArkORM configuration if
+* it hasn't already been loaded.
+*
+* @returns
+*/
+const getRuntimeClient = () => {
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionClient) return activeTransactionClient;
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return resolveClient(runtimeClientResolver);
+};
+/**
+* @deprecated Use getRuntimeClient instead.
+*/
+const getRuntimePrismaClient = getRuntimeClient;
+/**
+* Get the currently configured runtime adapter, if any.
+*
+* @returns
+*/
+const getRuntimeAdapter = () => {
+	const activeTransactionAdapter = transactionAdapterStorage.getStore();
+	if (activeTransactionAdapter) return activeTransactionAdapter;
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimeAdapter;
 };
-const removeAppliedMigration = (state, identity) => {
-	return {
-		version: 1,
-		migrations: state.migrations.filter((migration) => migration.id !== identity),
-		runs: (state.runs ?? []).map((run) => ({
-			...run,
-			migrationIds: run.migrationIds.filter((id) => id !== identity)
-		})).filter((run) => run.migrationIds.length > 0)
-	};
+/**
+* Releases the database resources held by the configured runtime — the adapter's
+* connection pool and/or the configured client. Intended for short-lived
+* processes (the CLI) so the Node event loop drains and the process exits
+* promptly instead of hanging on pool idle timeouts. Teardown failures are
+* swallowed because the process is shutting down anyway.
+*/
+const disposeArkormRuntime = async () => {
+	let adapterDisposed = false;
+	try {
+		if (runtimeAdapter && typeof runtimeAdapter.dispose === "function") {
+			await runtimeAdapter.dispose();
+			adapterDisposed = true;
+		}
+	} catch {}
+	const client = getRuntimeClient();
+	if (!client) return;
+	try {
+		if (typeof client.$disconnect === "function") await client.$disconnect();
+		else if (!adapterDisposed && typeof client.destroy === "function") await client.destroy();
+		else if (!adapterDisposed && typeof client.end === "function") await client.end();
+	} catch {}
 };
-const buildMigrationRunId = () => {
-	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+const getActiveTransactionClient = () => {
+	return transactionClientStorage.getStore();
 };
-const markMigrationRun = (state, run) => {
-	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
-	nextRuns.push(run);
-	return {
-		version: 1,
-		migrations: state.migrations,
-		runs: nextRuns
-	};
+const getActiveTransactionAdapter = () => {
+	return transactionAdapterStorage.getStore();
 };
-const getLastMigrationRun = (state) => {
-	const runs = state.runs ?? [];
-	if (runs.length === 0) return void 0;
-	return runs.map((run, index) => ({
-		run,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	})[0]?.run;
+const isTransactionCapableClient = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.$transaction === "function";
 };
-const getLatestAppliedMigrations = (state, steps) => {
-	return state.migrations.map((migration, index) => ({
-		migration,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
+const runArkormTransaction = async (callback, options = {}, preferredAdapter) => {
+	const activeTransactionAdapter = transactionAdapterStorage.getStore();
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionAdapter || activeTransactionClient) return await callback({
+		adapter: activeTransactionAdapter,
+		client: activeTransactionClient
+	});
+	const adapter = preferredAdapter ?? getRuntimeAdapter();
+	if (adapter) return await adapter.transaction(async (transactionAdapter) => {
+		return await transactionAdapterStorage.run(transactionAdapter, async () => {
+			return await callback({
+				adapter: transactionAdapter,
+				client: transactionClientStorage.getStore()
+			});
+		});
+	}, options);
+	const client = getRuntimeClient();
+	if (!client) throw new ArkormException("Cannot start a transaction without a configured runtime client or adapter.", {
+		code: "CLIENT_NOT_CONFIGURED",
+		operation: "transaction"
+	});
+	if (!isTransactionCapableClient(client)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the current adapter.", {
+		code: "TRANSACTION_NOT_SUPPORTED",
+		operation: "transaction"
+	});
+	return await client.$transaction(async (transactionClient) => {
+		return await transactionClientStorage.run(transactionClient, async () => {
+			return await callback({ client: transactionClient });
+		});
+	}, options);
 };
 /**
-* Groups the applied migrations into batches, oldest batch first, each batch
-* holding its migration ids in application order.
-*
-* A "batch" is one `migrate` run. When no runs were recorded (e.g. legacy state
-* written before run tracking), each applied migration is treated as its own
-* batch so `--step` still behaves predictably.
+* Get the configured pagination URL driver factory from runtime config.
 *
-* @param state
 * @returns
 */
-const resolveAppliedBatches = (state) => {
-	const runs = state.runs ?? [];
-	if (runs.length > 0) return runs.map((run, index) => ({
-		run,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = left.run.appliedAt.localeCompare(right.run.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return left.index - right.index;
-	}).map((entry) => entry.run.migrationIds);
-	return state.migrations.map((migration) => [migration.id]);
+const getRuntimePaginationURLDriverFactory = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimePaginationURLDriverFactory;
 };
 /**
-* Resolves the migrations belonging to the most recent `batches` batches, ordered
-* for rollback — **reverse of the order they were applied** (most recent batch
-* first, and within each batch the migration that ran `up()` last runs `down()`
-* first), so a rollback exactly reverses how the migrations were applied.
-*
-* Defaults to a single batch (`migrate:rollback` with no `--step`); `--step=N`
-* rolls back the last N batches.
+* Get the configured current-page resolver from runtime config.
 *
-* @param state
-* @param batches
 * @returns
 */
-const getLastBatchMigrations = (state, batches = 1) => {
-	if (batches < 1) return [];
-	const allBatches = resolveAppliedBatches(state);
-	const selected = allBatches.slice(Math.max(0, allBatches.length - batches));
-	const byId = new Map(state.migrations.map((migration) => [migration.id, migration]));
-	return selected.reverse().flatMap((migrationIds) => [...migrationIds].reverse()).map((id) => byId.get(id)).filter((migration) => Boolean(migration));
+const getRuntimePaginationCurrentPageResolver = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimePaginationCurrentPageResolver;
+};
+const getRuntimeDebugHandler = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimeDebugHandler;
+};
+const emitRuntimeDebugEvent = (event) => {
+	getRuntimeDebugHandler()?.(event);
 };
-
-//#endregion
-//#region src/database/ForeignKeyBuilder.ts
 /**
-* The ForeignKeyBuilder class provides a fluent interface for defining
-* foreign key constraints in a migration. It allows you to specify
-* the referenced table and column, as well as actions to take on
-* delete and aliases for the relation.
+* Check if a given value matches Arkorm's query-schema contract
+* by verifying the presence of common delegate methods.
 *
-* @author Legacy (3m1n3nc3)
-* @since 0.2.2
+* @param value The value to check.
+* @returns True if the value matches the query-schema contract, false otherwise.
 */
-var ForeignKeyBuilder = class {
-	constructor(foreignKey) {
-		this.foreignKey = foreignKey;
-	}
-	/**
-	* Defines the referenced table and column for this foreign key constraint.
-	*
-	* @param table
-	* @param column
-	* @returns
-	*/
-	references(table, column) {
-		this.foreignKey.referencesTable = table;
-		this.foreignKey.referencesColumn = column;
-		return this;
-	}
-	/**
-	* Defines the action to take when a referenced record is deleted, such
-	* as "CASCADE", "SET NULL", or "RESTRICT".
-	*
-	* @param action
-	* @returns
-	*/
-	onDelete(action) {
-		this.foreignKey.onDelete = action;
-		return this;
-	}
-	/**
-	* Defines an alias for the relation represented by this foreign key, which
-	* can be used in the ORM for more intuitive access to related models.
-	*
-	* @param name
-	* @returns
-	*/
-	alias(name) {
-		this.foreignKey.relationAlias = name;
-		return this;
-	}
-	/**
-	* Defines an alias for the inverse relation represented by this foreign key.
-	*
-	* @param name
-	* @returns
-	*/
-	inverseAlias(name) {
-		this.foreignKey.inverseRelationAlias = name;
-		return this;
-	}
-	/**
-	* Defines an alias for the foreign key field itself, which can be
-	* used in the ORM for more intuitive access to the foreign key value.
-	*
-	* @param fieldName
-	* @returns
-	*/
-	as(fieldName) {
-		this.foreignKey.fieldAlias = fieldName;
-		return this;
-	}
-};
-
-//#endregion
-//#region src/helpers/PrimaryKeyGenerationPlanner.ts
-var PrimaryKeyGenerationPlanner = class {
-	static plan(column) {
-		if (!column.primary || column.default !== void 0) return void 0;
-		if (column.type === "uuid" || column.type === "string") return {
-			strategy: "uuid",
-			prismaDefault: "@default(uuid())",
-			databaseDefault: column.type === "uuid" ? "gen_random_uuid()" : "gen_random_uuid()::text",
-			runtimeFactory: "uuid"
-		};
-	}
-	static generate(generation) {
-		if (generation?.runtimeFactory === "uuid") return (0, node_crypto.randomUUID)();
-	}
+const isQuerySchemaLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return [
+		"findMany",
+		"findFirst",
+		"create",
+		"update",
+		"delete",
+		"count"
+	].every((method) => typeof candidate[method] === "function");
 };
+/**
+* @deprecated Use isQuerySchemaLike instead.
+*/
+const isDelegateLike = isQuerySchemaLike;
+loadArkormConfig();
 
 //#endregion
 //#region src/Expression.ts
@@ -3650,886 +3322,1230 @@ const normalizePersistedTimestampColumns = (value) => {
 	}, []);
 	return columns.length > 0 ? columns : void 0;
 };
-const normalizePersistedColumnMappingsState = (state) => {
-	return {
-		version: 1,
-		tables: Object.entries(state?.tables ?? {}).reduce((all, [tableName, tableMetadata]) => {
-			if (tableName.trim().length === 0) return all;
-			const normalized = normalizePersistedTableMetadata(tableMetadata);
-			if (Object.keys(normalized.columns).length > 0 || Object.keys(normalized.enums).length > 0 || normalized.primaryKeyGeneration || normalized.timestampColumns?.length) all[tableName] = normalized;
+const normalizePersistedColumnMappingsState = (state) => {
+	return {
+		version: 1,
+		tables: Object.entries(state?.tables ?? {}).reduce((all, [tableName, tableMetadata]) => {
+			if (tableName.trim().length === 0) return all;
+			const normalized = normalizePersistedTableMetadata(tableMetadata);
+			if (Object.keys(normalized.columns).length > 0 || Object.keys(normalized.enums).length > 0 || normalized.primaryKeyGeneration || normalized.timestampColumns?.length) all[tableName] = normalized;
+			return all;
+		}, {})
+	};
+};
+const buildPersistedFeatureDisabledError = (feature, table) => {
+	return new ArkormException(`Table [${table}] requires ${feature === "persistedColumnMappings" ? "persisted column mappings" : "persisted enum metadata"}, but ${feature === "persistedColumnMappings" ? "features.persistedColumnMappings" : "features.persistedEnums"} is disabled in arkormx.config.*.`, {
+		operation: "metadata.persisted",
+		meta: {
+			feature,
+			table
+		}
+	});
+};
+const assertPersistedTableMetadataEnabled = (table, metadata, features, strict) => {
+	if (!strict) return;
+	if (!features.persistedColumnMappings && Object.keys(metadata.columns).length > 0) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+	if (!features.persistedEnums && Object.keys(metadata.enums).length > 0) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+};
+const buildEnumUnionType = (values) => {
+	return values.map((value) => {
+		return `'${value.replace(/'/g, String.raw`\'`)}'`;
+	}).join(" | ");
+};
+const resetPersistedColumnMappingsCache = () => {
+	cachedColumnMappingsPath = void 0;
+	cachedColumnMappingsState = void 0;
+};
+const readPersistedColumnMappingsState = (filePath) => {
+	if (cachedColumnMappingsPath === filePath && cachedColumnMappingsState) return cachedColumnMappingsState;
+	if (!(0, node_fs.existsSync)(filePath)) {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+	try {
+		const normalized = normalizePersistedColumnMappingsState(JSON.parse((0, node_fs.readFileSync)(filePath, "utf-8")));
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = normalized;
+		return normalized;
+	} catch {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+};
+const writePersistedColumnMappingsState = (filePath, state) => {
+	const normalized = normalizePersistedColumnMappingsState(state);
+	const directory = (0, node_path.dirname)(filePath);
+	if (!(0, node_fs.existsSync)(directory)) (0, node_fs.mkdirSync)(directory, { recursive: true });
+	(0, node_fs.writeFileSync)(filePath, JSON.stringify(normalized, null, 2));
+	cachedColumnMappingsPath = filePath;
+	cachedColumnMappingsState = normalized;
+};
+const deletePersistedColumnMappingsState = (filePath) => {
+	if ((0, node_fs.existsSync)(filePath)) (0, node_fs.rmSync)(filePath, { force: true });
+	resetPersistedColumnMappingsCache();
+};
+const getPersistedTableMetadata = (table, options = {}) => {
+	const metadata = readPersistedColumnMappingsState(resolveColumnMappingsFilePath(options.cwd ?? process.cwd(), options.configuredPath)).tables[table] ?? {
+		columns: {},
+		enums: {}
+	};
+	assertPersistedTableMetadataEnabled(table, metadata, options.features ?? resolvePersistedMetadataFeatures(), options.strict ?? false);
+	return {
+		columns: { ...metadata.columns },
+		enums: Object.entries(metadata.enums).reduce((all, [columnName, values]) => {
+			all[columnName] = [...values];
+			return all;
+		}, {}),
+		primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+		timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+	};
+};
+const getPersistedColumnMap = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).columns;
+};
+const getPersistedEnumMap = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).enums;
+};
+const getPersistedPrimaryKeyGeneration = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).primaryKeyGeneration;
+};
+const getPersistedTimestampColumns = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).timestampColumns ?? [];
+};
+const applyMappedColumn = (tableColumns, column, features, table) => {
+	if (typeof column.map === "string" && column.map.trim().length > 0 && column.map !== column.name) {
+		if (!features.persistedColumnMappings) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+		tableColumns[column.name] = column.map;
+		return;
+	}
+	delete tableColumns[column.name];
+};
+const applyEnumColumn = (tableEnums, column, features, table) => {
+	const values = column.enumValues ?? [];
+	if (column.type === "enum" && values.length > 0) {
+		if (!features.persistedEnums) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+		tableEnums[column.name] = [...values];
+		return;
+	}
+	delete tableEnums[column.name];
+};
+const removePersistedColumnMetadata = (tableMetadata, columnName) => {
+	delete tableMetadata.columns[columnName];
+	delete tableMetadata.enums[columnName];
+	Object.entries(tableMetadata.columns).forEach(([attribute, mappedColumn]) => {
+		if (mappedColumn === columnName) delete tableMetadata.columns[attribute];
+	});
+	if (tableMetadata.primaryKeyGeneration?.column === columnName) delete tableMetadata.primaryKeyGeneration;
+	if (tableMetadata.timestampColumns) {
+		tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((column) => column.column !== columnName);
+		if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+	}
+};
+const applyPrimaryKeyGeneration = (tableMetadata, column) => {
+	if (!column.primary || !column.primaryKeyGeneration) {
+		if (tableMetadata.primaryKeyGeneration?.column === column.name) delete tableMetadata.primaryKeyGeneration;
+		return;
+	}
+	tableMetadata.primaryKeyGeneration = {
+		column: column.name,
+		...column.primaryKeyGeneration
+	};
+};
+const applyTimestampColumn = (tableMetadata, column) => {
+	if (column.type !== "timestamp" || column.default !== "now()" && column.updatedAt !== true) {
+		if (tableMetadata.timestampColumns) {
+			tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((entry) => entry.column !== column.name);
+			if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+		}
+		return;
+	}
+	const nextColumn = {
+		column: column.name,
+		...column.default === "now()" ? { default: "now()" } : {},
+		...column.updatedAt ? { updatedAt: true } : {}
+	};
+	tableMetadata.timestampColumns = [...(tableMetadata.timestampColumns ?? []).filter((entry) => entry.column !== column.name), nextColumn];
+};
+const applyOperationsToPersistedColumnMappingsState = (state, operations, features = resolvePersistedMetadataFeatures()) => {
+	const nextTables = Object.entries(state.tables).reduce((all, [table, metadata]) => {
+		all[table] = {
+			columns: { ...metadata.columns },
+			enums: Object.entries(metadata.enums).reduce((nextEnums, [columnName, values]) => {
+				nextEnums[columnName] = [...values];
+				return nextEnums;
+			}, {}),
+			primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+			timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+		};
+		return all;
+	}, {});
+	operations.forEach((operation) => {
+		if (operation.type === "createTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.columns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		if (operation.type === "alterTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.addColumns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			operation.dropColumns.forEach((columnName) => {
+				removePersistedColumnMetadata(tableMetadata, columnName);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		delete nextTables[operation.table];
+	});
+	return {
+		version: 1,
+		tables: nextTables
+	};
+};
+const rebuildPersistedColumnMappingsState = async (state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const availableByIdentity = new Map(availableMigrations.map(([migrationClass, file]) => [buildMigrationIdentity(file, migrationClass.name), migrationClass]));
+	let nextState = createEmptyPersistedColumnMappingsState();
+	const orderedMigrations = state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = left.migration.appliedAt.localeCompare(right.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return left.index - right.index;
+	});
+	for (const { migration } of orderedMigrations) {
+		const migrationClass = availableByIdentity.get(migration.id);
+		if (!migrationClass) throw new ArkormException(`Unable to rebuild persisted column mappings because migration [${migration.id}] could not be resolved from the current migration files.`, {
+			operation: "migration.columnMappings",
+			meta: {
+				migrationId: migration.id,
+				file: migration.file,
+				className: migration.className
+			}
+		});
+		const operations = await getMigrationPlan(migrationClass, "up", { inert: true });
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+	return nextState;
+};
+const syncPersistedColumnMappingsFromState = async (cwd, state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const filePath = resolveColumnMappingsFilePath(cwd);
+	const nextState = await rebuildPersistedColumnMappingsState(state, availableMigrations, features);
+	if (Object.keys(nextState.tables).length === 0) {
+		deletePersistedColumnMappingsState(filePath);
+		return;
+	}
+	writePersistedColumnMappingsState(filePath, nextState);
+};
+const validatePersistedMetadataFeaturesForMigrations = async (migrations, features = resolvePersistedMetadataFeatures()) => {
+	let nextState = createEmptyPersistedColumnMappingsState();
+	for (const [migrationClass] of migrations) {
+		const operations = await getMigrationPlan(migrationClass, "up", { inert: true });
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+};
+const getPersistedEnumTsType = (values) => {
+	return buildEnumUnionType(values);
+};
+
+//#endregion
+//#region src/relationship/RelationTableLoader.ts
+/**
+* Utility class responsible for loading data from relation tables, which are used to
+* manage relationships between models in Arkorm.
+*
+* @author Legacy (3m1n3nc3)
+* @since 2.0.0-next.0
+*/
+var RelationTableLoader = class {
+	constructor(adapter) {
+		this.adapter = adapter;
+	}
+	buildTarget(table) {
+		return {
+			table,
+			columns: getPersistedTableMetadata(table, { features: resolvePersistedMetadataFeatures(getUserConfig("features")) }).columns
+		};
+	}
+	async selectRows(spec) {
+		return await this.adapter.select({
+			target: this.buildTarget(spec.table),
+			where: spec.where,
+			columns: spec.columns,
+			orderBy: spec.orderBy,
+			limit: spec.limit,
+			offset: spec.offset
+		});
+	}
+	async selectRow(spec) {
+		return await this.adapter.selectOne({
+			target: this.buildTarget(spec.table),
+			where: spec.where,
+			columns: spec.columns,
+			orderBy: spec.orderBy,
+			limit: spec.limit ?? 1,
+			offset: spec.offset
+		});
+	}
+	async selectColumnValues(spec) {
+		return (await this.selectRows({
+			...spec.lookup,
+			columns: [{ column: spec.column }]
+		})).map((row) => row[spec.column]);
+	}
+	async selectColumnValue(spec) {
+		return (await this.selectRow({
+			...spec.lookup,
+			columns: [{ column: spec.column }],
+			limit: 1
+		}))?.[spec.column] ?? null;
+	}
+};
+
+//#endregion
+//#region src/relationship/SetBasedEagerLoader.ts
+/**
+* Utility class responsible for performing set-based eager loading of relationships for
+* a collection of models.
+*
+* @author Legacy (3m1n3nc3)
+* @since 2.0.0-next.2
+*/
+var SetBasedEagerLoader = class SetBasedEagerLoader {
+	constructor(models, relations) {
+		this.models = models;
+		this.relations = relations;
+	}
+	/**
+	* Performs eager loading of all specified relationships for the set of models.
+	*
+	* @returns
+	*/
+	async load() {
+		if (this.models.length === 0) return;
+		const relationTree = this.buildRelationTree(this.relations);
+		await Promise.all(Array.from(relationTree.entries()).map(async ([name, node]) => {
+			await this.loadRelationNode(name, node);
+		}));
+	}
+	async loadRelationNode(name, node) {
+		await this.loadRelation(name, node.constraint);
+		if (node.children.size === 0) return;
+		const relatedModels = this.collectLoadedRelationModels(name);
+		if (relatedModels.length === 0) return;
+		await new SetBasedEagerLoader(relatedModels, this.relationTreeToMap(node.children)).load();
+	}
+	/**
+	* Loads a specific relationship for the set of models based on the relationship name
+	* and an optional constraint.
+	*
+	* @param name          The name of the relationship to load.
+	* @param constraint    An optional constraint to apply to the query.
+	* @returns             A promise that resolves when the relationship is loaded.
+	*/
+	async loadRelation(name, constraint) {
+		const resolver = this.resolveRelationResolver(name);
+		if (!resolver) return;
+		const metadata = resolver.call(this.models[0]).getMetadata();
+		switch (metadata.type) {
+			case "belongsTo":
+				await this.loadBelongsTo(name, resolver, metadata, constraint);
+				return;
+			case "belongsToMany":
+				await this.loadBelongsToMany(name, metadata, constraint);
+				return;
+			case "hasMany":
+				await this.loadHasMany(name, metadata, constraint);
+				return;
+			case "hasOne":
+				await this.loadHasOne(name, resolver, metadata, constraint);
+				return;
+			case "hasManyThrough":
+				await this.loadHasManyThrough(name, metadata, constraint);
+				return;
+			case "hasOneThrough":
+				await this.loadHasOneThrough(name, resolver, metadata, constraint);
+				return;
+			case "morphTo":
+				await this.loadMorphTo(name, metadata, constraint);
+				return;
+			case "morphOne":
+				await this.loadMorphOne(name, resolver, metadata, constraint);
+				return;
+			case "morphMany":
+				await this.loadMorphMany(name, metadata, constraint);
+				return;
+			case "morphToMany":
+			case "morphedByMany":
+				await this.loadPolymorphicManyToMany(name, metadata, constraint);
+				return;
+			default: await this.loadIndividually(name, resolver, constraint);
+		}
+	}
+	/**
+	* Resolves the relation resolver function for a given relationship name by inspecting
+	* the first model in the set.
+	*
+	* @param name  The name of the relationship to resolve.
+	* @returns     The relation resolver function or null if not found.
+	*/
+	resolveRelationResolver(name) {
+		const resolver = this.models[0][name];
+		if (typeof resolver !== "function") {
+			const modelName = this.models[0].constructor?.name ?? "Model";
+			throw new RelationResolutionException(`Relation [${name}] is not defined on the model.`, {
+				operation: "eagerLoad",
+				model: modelName,
+				relation: name
+			});
+		}
+		return resolver;
+	}
+	buildRelationTree(relations) {
+		const tree = /* @__PURE__ */ new Map();
+		Object.entries(relations).forEach(([path, constraint]) => {
+			const segments = path.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+			if (segments.length === 0) return;
+			let current = tree;
+			segments.forEach((segment, index) => {
+				const existing = current.get(segment) ?? {
+					constraint: void 0,
+					children: /* @__PURE__ */ new Map()
+				};
+				if (index === segments.length - 1 && constraint) existing.constraint = constraint;
+				current.set(segment, existing);
+				current = existing.children;
+			});
+		});
+		return tree;
+	}
+	relationTreeToMap(tree, prefix = "") {
+		return Array.from(tree.entries()).reduce((all, [name, node]) => {
+			const path = prefix ? `${prefix}.${name}` : name;
+			all[path] = node.constraint;
+			Object.assign(all, this.relationTreeToMap(node.children, path));
+			return all;
+		}, {});
+	}
+	collectLoadedRelationModels(name) {
+		return this.models.reduce((all, model) => {
+			const loaded = model.getAttribute(name);
+			if (loaded instanceof ArkormCollection) {
+				loaded.all().forEach((item) => {
+					if (this.isEagerLoadableModel(item)) all.push(item);
+				});
+				return all;
+			}
+			if (this.isEagerLoadableModel(loaded)) all.push(loaded);
+			return all;
+		}, []);
+	}
+	isEagerLoadableModel(value) {
+		return typeof value === "object" && value !== null && typeof value.getAttribute === "function" && typeof value.setLoadedRelation === "function";
+	}
+	/**
+	* Loads a "belongs to" relationship for the set of models.
+	*
+	* @param name          The name of the relationship to load.
+	* @param resolver      The relation resolver function.
+	* @param metadata      The metadata for the relationship.
+	* @param constraint    An optional constraint to apply to the query.
+	* @returns             A promise that resolves when the relationship is loaded.
+	*/
+	async loadBelongsTo(name, resolver, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.foreignKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.ownerKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = await this.getPartitionedModels(query, metadata.ownerKey, keys);
+		const relatedByOwnerKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.ownerKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (!relatedByOwnerKey.has(lookupKey)) relatedByOwnerKey.set(lookupKey, related);
+		});
+		this.models.forEach((model) => {
+			const foreignValue = model.getAttribute(metadata.foreignKey);
+			const relationValue = foreignValue == null ? void 0 : relatedByOwnerKey.get(this.toLookupKey(foreignValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
+	}
+	/**
+	* Loads a "has many" relationship for the set of models.
+	*
+	* @param name
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadHasMany(name, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = await this.getPartitionedModels(query, metadata.foreignKey, keys);
+		const relatedByForeignKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.foreignKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			const bucket = relatedByForeignKey.get(lookupKey) ?? [];
+			bucket.push(related);
+			relatedByForeignKey.set(lookupKey, bucket);
+		});
+		this.models.forEach((model) => {
+			const localValue = model.getAttribute(metadata.localKey);
+			const related = localValue == null ? [] : relatedByForeignKey.get(this.toLookupKey(localValue)) ?? [];
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	*
+	* @param name
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadBelongsToMany(name, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.parentKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		const pivotRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: this.buildBelongsToManyPivotWhere(metadata, parentKeys),
+			columns: this.getBelongsToManyPivotColumns(metadata).map((column) => ({ column }))
+		});
+		const relatedIds = this.collectUniqueRowValues(pivotRows, metadata.relatedPivotKey);
+		if (relatedIds.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.relatedKey, relatedIds);
+		query = this.applyConstraint(query, constraint);
+		if (query.hasEagerLoadPagination() && parentKeys.length > 1 && await this.loadLimitedBelongsToMany(name, metadata, query, parentKeys, pivotRows)) return;
+		const relatedModels = (await query.get()).all();
+		const relatedByKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.relatedKey);
+			if (relatedValue == null) return;
+			relatedByKey.set(this.toLookupKey(relatedValue), related);
+		});
+		const relatedKeysByParent = /* @__PURE__ */ new Map();
+		const pivotByParentAndRelated = /* @__PURE__ */ new Map();
+		pivotRows.forEach((row) => {
+			const parentValue = row[metadata.foreignPivotKey];
+			const relatedValue = row[metadata.relatedPivotKey];
+			if (parentValue == null || relatedValue == null) return;
+			const bucket = relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? [];
+			bucket.push(relatedValue);
+			relatedKeysByParent.set(this.toLookupKey(parentValue), bucket);
+			pivotByParentAndRelated.set(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`, row);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.parentKey);
+			const related = (parentValue == null ? [] : relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? []).reduce((all, relatedValue) => {
+				const candidate = relatedByKey.get(this.toLookupKey(relatedValue));
+				if (candidate) all.push(this.attachBelongsToManyPivot(metadata, candidate, pivotByParentAndRelated.get(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`)));
+				return all;
+			}, []);
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+	}
+	async loadLimitedBelongsToMany(name, metadata, query, parentKeys, pivotRows) {
+		if (metadata.pivotWhere) {
+			await this.loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows);
+			return true;
+		}
+		const pivotColumns = this.getBelongsToManyPivotColumns(metadata);
+		const pivotAliases = new Map(pivotColumns.map((column, index) => [column, `__arkorm_pivot_${index}`]));
+		const parentAlias = pivotAliases.get(metadata.foreignPivotKey);
+		const throughTable = metadata.throughTable;
+		const relatedTable = metadata.relatedModel.getTable();
+		const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.relatedKey)}`, "=", `${throughTable}.${metadata.relatedPivotKey}`).whereIn(`${throughTable}.${metadata.foreignPivotKey}`, parentKeys).addSelect({ ...Object.fromEntries([...pivotAliases].map(([column, alias]) => [`${throughTable}.${column}`, alias])) }).getRowsForEagerLoad([`${throughTable}.${metadata.foreignPivotKey}`]);
+		if (!rows) {
+			await this.loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows);
+			return true;
+		}
+		const selectedIds = this.collectUniqueRowValues(rows, metadata.relatedKey);
+		const relatedModels = (await query.clone().withoutPagination().whereIn(metadata.relatedKey, selectedIds).get()).all();
+		const relatedByKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const key = this.readModelAttribute(related, metadata.relatedKey);
+			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
+		});
+		const relatedByParent = /* @__PURE__ */ new Map();
+		rows.forEach((row) => {
+			const parentKey = row[parentAlias];
+			const relatedKey = row[metadata.relatedKey];
+			if (parentKey == null || relatedKey == null) return;
+			const related = relatedByKey.get(this.toLookupKey(relatedKey));
+			if (!related) return;
+			const pivot = Object.fromEntries([...pivotAliases].map(([column, alias]) => [column, row[alias]]));
+			const bucket = relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
+			bucket.push(this.attachBelongsToManyPivot(metadata, related, pivot));
+			relatedByParent.set(this.toLookupKey(parentKey), bucket);
+		});
+		this.models.forEach((model) => {
+			const parentKey = model.getAttribute(metadata.parentKey);
+			const related = parentKey == null ? [] : relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+		return true;
+	}
+	async loadLimitedBelongsToManyIndividually(name, metadata, query, pivotRows) {
+		const rowsByParent = /* @__PURE__ */ new Map();
+		pivotRows.forEach((row) => {
+			const parentKey = row[metadata.foreignPivotKey];
+			if (parentKey == null) return;
+			const bucket = rowsByParent.get(this.toLookupKey(parentKey)) ?? [];
+			bucket.push(row);
+			rowsByParent.set(this.toLookupKey(parentKey), bucket);
+		});
+		await Promise.all(this.models.map(async (model) => {
+			const parentKey = model.getAttribute(metadata.parentKey);
+			const rows = parentKey == null ? [] : rowsByParent.get(this.toLookupKey(parentKey)) ?? [];
+			const relatedIds = this.collectUniqueRowValues(rows, metadata.relatedPivotKey);
+			const related = relatedIds.length ? (await query.clone().whereIn(metadata.relatedKey, relatedIds).get()).all() : [];
+			const pivotByRelated = new Map(rows.map((row) => [this.toLookupKey(row[metadata.relatedPivotKey]), row]));
+			model.setLoadedRelation(name, new ArkormCollection(related.map((entry) => this.attachBelongsToManyPivot(metadata, entry, pivotByRelated.get(this.toLookupKey(this.readModelAttribute(entry, metadata.relatedKey)))))));
+		}));
+	}
+	buildBelongsToManyPivotWhere(metadata, parentKeys) {
+		const baseCondition = {
+			type: "comparison",
+			column: metadata.foreignPivotKey,
+			operator: "in",
+			value: parentKeys
+		};
+		if (!metadata.pivotWhere) return baseCondition;
+		return {
+			type: "group",
+			operator: "and",
+			conditions: [baseCondition, metadata.pivotWhere]
+		};
+	}
+	getBelongsToManyPivotColumns(metadata) {
+		return [
+			metadata.foreignPivotKey,
+			metadata.relatedPivotKey,
+			...metadata.pivotColumns ?? []
+		].filter((column, index, all) => all.indexOf(column) === index);
+	}
+	shouldAttachBelongsToManyPivot(metadata) {
+		return Boolean(metadata.pivotModel) || Boolean(metadata.pivotCreatedAtColumn) || Boolean(metadata.pivotUpdatedAtColumn) || (metadata.pivotColumns?.length ?? 0) > 0 || Boolean(metadata.pivotAccessor);
+	}
+	createBelongsToManyPivotRecord(metadata, row) {
+		const attributes = this.getBelongsToManyPivotColumns(metadata).reduce((all, column) => {
+			all[column] = row[column];
 			return all;
-		}, {})
-	};
-};
-const buildPersistedFeatureDisabledError = (feature, table) => {
-	return new ArkormException(`Table [${table}] requires ${feature === "persistedColumnMappings" ? "persisted column mappings" : "persisted enum metadata"}, but ${feature === "persistedColumnMappings" ? "features.persistedColumnMappings" : "features.persistedEnums"} is disabled in arkormx.config.*.`, {
-		operation: "metadata.persisted",
-		meta: {
-			feature,
-			table
+		}, {});
+		if (!metadata.pivotModel) return attributes;
+		if (typeof metadata.pivotModel.hydrate === "function") return metadata.pivotModel.hydrate(attributes);
+		return new metadata.pivotModel(attributes);
+	}
+	attachBelongsToManyPivot(metadata, related, row) {
+		if (!row || !this.shouldAttachBelongsToManyPivot(metadata)) return related;
+		const rawReader = related;
+		if (typeof rawReader.getRawAttributes !== "function" || typeof rawReader.setAttribute !== "function") return related;
+		const cloned = metadata.relatedModel.hydrate(rawReader.getRawAttributes());
+		cloned.setAttribute(metadata.pivotAccessor ?? "pivot", this.createBelongsToManyPivotRecord(metadata, row));
+		return cloned;
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	*
+	* @param name
+	* @param resolver
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadHasOne(name, resolver, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
 		}
-	});
-};
-const assertPersistedTableMetadataEnabled = (table, metadata, features, strict) => {
-	if (!strict) return;
-	if (!features.persistedColumnMappings && Object.keys(metadata.columns).length > 0) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
-	if (!features.persistedEnums && Object.keys(metadata.enums).length > 0) throw buildPersistedFeatureDisabledError("persistedEnums", table);
-};
-const buildEnumUnionType = (values) => {
-	return values.map((value) => {
-		return `'${value.replace(/'/g, String.raw`\'`)}'`;
-	}).join(" | ");
-};
-const resetPersistedColumnMappingsCache = () => {
-	cachedColumnMappingsPath = void 0;
-	cachedColumnMappingsState = void 0;
-};
-const readPersistedColumnMappingsState = (filePath) => {
-	if (cachedColumnMappingsPath === filePath && cachedColumnMappingsState) return cachedColumnMappingsState;
-	if (!(0, node_fs.existsSync)(filePath)) {
-		const empty = createEmptyPersistedColumnMappingsState();
-		cachedColumnMappingsPath = filePath;
-		cachedColumnMappingsState = empty;
-		return empty;
+		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = await this.getPartitionedModels(query, metadata.foreignKey, keys);
+		const relatedByForeignKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.foreignKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (!relatedByForeignKey.has(lookupKey)) relatedByForeignKey.set(lookupKey, related);
+		});
+		this.models.forEach((model) => {
+			const localValue = model.getAttribute(metadata.localKey);
+			const relationValue = localValue == null ? void 0 : relatedByForeignKey.get(this.toLookupKey(localValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
+	}
+	/**
+	* Loads a "has many through" relationship for the set of models.
+	*
+	* @param name
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadHasManyThrough(name, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		const throughRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: {
+				type: "comparison",
+				column: metadata.firstKey,
+				operator: "in",
+				value: parentKeys
+			}
+		});
+		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
+		if (intermediateKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
+		query = this.applyConstraint(query, constraint);
+		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
+			const limited = await this.loadLimitedThrough(metadata, query, parentKeys, throughRows);
+			this.models.forEach((model) => {
+				const parentKey = model.getAttribute(metadata.localKey);
+				const related = parentKey == null ? [] : limited.get(this.toLookupKey(parentKey)) ?? [];
+				model.setLoadedRelation(name, new ArkormCollection(related));
+			});
+			return;
+		}
+		const relatedModels = (await query.get()).all();
+		const relatedByIntermediate = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
+			if (relatedValue == null) return;
+			const bucket = relatedByIntermediate.get(this.toLookupKey(relatedValue)) ?? [];
+			bucket.push(related);
+			relatedByIntermediate.set(this.toLookupKey(relatedValue), bucket);
+		});
+		const intermediateByParent = /* @__PURE__ */ new Map();
+		throughRows.forEach((row) => {
+			const parentValue = row[metadata.firstKey];
+			const intermediateValue = row[metadata.secondLocalKey];
+			if (parentValue == null || intermediateValue == null) return;
+			const bucket = intermediateByParent.get(this.toLookupKey(parentValue)) ?? [];
+			bucket.push(intermediateValue);
+			intermediateByParent.set(this.toLookupKey(parentValue), bucket);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.localKey);
+			const related = (parentValue == null ? [] : intermediateByParent.get(this.toLookupKey(parentValue)) ?? []).flatMap((intermediateValue) => relatedByIntermediate.get(this.toLookupKey(intermediateValue)) ?? []);
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
 	}
-	try {
-		const normalized = normalizePersistedColumnMappingsState(JSON.parse((0, node_fs.readFileSync)(filePath, "utf-8")));
-		cachedColumnMappingsPath = filePath;
-		cachedColumnMappingsState = normalized;
-		return normalized;
-	} catch {
-		const empty = createEmptyPersistedColumnMappingsState();
-		cachedColumnMappingsPath = filePath;
-		cachedColumnMappingsState = empty;
-		return empty;
+	/**
+	* Loads a "has one through" relationship for the set of models.
+	*
+	* @param name
+	* @param resolver
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadHasOneThrough(name, resolver, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		const throughRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: {
+				type: "comparison",
+				column: metadata.firstKey,
+				operator: "in",
+				value: parentKeys
+			}
+		});
+		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
+		if (intermediateKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
+		query = this.applyConstraint(query, constraint);
+		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
+			const limited = await this.loadLimitedThrough(metadata, query, parentKeys, throughRows);
+			this.models.forEach((model) => {
+				const parentKey = model.getAttribute(metadata.localKey);
+				const related = parentKey == null ? void 0 : limited.get(this.toLookupKey(parentKey))?.[0];
+				model.setLoadedRelation(name, related ?? this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		const relatedModels = (await query.get()).all();
+		const relatedByIntermediate = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
+			if (relatedValue == null) return;
+			const lookupKey = this.toLookupKey(relatedValue);
+			if (!relatedByIntermediate.has(lookupKey)) relatedByIntermediate.set(lookupKey, related);
+		});
+		const intermediateByParent = /* @__PURE__ */ new Map();
+		throughRows.forEach((row) => {
+			const parentValue = row[metadata.firstKey];
+			const intermediateValue = row[metadata.secondLocalKey];
+			if (parentValue == null || intermediateValue == null) return;
+			const lookupKey = this.toLookupKey(parentValue);
+			if (!intermediateByParent.has(lookupKey)) intermediateByParent.set(lookupKey, intermediateValue);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.localKey);
+			const intermediateValue = parentValue == null ? void 0 : intermediateByParent.get(this.toLookupKey(parentValue));
+			const relationValue = intermediateValue == null ? void 0 : relatedByIntermediate.get(this.toLookupKey(intermediateValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
 	}
-};
-const writePersistedColumnMappingsState = (filePath, state) => {
-	const normalized = normalizePersistedColumnMappingsState(state);
-	const directory = (0, node_path.dirname)(filePath);
-	if (!(0, node_fs.existsSync)(directory)) (0, node_fs.mkdirSync)(directory, { recursive: true });
-	(0, node_fs.writeFileSync)(filePath, JSON.stringify(normalized, null, 2));
-	cachedColumnMappingsPath = filePath;
-	cachedColumnMappingsState = normalized;
-};
-const deletePersistedColumnMappingsState = (filePath) => {
-	if ((0, node_fs.existsSync)(filePath)) (0, node_fs.rmSync)(filePath, { force: true });
-	resetPersistedColumnMappingsCache();
-};
-const getPersistedTableMetadata = (table, options = {}) => {
-	const metadata = readPersistedColumnMappingsState(resolveColumnMappingsFilePath(options.cwd ?? process.cwd(), options.configuredPath)).tables[table] ?? {
-		columns: {},
-		enums: {}
-	};
-	assertPersistedTableMetadataEnabled(table, metadata, options.features ?? resolvePersistedMetadataFeatures(), options.strict ?? false);
-	return {
-		columns: { ...metadata.columns },
-		enums: Object.entries(metadata.enums).reduce((all, [columnName, values]) => {
-			all[columnName] = [...values];
+	async loadLimitedThrough(metadata, query, parentKeys, throughRows) {
+		const parentAlias = "__arkorm_parent_key";
+		const throughTable = metadata.throughTable;
+		const relatedTable = metadata.relatedModel.getTable();
+		const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.secondKey)}`, "=", `${throughTable}.${metadata.secondLocalKey}`).whereIn(`${throughTable}.${metadata.firstKey}`, parentKeys).addSelect({ [`${throughTable}.${metadata.firstKey}`]: parentAlias }).getRowsForEagerLoad([`${throughTable}.${metadata.firstKey}`]);
+		if (!rows) return await this.loadLimitedThroughIndividually(metadata, query, throughRows);
+		const relatedKey = metadata.relatedModel.getPrimaryKey();
+		const selectedIds = this.collectUniqueRowValues(rows, relatedKey);
+		const relatedModels = (await query.clone().withoutPagination().whereIn(relatedKey, selectedIds).get()).all();
+		const relatedByKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const key = this.readModelAttribute(related, relatedKey);
+			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
+		});
+		return rows.reduce((all, row) => {
+			const parentKey = row[parentAlias];
+			const key = row[relatedKey];
+			if (parentKey == null || key == null) return all;
+			const related = relatedByKey.get(this.toLookupKey(key));
+			if (!related) return all;
+			const lookup = this.toLookupKey(parentKey);
+			const bucket = all.get(lookup) ?? [];
+			bucket.push(related);
+			all.set(lookup, bucket);
 			return all;
-		}, {}),
-		primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
-		timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
-	};
-};
-const getPersistedColumnMap = (table, options = {}) => {
-	return getPersistedTableMetadata(table, options).columns;
-};
-const getPersistedEnumMap = (table, options = {}) => {
-	return getPersistedTableMetadata(table, options).enums;
-};
-const getPersistedPrimaryKeyGeneration = (table, options = {}) => {
-	return getPersistedTableMetadata(table, options).primaryKeyGeneration;
-};
-const getPersistedTimestampColumns = (table, options = {}) => {
-	return getPersistedTableMetadata(table, options).timestampColumns ?? [];
-};
-const applyMappedColumn = (tableColumns, column, features, table) => {
-	if (typeof column.map === "string" && column.map.trim().length > 0 && column.map !== column.name) {
-		if (!features.persistedColumnMappings) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
-		tableColumns[column.name] = column.map;
-		return;
+		}, /* @__PURE__ */ new Map());
 	}
-	delete tableColumns[column.name];
-};
-const applyEnumColumn = (tableEnums, column, features, table) => {
-	const values = column.enumValues ?? [];
-	if (column.type === "enum" && values.length > 0) {
-		if (!features.persistedEnums) throw buildPersistedFeatureDisabledError("persistedEnums", table);
-		tableEnums[column.name] = [...values];
-		return;
+	async loadLimitedThroughIndividually(metadata, query, throughRows) {
+		const intermediateByParent = /* @__PURE__ */ new Map();
+		throughRows.forEach((row) => {
+			const parentKey = row[metadata.firstKey];
+			const intermediateKey = row[metadata.secondLocalKey];
+			if (parentKey == null || intermediateKey == null) return;
+			const lookup = this.toLookupKey(parentKey);
+			const bucket = intermediateByParent.get(lookup) ?? [];
+			bucket.push(intermediateKey);
+			intermediateByParent.set(lookup, bucket);
+		});
+		const entries = await Promise.all([...intermediateByParent].map(async ([parentKey, intermediateKeys]) => {
+			return [parentKey, (await query.clone().whereIn(metadata.secondKey, intermediateKeys).get()).all()];
+		}));
+		return new Map(entries);
 	}
-	delete tableEnums[column.name];
-};
-const removePersistedColumnMetadata = (tableMetadata, columnName) => {
-	delete tableMetadata.columns[columnName];
-	delete tableMetadata.enums[columnName];
-	Object.entries(tableMetadata.columns).forEach(([attribute, mappedColumn]) => {
-		if (mappedColumn === columnName) delete tableMetadata.columns[attribute];
-	});
-	if (tableMetadata.primaryKeyGeneration?.column === columnName) delete tableMetadata.primaryKeyGeneration;
-	if (tableMetadata.timestampColumns) {
-		tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((column) => column.column !== columnName);
-		if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+	/**
+	* Loads an inverse polymorphic ("morph to") relationship for the set of
+	* models. Parents are grouped by their morph type, so each distinct type
+	* runs a single batched query instead of one query per parent row.
+	*
+	* @param name
+	* @param metadata
+	* @param constraint
+	* @returns
+	*/
+	async loadMorphTo(name, metadata, constraint) {
+		const idsByType = /* @__PURE__ */ new Map();
+		const seenByType = /* @__PURE__ */ new Map();
+		this.models.forEach((model) => {
+			const morphType = this.readModelAttribute(model, metadata.morphTypeColumn);
+			const morphId = this.readModelAttribute(model, metadata.morphIdColumn);
+			if (typeof morphType !== "string" || morphType.length === 0 || morphId == null) return;
+			const ids = idsByType.get(morphType) ?? [];
+			const seen = seenByType.get(morphType) ?? /* @__PURE__ */ new Set();
+			const lookupKey = this.toLookupKey(morphId);
+			if (!seen.has(lookupKey)) {
+				seen.add(lookupKey);
+				ids.push(morphId);
+			}
+			idsByType.set(morphType, ids);
+			seenByType.set(morphType, seen);
+		});
+		const relatedByTypeAndKey = /* @__PURE__ */ new Map();
+		await Promise.all(Array.from(idsByType.entries()).map(async ([morphType, ids]) => {
+			const relatedModel = metadata.resolveModel(morphType);
+			const ownerKey = metadata.ownerKey ?? relatedModel.getPrimaryKey();
+			let query = relatedModel.query().whereIn(ownerKey, ids);
+			query = this.applyConstraint(query, constraint);
+			(await this.getPartitionedModels(query, ownerKey, ids)).forEach((related) => {
+				const value = this.readModelAttribute(related, ownerKey);
+				if (value == null) return;
+				relatedByTypeAndKey.set(`${morphType}:${this.toLookupKey(value)}`, related);
+			});
+		}));
+		this.models.forEach((model) => {
+			const morphType = this.readModelAttribute(model, metadata.morphTypeColumn);
+			const morphId = this.readModelAttribute(model, metadata.morphIdColumn);
+			const relationValue = typeof morphType !== "string" || morphId == null ? null : relatedByTypeAndKey.get(`${morphType}:${this.toLookupKey(morphId)}`) ?? null;
+			model.setLoadedRelation(name, relationValue);
+		});
 	}
-};
-const applyPrimaryKeyGeneration = (tableMetadata, column) => {
-	if (!column.primary || !column.primaryKeyGeneration) {
-		if (tableMetadata.primaryKeyGeneration?.column === column.name) delete tableMetadata.primaryKeyGeneration;
-		return;
+	/**
+	* Loads a polymorphic one-to-one ("morph one") relationship for the set of
+	* models. See {@link loadMorphChildren} for the batching strategy.
+	*
+	* @param name
+	* @param resolver
+	* @param metadata
+	* @param constraint
+	*/
+	async loadMorphOne(name, resolver, metadata, constraint) {
+		const relatedByKey = await this.loadMorphChildren(metadata, constraint);
+		this.models.forEach((model) => {
+			const bucket = relatedByKey.get(this.morphParentKey(model, metadata.localKey));
+			model.setLoadedRelation(name, bucket?.[0] ?? this.resolveSingleDefault(resolver, model));
+		});
 	}
-	tableMetadata.primaryKeyGeneration = {
-		column: column.name,
-		...column.primaryKeyGeneration
-	};
-};
-const applyTimestampColumn = (tableMetadata, column) => {
-	if (column.type !== "timestamp" || column.default !== "now()" && column.updatedAt !== true) {
-		if (tableMetadata.timestampColumns) {
-			tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((entry) => entry.column !== column.name);
-			if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
-		}
-		return;
+	/**
+	* Loads a polymorphic one-to-many ("morph many") relationship for the set of
+	* models. See {@link loadMorphChildren} for the batching strategy.
+	*
+	* @param name
+	* @param metadata
+	* @param constraint
+	*/
+	async loadMorphMany(name, metadata, constraint) {
+		const relatedByKey = await this.loadMorphChildren(metadata, constraint);
+		this.models.forEach((model) => {
+			const bucket = relatedByKey.get(this.morphParentKey(model, metadata.localKey)) ?? [];
+			model.setLoadedRelation(name, new ArkormCollection(bucket));
+		});
 	}
-	const nextColumn = {
-		column: column.name,
-		...column.default === "now()" ? { default: "now()" } : {},
-		...column.updatedAt ? { updatedAt: true } : {}
-	};
-	tableMetadata.timestampColumns = [...(tableMetadata.timestampColumns ?? []).filter((entry) => entry.column !== column.name), nextColumn];
-};
-const applyOperationsToPersistedColumnMappingsState = (state, operations, features = resolvePersistedMetadataFeatures()) => {
-	const nextTables = Object.entries(state.tables).reduce((all, [table, metadata]) => {
-		all[table] = {
-			columns: { ...metadata.columns },
-			enums: Object.entries(metadata.enums).reduce((nextEnums, [columnName, values]) => {
-				nextEnums[columnName] = [...values];
-				return nextEnums;
-			}, {}),
-			primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
-			timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
-		};
-		return all;
-	}, {});
-	operations.forEach((operation) => {
-		if (operation.type === "createTable") {
-			const tableMetadata = nextTables[operation.table] ?? {
-				columns: {},
-				enums: {}
-			};
-			operation.columns.forEach((column) => {
-				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
-				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
-				applyPrimaryKeyGeneration(tableMetadata, column);
-				applyTimestampColumn(tableMetadata, column);
-			});
-			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
-			else delete nextTables[operation.table];
+	async loadPolymorphicManyToMany(name, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.parentKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => model.setLoadedRelation(name, new ArkormCollection([])));
 			return;
 		}
-		if (operation.type === "alterTable") {
-			const tableMetadata = nextTables[operation.table] ?? {
-				columns: {},
-				enums: {}
-			};
-			operation.addColumns.forEach((column) => {
-				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
-				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
-				applyPrimaryKeyGeneration(tableMetadata, column);
-				applyTimestampColumn(tableMetadata, column);
-			});
-			operation.dropColumns.forEach((columnName) => {
-				removePersistedColumnMetadata(tableMetadata, columnName);
-			});
-			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
-			else delete nextTables[operation.table];
+		const parentPivotKey = metadata.type === "morphToMany" ? metadata.morphIdColumn : metadata.foreignPivotKey;
+		const morphType = metadata.type === "morphToMany" ? this.morphTypeOf(this.models[0]) : metadata.relatedModel.name;
+		const pivotRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: {
+				type: "group",
+				operator: "and",
+				conditions: [{
+					type: "comparison",
+					column: parentPivotKey,
+					operator: "in",
+					value: parentKeys
+				}, {
+					type: "comparison",
+					column: metadata.morphTypeColumn,
+					operator: "=",
+					value: morphType
+				}]
+			},
+			columns: [parentPivotKey, metadata.relatedPivotKey].map((column) => ({ column }))
+		});
+		const relatedIds = this.collectUniqueRowValues(pivotRows, metadata.relatedPivotKey);
+		if (relatedIds.length === 0) {
+			this.models.forEach((model) => model.setLoadedRelation(name, new ArkormCollection([])));
 			return;
 		}
-		delete nextTables[operation.table];
-	});
-	return {
-		version: 1,
-		tables: nextTables
-	};
-};
-const rebuildPersistedColumnMappingsState = async (state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
-	const availableByIdentity = new Map(availableMigrations.map(([migrationClass, file]) => [buildMigrationIdentity(file, migrationClass.name), migrationClass]));
-	let nextState = createEmptyPersistedColumnMappingsState();
-	const orderedMigrations = state.migrations.map((migration, index) => ({
-		migration,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = left.migration.appliedAt.localeCompare(right.migration.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return left.index - right.index;
-	});
-	for (const { migration } of orderedMigrations) {
-		const migrationClass = availableByIdentity.get(migration.id);
-		if (!migrationClass) throw new ArkormException(`Unable to rebuild persisted column mappings because migration [${migration.id}] could not be resolved from the current migration files.`, {
-			operation: "migration.columnMappings",
-			meta: {
-				migrationId: migration.id,
-				file: migration.file,
-				className: migration.className
+		let query = metadata.relatedModel.query().whereIn(metadata.relatedKey, relatedIds);
+		query = this.applyConstraint(query, constraint);
+		let pairs = pivotRows.map((row) => ({
+			parent: row[parentPivotKey],
+			related: row[metadata.relatedPivotKey]
+		}));
+		let relatedModels;
+		if (query.hasEagerLoadPagination() && parentKeys.length > 1) {
+			const parentAlias = "__arkorm_parent_key";
+			const throughTable = metadata.throughTable;
+			const relatedTable = metadata.relatedModel.getTable();
+			const rows = await query.clone().innerJoin(throughTable, `${relatedTable}.${metadata.relatedModel.getColumnName(metadata.relatedKey)}`, "=", `${throughTable}.${metadata.relatedPivotKey}`).whereIn(`${throughTable}.${parentPivotKey}`, parentKeys).where({ [`${throughTable}.${metadata.morphTypeColumn}`]: morphType }).addSelect({ [`${throughTable}.${parentPivotKey}`]: parentAlias }).getRowsForEagerLoad([`${throughTable}.${parentPivotKey}`]);
+			if (rows) {
+				pairs = rows.map((row) => ({
+					parent: row[parentAlias],
+					related: row[metadata.relatedKey]
+				}));
+				const selectedIds = this.collectUniqueRowValues(rows, metadata.relatedKey);
+				relatedModels = (await query.clone().withoutPagination().whereIn(metadata.relatedKey, selectedIds).get()).all();
+			} else {
+				await this.loadPolymorphicManyToManyIndividually(name, metadata, query, parentPivotKey, pivotRows);
+				return;
 			}
+		} else relatedModels = (await query.get()).all();
+		const relatedByKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const key = this.readModelAttribute(related, metadata.relatedKey);
+			if (key != null) relatedByKey.set(this.toLookupKey(key), related);
+		});
+		const relatedByParent = /* @__PURE__ */ new Map();
+		pairs.forEach(({ parent, related }) => {
+			if (parent == null || related == null) return;
+			const model = relatedByKey.get(this.toLookupKey(related));
+			if (!model) return;
+			const lookup = this.toLookupKey(parent);
+			const bucket = relatedByParent.get(lookup) ?? [];
+			bucket.push(model);
+			relatedByParent.set(lookup, bucket);
+		});
+		this.models.forEach((model) => {
+			const parentKey = model.getAttribute(metadata.parentKey);
+			const related = parentKey == null ? [] : relatedByParent.get(this.toLookupKey(parentKey)) ?? [];
+			model.setLoadedRelation(name, new ArkormCollection(related));
 		});
-		const operations = await getMigrationPlan(migrationClass, "up", { inert: true });
-		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
 	}
-	return nextState;
-};
-const syncPersistedColumnMappingsFromState = async (cwd, state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
-	const filePath = resolveColumnMappingsFilePath(cwd);
-	const nextState = await rebuildPersistedColumnMappingsState(state, availableMigrations, features);
-	if (Object.keys(nextState.tables).length === 0) {
-		deletePersistedColumnMappingsState(filePath);
-		return;
+	async loadPolymorphicManyToManyIndividually(name, metadata, query, parentPivotKey, pivotRows) {
+		await Promise.all(this.models.map(async (model) => {
+			const parentKey = model.getAttribute(metadata.parentKey);
+			const ids = pivotRows.filter((row) => this.toLookupKey(row[parentPivotKey]) === this.toLookupKey(parentKey)).map((row) => row[metadata.relatedPivotKey]);
+			const related = ids.length ? (await query.clone().whereIn(metadata.relatedKey, ids).get()).all() : [];
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		}));
+	}
+	/**
+	* Batch-loads the children for a morphOne/morphMany relationship. Parents are
+	* grouped by their own morph type (constructor name), so each distinct type
+	* runs a single query constrained by `idColumn IN (...) AND typeColumn = type`
+	* instead of one query per parent row. This also supports a heterogeneous
+	* parent set (e.g. the result of a nested load after a morphTo).
+	*
+	* @param metadata
+	* @param constraint
+	* @returns A map of `"{type}:{localKey}" -> related[]`.
+	*/
+	async loadMorphChildren(metadata, constraint) {
+		const keysByType = /* @__PURE__ */ new Map();
+		const seenByType = /* @__PURE__ */ new Map();
+		this.models.forEach((model) => {
+			const morphType = this.morphTypeOf(model);
+			const localValue = model.getAttribute(metadata.localKey);
+			if (morphType.length === 0 || localValue == null) return;
+			const keys = keysByType.get(morphType) ?? [];
+			const seen = seenByType.get(morphType) ?? /* @__PURE__ */ new Set();
+			const lookupKey = this.toLookupKey(localValue);
+			if (!seen.has(lookupKey)) {
+				seen.add(lookupKey);
+				keys.push(localValue);
+			}
+			keysByType.set(morphType, keys);
+			seenByType.set(morphType, seen);
+		});
+		const relatedByKey = /* @__PURE__ */ new Map();
+		await Promise.all(Array.from(keysByType.entries()).map(async ([morphType, keys]) => {
+			let query = metadata.relatedModel.query().whereIn(metadata.morphIdColumn, keys).where({ [metadata.morphTypeColumn]: morphType });
+			query = this.applyConstraint(query, constraint);
+			(await this.getPartitionedModels(query, metadata.morphIdColumn, keys)).forEach((related) => {
+				const value = this.readModelAttribute(related, metadata.morphIdColumn);
+				if (value == null) return;
+				const key = `${morphType}:${this.toLookupKey(value)}`;
+				const bucket = relatedByKey.get(key) ?? [];
+				bucket.push(related);
+				relatedByKey.set(key, bucket);
+			});
+		}));
+		return relatedByKey;
+	}
+	morphParentKey(model, localKey) {
+		return `${this.morphTypeOf(model)}:${this.toLookupKey(model.getAttribute(localKey))}`;
 	}
-	writePersistedColumnMappingsState(filePath, nextState);
-};
-const validatePersistedMetadataFeaturesForMigrations = async (migrations, features = resolvePersistedMetadataFeatures()) => {
-	let nextState = createEmptyPersistedColumnMappingsState();
-	for (const [migrationClass] of migrations) {
-		const operations = await getMigrationPlan(migrationClass, "up", { inert: true });
-		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	morphTypeOf(model) {
+		return model.constructor?.name ?? "";
 	}
-};
-const getPersistedEnumTsType = (values) => {
-	return buildEnumUnionType(values);
-};
-
-//#endregion
-//#region src/helpers/runtime-registry.ts
-const createEmptyRegistry = () => ({
-	paths: {
-		models: [],
-		seeders: [],
-		migrations: [],
-		factories: []
-	},
-	migrations: [],
-	seeders: [],
-	models: [],
-	factories: []
-});
-const registry = createEmptyRegistry();
-const pushUnique = (items, values) => {
-	values.forEach((value) => {
-		if (!items.includes(value)) items.push(value);
-	});
-};
-const normalizePathInput = (paths) => {
-	if (paths === void 0) return [];
-	return (Array.isArray(paths) ? paths : [paths]).filter((path) => typeof path === "string" && path.trim().length > 0);
-};
-const normalizeConstructors = (items) => items.flatMap((item) => Array.isArray(item) ? item : [item]).filter(Boolean);
-/**
-* Register additional runtime discovery paths without replacing configured paths.
-*
-* @param paths
-*/
-const registerPaths = (paths) => {
-	Object.entries(paths).forEach(([key, value]) => {
-		pushUnique(registry.paths[key], normalizePathInput(value));
-	});
-};
-/**
-* Register additional runtime discovery paths for migrations without replacing configured paths.
-*
-* @param paths
-* @returns
-*/
-const loadMigrationsFrom = (paths) => registerPaths({ migrations: paths });
-/**
-* Register additional runtime discovery paths for seeders without replacing configured paths.
-*
-* @param paths
-* @returns
-*/
-const loadSeedersFrom = (paths) => registerPaths({ seeders: paths });
-/**
-* Register additional runtime discovery paths for models without replacing configured paths.
-*
-* @param paths
-* @returns
-*/
-const loadModelsFrom = (paths) => registerPaths({ models: paths });
-/**
-* Register additional runtime discovery paths for factories without replacing configured paths.
-*
-* @param paths
-* @returns
-*/
-const loadFactoriesFrom = (paths) => registerPaths({ factories: paths });
-/**
-* Register migration constructors directly without relying on runtime discovery.
-*
-* @param migrations
-*/
-const registerMigrations = (...migrations) => {
-	pushUnique(registry.migrations, normalizeConstructors(migrations));
-};
-/**
-* Register seeder constructors directly without relying on runtime discovery.
-*
-* @param seeders
-*/
-const registerSeeders = (...seeders) => {
-	pushUnique(registry.seeders, normalizeConstructors(seeders));
-};
-/**
-* Register model constructors directly without relying on runtime discovery.
-*
-* @param models
-*/
-const registerModels = (...models) => {
-	pushUnique(registry.models, normalizeConstructors(models));
-};
-/**
-* Register factory constructors or instances directly without relying on runtime discovery.
-*
-* @param factories
-*/
-const registerFactories = (...factories) => {
-	pushUnique(registry.factories, normalizeConstructors(factories));
-};
-/**
-* Get registered runtime discovery paths or registered constructors for a specific type.
-*
-* @param key
-* @returns
-*/
-const getRegisteredPaths = (key) => {
-	if (key) return [...registry.paths[key]];
-	return {
-		models: [...registry.paths.models],
-		seeders: [...registry.paths.seeders],
-		migrations: [...registry.paths.migrations],
-		factories: [...registry.paths.factories]
-	};
-};
-/**
-* Get registered migration constructors instances.
-*
-* @returns
-*/
-const getRegisteredMigrations = () => [...registry.migrations];
-/**
-* Get registered seeder constructors instances.
-*
-* @returns
-*/
-const getRegisteredSeeders = () => [...registry.seeders];
-/**
-* Get registered model constructors instances.
-*
-* @returns
-*/
-const getRegisteredModels = () => [...registry.models];
-/**
-* Get registered factory constructors or instances.
-*
-* @returns
-*/
-const getRegisteredFactories = () => [...registry.factories];
-const resetRuntimeRegistryForTests = () => {
-	const empty = createEmptyRegistry();
-	registry.paths = empty.paths;
-	registry.migrations = empty.migrations;
-	registry.seeders = empty.seeders;
-	registry.models = empty.models;
-	registry.factories = empty.factories;
-};
-
-//#endregion
-//#region src/helpers/runtime-config.ts
-const resolveDefaultStubsPath = () => {
-	let current = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
-	while (true) {
-		const packageJsonPath = path.default.join(current, "package.json");
-		const stubsPath = path.default.join(current, "stubs");
-		if ((0, fs.existsSync)(packageJsonPath) && (0, fs.existsSync)(stubsPath)) return stubsPath;
-		const parent = path.default.dirname(current);
-		if (parent === current) break;
-		current = parent;
+	/**
+	* Fallback method to load relationships individually for each model when the
+	* relationship type is not supported for set-based loading.
+	*
+	* @param name
+	* @param resolver
+	* @param constraint
+	*/
+	async loadIndividually(name, resolver, constraint) {
+		await Promise.all(this.models.map(async (model) => {
+			const relation = resolver.call(model);
+			if (constraint) relation.constrain(constraint);
+			model.setLoadedRelation(name, await relation.getResults());
+		}));
 	}
-	return path.default.join(process.cwd(), "stubs");
-};
-const baseConfig = {
-	naming: { case: "snake" },
-	features: {
-		persistedColumnMappings: true,
-		persistedEnums: true
-	},
-	paths: {
-		stubs: resolveDefaultStubsPath(),
-		seeders: path.default.join(process.cwd(), "database", "seeders"),
-		models: path.default.join(process.cwd(), "src", "models"),
-		migrations: path.default.join(process.cwd(), "database", "migrations"),
-		factories: path.default.join(process.cwd(), "database", "factories"),
-		buildOutput: path.default.join(process.cwd(), "dist")
-	},
-	outputExt: "ts"
-};
-const userConfig = {
-	...baseConfig,
-	naming: { ...baseConfig.naming ?? {} },
-	features: { ...baseConfig.features ?? {} },
-	paths: { ...baseConfig.paths ?? {} }
-};
-let runtimeConfigLoaded = false;
-let runtimeConfigLoadingPromise;
-let runtimeModelRegistrationPromise;
-let runtimeModelRegistrationGeneration = 0;
-let runtimeClientResolver;
-let runtimeAdapter;
-let runtimePaginationURLDriverFactory;
-let runtimePaginationCurrentPageResolver;
-let runtimeDebugHandler;
-const transactionClientStorage = new async_hooks.AsyncLocalStorage();
-const transactionAdapterStorage = new async_hooks.AsyncLocalStorage();
-const defaultDebugHandler = (event) => {
-	const prefix = `[arkorm:${event.adapter}] ${event.operation}${event.target ? ` [${event.target}]` : ""}`;
-	const payload = {
-		phase: event.phase,
-		durationMs: event.durationMs,
-		inspection: event.inspection ?? void 0,
-		meta: event.meta,
-		error: event.error
-	};
-	if (event.phase === "error") {
-		console.error(prefix, payload);
-		return;
+	/**
+	* Applies an eager load constraint to a query if provided.
+	*
+	* @param query
+	* @param constraint
+	* @returns
+	*/
+	applyConstraint(query, constraint) {
+		if (!constraint) return query;
+		return constraint(query) ?? query;
+	}
+	async getPartitionedModels(query, partitionColumn, partitionValues) {
+		if (partitionValues.length <= 1) return (await query.get()).all();
+		const partitioned = await query.getForEagerLoad([partitionColumn]);
+		if (partitioned) return partitioned.all();
+		return (await Promise.all(partitionValues.map(async (value) => {
+			return (await query.clone().where({ [partitionColumn]: value }).get()).all();
+		}))).flat();
+	}
+	/**
+	* Collects unique values from the set of models based on a resolver function, which
+	* is used to extract the value from each model.
+	*
+	* @param resolve   A function that takes a model and returns the value to be collected.
+	* @returns         An array of unique values.
+	*/
+	collectUniqueKeys(resolve) {
+		const seen = /* @__PURE__ */ new Set();
+		const values = [];
+		this.models.forEach((model) => {
+			const value = resolve(model);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (seen.has(lookupKey)) return;
+			seen.add(lookupKey);
+			values.push(value);
+		});
+		return values;
 	}
-	console.debug(prefix, payload);
-};
-const resolveDebugHandler = (debug) => {
-	if (debug === true) return defaultDebugHandler;
-	return typeof debug === "function" ? debug : void 0;
-};
-const mergeNamingConfig = (naming) => {
-	const defaults = baseConfig.naming ?? {};
-	const current = userConfig.naming ?? {};
-	const resolvedCase = naming?.case ?? naming?.modelTableCase ?? current.case ?? current.modelTableCase ?? defaults.case ?? defaults.modelTableCase ?? "snake";
-	return {
-		...defaults,
-		...current,
-		...naming ?? {},
-		case: resolvedCase
-	};
-};
-const mergePathConfig = (paths) => {
-	const defaults = baseConfig.paths ?? {};
-	const current = userConfig.paths ?? {};
-	const incoming = Object.entries(paths ?? {}).reduce((all, [key, value]) => {
-		if (typeof value === "string" && value.trim().length > 0) all[key] = path.default.isAbsolute(value) ? value : path.default.resolve(process.cwd(), value);
-		return all;
-	}, {});
-	return {
-		...defaults,
-		...current,
-		...incoming
-	};
-};
-/**
-* Merge the feature configuration from the base defaults, user configuration, and provided options.
-*
-* @param features
-* @returns
-*/
-const mergeFeatureConfig = (features) => {
-	const defaults = baseConfig.features ?? {};
-	const current = userConfig.features ?? {};
-	return {
-		...defaults,
-		...current,
-		...features ?? {}
-	};
-};
-const resolveRuntimeModelsDirectory = (directory) => {
-	if ((0, fs.existsSync)(directory)) return directory;
-	const buildOutput = userConfig.paths?.buildOutput;
-	if (typeof buildOutput !== "string" || buildOutput.trim().length === 0) return directory;
-	const relativeSource = path.default.relative(process.cwd(), directory);
-	if (!relativeSource || relativeSource.startsWith("..")) return directory;
-	const mappedDirectory = path.default.join(buildOutput, relativeSource);
-	return (0, fs.existsSync)(mappedDirectory) ? mappedDirectory : directory;
-};
-const collectRuntimeModelFiles = (directory) => {
-	if (!(0, fs.existsSync)(directory)) return [];
-	return (0, fs.readdirSync)(directory, { withFileTypes: true }).flatMap((entry) => {
-		const entryPath = path.default.join(directory, entry.name);
-		if (entry.isDirectory()) return collectRuntimeModelFiles(entryPath);
-		if (!entry.isFile() || !/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i.test(entry.name)) return [];
-		if (/\.d\.(ts|mts|cts)$/i.test(entry.name)) return [];
-		return [entryPath];
-	});
-};
-const isModelConstructor = (value) => {
-	if (typeof value !== "function") return false;
-	const candidate = value;
-	return typeof candidate.query === "function" && typeof candidate.hydrate === "function" && typeof candidate.getTable === "function" && typeof candidate.getPrimaryKey === "function";
-};
-const registerConfiguredModels = async (generation) => {
-	const configured = userConfig.paths?.models;
-	const additional = getRegisteredPaths("models");
-	const files = [...typeof configured === "string" ? [configured] : [], ...additional].map((directory) => resolveRuntimeModelsDirectory(path.default.isAbsolute(directory) ? directory : path.default.resolve(process.cwd(), directory))).filter((directory, index, all) => all.indexOf(directory) === index).flatMap(collectRuntimeModelFiles);
-	const loaded = await RuntimeModuleLoader.loadAll(files);
-	loaded.forEach(({ file, error }) => {
-		if (error !== void 0) console.warn(`[arkorm] Failed to load model file for registration: ${file}\n        ${error instanceof Error ? error.message : String(error)}\n        Models in this file will not be registered (morphTo resolution may fail). This is often a circular import — avoid importing models at the top level of trait modules.`);
-	});
-	const models = loaded.flatMap(({ module }) => module ? Object.values(module).filter(isModelConstructor) : []);
-	if (generation === runtimeModelRegistrationGeneration) registerModels(models);
-};
-const scheduleConfiguredModelRegistration = () => {
-	const generation = runtimeModelRegistrationGeneration;
-	runtimeModelRegistrationPromise = (runtimeModelRegistrationPromise ?? Promise.resolve()).then(async () => await registerConfiguredModels(generation));
-	return runtimeModelRegistrationPromise;
-};
-const awaitConfiguredModelsRegistration = async () => {
-	if (runtimeModelRegistrationPromise) await runtimeModelRegistrationPromise;
-};
-/**
-* Define the ArkORM runtime configuration. This function can be used to provide.
-*
-* @param config The ArkORM configuration object.
-* @returns The same configuration object.
-*/
-const defineConfig = (config) => {
-	return config;
-};
-/**
-* Bind a database adapter instance to an array of models that support adapter binding.
-*
-* @param adapter
-* @param models
-* @returns
-*/
-const bindAdapterToModels = (adapter, models) => {
-	models.forEach((model) => {
-		model.setAdapter(adapter);
-	});
-	return adapter;
-};
-/**
-* Get the user-provided ArkORM configuration.
-*
-* @param key Optional specific configuration key to retrieve. If omitted, the entire configuration object is returned.
-* @returns The user-provided ArkORM configuration object.
-*/
-const getUserConfig = (key) => {
-	if (key) return userConfig[key];
-	return userConfig;
-};
-/**
-* Configure the ArkORM runtime with the provided runtime client resolver and
-* adapter-first options.
-*
-* @param client
-* @param options
-*/
-const configureArkormRuntime = (client, options = {}) => {
-	const resolvedClient = client ?? options.client;
-	const nextConfig = {
-		...userConfig,
-		naming: mergeNamingConfig(options.naming),
-		features: mergeFeatureConfig(options.features),
-		paths: mergePathConfig(options.paths)
-	};
-	nextConfig.client = resolvedClient;
-	nextConfig.prisma = resolvedClient;
-	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
-	if (options.adapter !== void 0) nextConfig.adapter = options.adapter;
-	if (options.boot !== void 0) nextConfig.boot = options.boot;
-	if (options.debug !== void 0) nextConfig.debug = options.debug;
-	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
-	Object.assign(userConfig, { ...nextConfig });
-	runtimeClientResolver = resolvedClient;
-	runtimeAdapter = options.adapter;
-	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
-	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
-	runtimeDebugHandler = resolveDebugHandler(nextConfig.debug);
-	scheduleConfiguredModelRegistration();
-	const bootClient = resolveClient(resolvedClient);
-	options.boot?.({
-		client: bootClient,
-		prisma: bootClient,
-		bindAdapter: bindAdapterToModels
-	});
-};
-/**
-* Reset the ArkORM runtime configuration.
-* This is primarily intended for testing purposes.
-*/
-const resetArkormRuntimeForTests = () => {
-	Object.assign(userConfig, {
-		...baseConfig,
-		naming: { ...baseConfig.naming ?? {} },
-		features: { ...baseConfig.features ?? {} },
-		paths: { ...baseConfig.paths ?? {} }
-	});
-	runtimeConfigLoaded = false;
-	runtimeConfigLoadingPromise = void 0;
-	runtimeModelRegistrationPromise = void 0;
-	runtimeModelRegistrationGeneration++;
-	runtimeClientResolver = void 0;
-	runtimeAdapter = void 0;
-	runtimePaginationURLDriverFactory = void 0;
-	runtimePaginationCurrentPageResolver = void 0;
-	runtimeDebugHandler = void 0;
-	resetPersistedColumnMappingsCache();
-	resetRuntimeRegistryForTests();
-};
-/**
-* Resolve a runtime client instance from the provided resolver, which can be either
-* a direct client instance or a function that returns a client instance.
-*
-* @param resolver
-* @returns
-*/
-const resolveClient = (resolver) => {
-	if (!resolver) return void 0;
-	const client = typeof resolver === "function" ? resolver() : resolver;
-	if (!client || typeof client !== "object") return void 0;
-	return client;
-};
-/**
-* Resolve and apply the ArkORM configuration from an imported module.
-* This function checks for a default export and falls back to the module itself, then validates
-* the configuration object and applies it to the runtime if valid.
-*
-* @param imported
-* @returns
-*/
-const resolveAndApplyConfig = (imported) => {
-	const config = imported?.default ?? imported;
-	if (!config || typeof config !== "object") return;
-	const runtimeClient = config.client ?? config.prisma;
-	configureArkormRuntime(runtimeClient, {
-		client: runtimeClient,
-		adapter: config.adapter,
-		boot: config.boot,
-		debug: config.debug,
-		naming: config.naming,
-		features: config.features,
-		pagination: config.pagination,
-		paths: config.paths,
-		outputExt: config.outputExt
-	});
-	runtimeConfigLoaded = true;
-};
-/**
-* Dynamically import a configuration file.
-* A cache-busting query parameter is appended to ensure the latest version is loaded.
-*
-* @param configPath
-* @returns A promise that resolves to the imported configuration module.
-*/
-const importConfigFile = (configPath) => {
-	return RuntimeModuleLoader.load(configPath);
-};
-const loadRuntimeConfigSync = () => {
-	const require = (0, module$1.createRequire)(require("url").pathToFileURL(__filename).href);
-	const syncConfigPaths = [path.default.join(process.cwd(), "arkormx.config.cjs")];
-	for (const configPath of syncConfigPaths) {
-		if (!(0, fs.existsSync)(configPath)) continue;
+	/**
+	* Collects unique values from an array of database rows based on a specified key, which
+	* is used to extract the value from each row.
+	*
+	* @param rows  An array of database rows.
+	* @param key   The key to extract values from each row.
+	* @returns     An array of unique values.
+	*/
+	collectUniqueRowValues(rows, key) {
+		const seen = /* @__PURE__ */ new Set();
+		const values = [];
+		rows.forEach((row) => {
+			const value = row[key];
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (seen.has(lookupKey)) return;
+			seen.add(lookupKey);
+			values.push(value);
+		});
+		return values;
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	*
+	* @returns
+	*/
+	createRelationTableLoader() {
+		return new RelationTableLoader(this.resolveAdapter());
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	*
+	* @returns
+	*/
+	resolveAdapter() {
+		const adapter = this.models[0].constructor.getAdapter?.();
+		if (!adapter) throw new Error("Set-based eager loading requires a configured adapter.");
+		return adapter;
+	}
+	/**
+	* Reads an attribute value from a model using the getAttribute method, which is used
+	* to access model attributes in a way that is compatible with Arkorm's internal model structure.
+	*
+	* @param model The model to read the attribute from.
+	* @param key The name of the attribute to read.
+	* @returns
+	*/
+	readModelAttribute(model, key) {
+		const readable = model;
+		const value = readable.getAttribute?.(key);
+		if (value !== void 0) return value;
 		try {
-			resolveAndApplyConfig(require(configPath));
-			return true;
+			const attribute = Object.entries(readable.constructor?.getColumnMap?.() ?? {}).find(([, column]) => column === key)?.[0];
+			return attribute ? readable.getAttribute?.(attribute) : value;
 		} catch {
-			continue;
+			return value;
 		}
 	}
-	return false;
-};
-/**
-* Load the ArkORM configuration by searching for configuration files in the
-* current working directory.
-* @returns
-*/
-const loadArkormConfig = async () => {
-	if (runtimeConfigLoaded) {
-		await awaitConfiguredModelsRegistration();
-		return;
+	/**
+	* Resolves the default result for a relationship when no related models are found.
+	*
+	* @param resolver
+	* @param model
+	* @returns
+	*/
+	resolveSingleDefault(resolver, model) {
+		return resolver.call(model).resolveDefaultResult?.() ?? null;
 	}
-	if (runtimeConfigLoadingPromise) return await runtimeConfigLoadingPromise;
-	if (loadRuntimeConfigSync()) {
-		await awaitConfiguredModelsRegistration();
-		return;
+	/**
+	* Generates a unique lookup key for a given value, which is used to store and retrieve
+	* values in maps during the eager loading process.
+	*
+	* @param value     The value to generate a lookup key for.
+	* @returns         A unique string representing the value.
+	*/
+	toLookupKey(value) {
+		if (value instanceof Date) return `date:${value.toISOString()}`;
+		return `${typeof value}:${String(value)}`;
 	}
-	runtimeConfigLoadingPromise = (async () => {
-		const configPaths = [path.default.join(process.cwd(), "arkormx.config.js"), path.default.join(process.cwd(), "arkormx.config.ts")];
-		for (const configPath of configPaths) {
-			if (!(0, fs.existsSync)(configPath)) continue;
-			try {
-				resolveAndApplyConfig(await importConfigFile(configPath));
-				await awaitConfiguredModelsRegistration();
-				return;
-			} catch {
-				continue;
-			}
-		}
-		runtimeConfigLoaded = true;
-		await scheduleConfiguredModelRegistration();
-		await awaitConfiguredModelsRegistration();
-	})();
-	await runtimeConfigLoadingPromise;
-};
-/**
-* Ensure that the ArkORM configuration is loaded.
-* This function can be called to trigger the loading process if it hasn't already been initiated.
-* If the configuration is already loaded, it will return immediately.
-*
-* @returns
-*/
-const ensureArkormConfigLoading = () => {
-	if (runtimeConfigLoaded) return;
-	if (!runtimeConfigLoadingPromise) loadArkormConfig();
-};
-const getDefaultStubsPath = () => {
-	return resolveDefaultStubsPath();
-};
-/**
-* Get the runtime compatibility client.
-* This function will trigger the loading of the ArkORM configuration if
-* it hasn't already been loaded.
-*
-* @returns
-*/
-const getRuntimeClient = () => {
-	const activeTransactionClient = transactionClientStorage.getStore();
-	if (activeTransactionClient) return activeTransactionClient;
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return resolveClient(runtimeClientResolver);
-};
-/**
-* @deprecated Use getRuntimeClient instead.
-*/
-const getRuntimePrismaClient = getRuntimeClient;
-/**
-* Get the currently configured runtime adapter, if any.
-*
-* @returns
-*/
-const getRuntimeAdapter = () => {
-	const activeTransactionAdapter = transactionAdapterStorage.getStore();
-	if (activeTransactionAdapter) return activeTransactionAdapter;
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimeAdapter;
-};
-/**
-* Releases the database resources held by the configured runtime — the adapter's
-* connection pool and/or the configured client. Intended for short-lived
-* processes (the CLI) so the Node event loop drains and the process exits
-* promptly instead of hanging on pool idle timeouts. Teardown failures are
-* swallowed because the process is shutting down anyway.
-*/
-const disposeArkormRuntime = async () => {
-	let adapterDisposed = false;
-	try {
-		if (runtimeAdapter && typeof runtimeAdapter.dispose === "function") {
-			await runtimeAdapter.dispose();
-			adapterDisposed = true;
-		}
-	} catch {}
-	const client = getRuntimeClient();
-	if (!client) return;
-	try {
-		if (typeof client.$disconnect === "function") await client.$disconnect();
-		else if (!adapterDisposed && typeof client.destroy === "function") await client.destroy();
-		else if (!adapterDisposed && typeof client.end === "function") await client.end();
-	} catch {}
-};
-const getActiveTransactionClient = () => {
-	return transactionClientStorage.getStore();
-};
-const getActiveTransactionAdapter = () => {
-	return transactionAdapterStorage.getStore();
-};
-const isTransactionCapableClient = (value) => {
-	if (!value || typeof value !== "object") return false;
-	return typeof value.$transaction === "function";
-};
-const runArkormTransaction = async (callback, options = {}, preferredAdapter) => {
-	const activeTransactionAdapter = transactionAdapterStorage.getStore();
-	const activeTransactionClient = transactionClientStorage.getStore();
-	if (activeTransactionAdapter || activeTransactionClient) return await callback({
-		adapter: activeTransactionAdapter,
-		client: activeTransactionClient
-	});
-	const adapter = preferredAdapter ?? getRuntimeAdapter();
-	if (adapter) return await adapter.transaction(async (transactionAdapter) => {
-		return await transactionAdapterStorage.run(transactionAdapter, async () => {
-			return await callback({
-				adapter: transactionAdapter,
-				client: transactionClientStorage.getStore()
-			});
-		});
-	}, options);
-	const client = getRuntimeClient();
-	if (!client) throw new ArkormException("Cannot start a transaction without a configured runtime client or adapter.", {
-		code: "CLIENT_NOT_CONFIGURED",
-		operation: "transaction"
-	});
-	if (!isTransactionCapableClient(client)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the current adapter.", {
-		code: "TRANSACTION_NOT_SUPPORTED",
-		operation: "transaction"
-	});
-	return await client.$transaction(async (transactionClient) => {
-		return await transactionClientStorage.run(transactionClient, async () => {
-			return await callback({ client: transactionClient });
-		});
-	}, options);
-};
-/**
-* Get the configured pagination URL driver factory from runtime config.
-*
-* @returns
-*/
-const getRuntimePaginationURLDriverFactory = () => {
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimePaginationURLDriverFactory;
-};
-/**
-* Get the configured current-page resolver from runtime config.
-*
-* @returns
-*/
-const getRuntimePaginationCurrentPageResolver = () => {
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimePaginationCurrentPageResolver;
-};
-const getRuntimeDebugHandler = () => {
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimeDebugHandler;
-};
-const emitRuntimeDebugEvent = (event) => {
-	getRuntimeDebugHandler()?.(event);
-};
-/**
-* Check if a given value matches Arkorm's query-schema contract
-* by verifying the presence of common delegate methods.
-*
-* @param value The value to check.
-* @returns True if the value matches the query-schema contract, false otherwise.
-*/
-const isQuerySchemaLike = (value) => {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return [
-		"findMany",
-		"findFirst",
-		"create",
-		"update",
-		"delete",
-		"count"
-	].every((method) => typeof candidate[method] === "function");
 };
-/**
-* @deprecated Use isQuerySchemaLike instead.
-*/
-const isDelegateLike = isQuerySchemaLike;
-loadArkormConfig();
 
 //#endregion
 //#region src/URLDriver.ts
@@ -7893,6 +7909,12 @@ Object.defineProperty(exports, 'resolvePrismaType', {
     return resolvePrismaType;
   }
 });
+Object.defineProperty(exports, 'resolveRegisteredModel', {
+  enumerable: true,
+  get: function () {
+    return resolveRegisteredModel;
+  }
+});
 Object.defineProperty(exports, 'runArkormTransaction', {
   enumerable: true,
   get: function () {