arkormx 2.0.9 → 2.0.11

package/dist/index.cjs

@@ -1,6 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_MorphToManyRelation = require('./MorphToManyRelation-CYo17sC0.cjs');
-require('./relationship/index.cjs');
+const require_relationship = require('./relationship-CG78rqWf.cjs');
 let node_path = require("node:path");
 let module$1 = require("module");
 let fs = require("fs");
@@ -12,8 +11,7 @@ let _h3ravel_shared = require("@h3ravel/shared");
 let _h3ravel_musket = require("@h3ravel/musket");
 
 //#region src/Exceptions/QueryExecutionException.ts
-var QueryExecutionException = class extends require_MorphToManyRelation.ArkormException {
-	inspection;
+var QueryExecutionException = class extends require_relationship.ArkormException {
 	constructor(message = "Database query execution failed.", context = {}) {
 		super(message, {
 			code: "QUERY_EXECUTION_FAILED",
@@ -41,24 +39,28 @@ var QueryExecutionException = class extends require_MorphToManyRelation.ArkormEx
 * @since 2.0.0-next.0
 */
 var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
-	static migrationStateTable = "arkormx_migrations";
-	static migrationRunTable = "arkormx_migration_runs";
-	capabilities = {
-		transactions: true,
-		returning: true,
-		insertMany: true,
-		upsert: true,
-		updateMany: true,
-		deleteMany: true,
-		exists: true,
-		relationLoads: true,
-		relationAggregates: true,
-		relationFilters: true,
-		rawWhere: true
-	};
+	static {
+		this.migrationStateTable = "arkormx_migrations";
+	}
+	static {
+		this.migrationRunTable = "arkormx_migration_runs";
+	}
 	constructor(db, mapping = {}) {
 		this.db = db;
 		this.mapping = mapping;
+		this.capabilities = {
+			transactions: true,
+			returning: true,
+			insertMany: true,
+			upsert: true,
+			updateMany: true,
+			deleteMany: true,
+			exists: true,
+			relationLoads: true,
+			relationAggregates: true,
+			relationFilters: true,
+			rawWhere: true
+		};
 	}
 	quoteIdentifier(value) {
 		return `"${value.replace(/"/g, "\"\"")}"`;
@@ -177,7 +179,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
                 ) as exists
             `.execute(executor)).rows[0]?.exists) continue;
 			const values = column.enumValues ?? [];
-			if (values.length === 0) throw new require_MorphToManyRelation.ArkormException(`Enum column [${column.name}] requires enum values for database-backed migrations.`);
+			if (values.length === 0) throw new require_relationship.ArkormException(`Enum column [${column.name}] requires enum values for database-backed migrations.`);
 			await this.executeRawStatement(`create type ${this.quoteIdentifier(enumName)} as enum (${values.map((value) => this.quoteLiteral(value)).join(", ")})`, executor);
 		}
 	}
@@ -299,7 +301,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	}
 	resolveTable(target) {
 		if (target.table && target.table.trim().length > 0) return this.mapping[target.table] ?? target.table;
-		throw new require_MorphToManyRelation.ArkormException("Kysely adapter requires a concrete target table.", {
+		throw new require_relationship.ArkormException("Kysely adapter requires a concrete target table.", {
 			operation: "adapter.table",
 			model: target.modelName,
 			meta: { target }
@@ -375,7 +377,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	buildRawWhereCondition(condition) {
 		const segments = condition.sql.split("?");
 		const bindings = condition.bindings ?? [];
-		if (segments.length !== bindings.length + 1) throw new require_MorphToManyRelation.ArkormException("Raw where bindings do not match the number of placeholders.");
+		if (segments.length !== bindings.length + 1) throw new require_relationship.ArkormException("Raw where bindings do not match the number of placeholders.");
 		const parts = [];
 		segments.forEach((segment, index) => {
 			if (segment.length > 0) parts.push(kysely.sql.raw(segment));
@@ -418,12 +420,12 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	}
 	buildRelatedTargetFromRelation(target, relation) {
 		const metadata = target.model?.getRelationMetadata(relation);
-		if (!metadata) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException(`Relation [${relation}] could not be resolved for SQL-backed relation execution.`, {
+		if (!metadata) throw new require_relationship.UnsupportedAdapterFeatureException(`Relation [${relation}] could not be resolved for SQL-backed relation execution.`, {
 			operation: "adapter.relation.metadata",
 			model: target.modelName,
 			relation
 		});
-		if (metadata.type !== "hasMany" && metadata.type !== "hasOne" && metadata.type !== "belongsTo" && metadata.type !== "belongsToMany" && metadata.type !== "hasOneThrough" && metadata.type !== "hasManyThrough") throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException(`Relation [${relation}] is not supported for SQL-backed relation execution by the Kysely adapter yet.`, {
+		if (metadata.type !== "hasMany" && metadata.type !== "hasOne" && metadata.type !== "belongsTo" && metadata.type !== "belongsToMany" && metadata.type !== "hasOneThrough" && metadata.type !== "hasManyThrough") throw new require_relationship.UnsupportedAdapterFeatureException(`Relation [${relation}] is not supported for SQL-backed relation execution by the Kysely adapter yet.`, {
 			operation: "adapter.relation.metadata",
 			model: target.modelName,
 			relation,
@@ -644,7 +646,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		};
 	}
 	emitDebugQuery(phase, operation, target, inspection, meta, durationMs, error) {
-		require_MorphToManyRelation.emitRuntimeDebugEvent({
+		require_relationship.emitRuntimeDebugEvent({
 			type: "query",
 			phase,
 			adapter: "kysely",
@@ -657,7 +659,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		});
 	}
 	wrapExecutionError(error, operation, target, inspection, meta) {
-		if (error instanceof require_MorphToManyRelation.ArkormException) return error;
+		if (error instanceof require_relationship.ArkormException) return error;
 		return new QueryExecutionException(`Failed to execute ${operation} query.`, {
 			operation: `adapter.${operation}`,
 			model: target.modelName,
@@ -997,11 +999,11 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	*/
 	async loadRelations(spec) {
 		if (spec.models.length === 0 || spec.relations.length === 0) return;
-		if (spec.models.some((model) => !this.isEagerLoadableModel(model))) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Kysely adapter relation-load execution requires Arkorm model instances.", {
+		if (spec.models.some((model) => !this.isEagerLoadableModel(model))) throw new require_relationship.UnsupportedAdapterFeatureException("Kysely adapter relation-load execution requires Arkorm model instances.", {
 			operation: "adapter.loadRelations",
 			meta: { feature: "relationLoads" }
 		});
-		await new require_MorphToManyRelation.SetBasedEagerLoader(spec.models, this.toEagerLoadMap(spec.relations)).load();
+		await new require_relationship.SetBasedEagerLoader(spec.models, this.toEagerLoadMap(spec.relations)).load();
 	}
 	async introspectModels(options = {}) {
 		const tables = options.tables?.filter(Boolean) ?? [];
@@ -1139,7 +1141,7 @@ const createKyselyAdapter = (db, mapping = {}) => {
 
 //#endregion
 //#region src/Exceptions/MissingDelegateException.ts
-var MissingDelegateException = class extends require_MorphToManyRelation.ArkormException {
+var MissingDelegateException = class extends require_relationship.ArkormException {
 	constructor(message, context = {}) {
 		super(message, {
 			code: "MISSING_DELEGATE",
@@ -1163,7 +1165,7 @@ var MissingDelegateException = class extends require_MorphToManyRelation.ArkormE
 */
 function createPrismaAdapter(prisma) {
 	return Object.entries(prisma).reduce((accumulator, [key, value]) => {
-		if (!require_MorphToManyRelation.isQuerySchemaLike(value)) return accumulator;
+		if (!require_relationship.isQuerySchemaLike(value)) return accumulator;
 		accumulator[key] = value;
 		return accumulator;
 	}, {});
@@ -1208,13 +1210,11 @@ function inferDelegateName(modelName) {
 * @since 2.0.0-next.0
 */
 var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
-	capabilities;
-	delegates;
 	constructor(prisma, mapping = {}) {
 		this.prisma = prisma;
 		this.mapping = mapping;
 		this.delegates = Object.entries(prisma).reduce((accumulator, [key, value]) => {
-			if (!require_MorphToManyRelation.isDelegateLike(value)) return accumulator;
+			if (!require_relationship.isDelegateLike(value)) return accumulator;
 			accumulator[key] = value;
 			return accumulator;
 		}, {});
@@ -1303,7 +1303,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 			if (!nested) return void 0;
 			return { NOT: nested };
 		}
-		throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the Prisma compatibility adapter; use a SQL-backed adapter for raw SQL predicates.", {
+		throw new require_relationship.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the Prisma compatibility adapter; use a SQL-backed adapter for raw SQL predicates.", {
 			operation: "adapter.where",
 			meta: {
 				feature: "rawWhere",
@@ -1322,7 +1322,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 		};
 	}
 	emitDebugQuery(phase, operation, target, meta, durationMs, error, inspection = null) {
-		require_MorphToManyRelation.emitRuntimeDebugEvent({
+		require_relationship.emitRuntimeDebugEvent({
 			type: "query",
 			phase,
 			adapter: "prisma",
@@ -1335,7 +1335,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 		});
 	}
 	wrapExecutionError(error, operation, target, meta) {
-		if (error instanceof require_MorphToManyRelation.ArkormException) return error;
+		if (error instanceof require_relationship.ArkormException) return error;
 		return new QueryExecutionException(`Failed to execute ${operation} query.`, {
 			operation: `adapter.${operation}`,
 			model: target.modelName,
@@ -1622,7 +1622,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 	* @param _spec 
 	*/
 	async loadRelations(_spec) {
-		throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Adapter-owned relation batch loading is intentionally unavailable on the Prisma compatibility adapter; eager loading stays on Arkorm's generic loader for this path.", {
+		throw new require_relationship.UnsupportedAdapterFeatureException("Adapter-owned relation batch loading is intentionally unavailable on the Prisma compatibility adapter; eager loading stays on Arkorm's generic loader for this path.", {
 			operation: "adapter.loadRelations",
 			meta: { feature: "relationLoads" }
 		});
@@ -1636,7 +1636,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 	* @returns 
 	*/
 	async transaction(callback, context = {}) {
-		if (!this.hasTransactionSupport(this.prisma)) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Transactions are not supported by the Prisma compatibility adapter.", {
+		if (!this.hasTransactionSupport(this.prisma)) throw new require_relationship.UnsupportedAdapterFeatureException("Transactions are not supported by the Prisma compatibility adapter.", {
 			operation: "adapter.transaction",
 			meta: { feature: "transactions" }
 		});
@@ -1673,8 +1673,6 @@ const createPrismaCompatibilityAdapter = createPrismaDatabaseAdapter;
 //#endregion
 //#region src/Attribute.ts
 var Attribute = class Attribute {
-	get;
-	set;
 	constructor(options = {}) {
 		this.get = options.get;
 		this.set = options.set;
@@ -1759,18 +1757,11 @@ function resolveCast(definition) {
 * @since 0.1.0
 */
 var CliApp = class {
-	command;
-	config = {};
 	constructor() {
-		this.config = require_MorphToManyRelation.getUserConfig();
+		this.config = {};
+		this.getConfig = require_relationship.getUserConfig;
+		this.config = require_relationship.getUserConfig();
 	}
-	/**
-	* Get the current configuration object or a specific configuration value.
-	*
-	* @param key Optional specific configuration key to retrieve
-	* @returns The entire configuration object or the value of the specified key
-	*/
-	getConfig = require_MorphToManyRelation.getUserConfig;
 	isUsingPrismaAdapter() {
 		return this.getConfig("adapter") instanceof PrismaDatabaseAdapter;
 	}
@@ -1907,7 +1898,7 @@ var CliApp = class {
 	* @returns 
 	*/
 	resolveStubPath(stubName) {
-		return (0, path.join)(this.resolveConfigPath("stubs", require_MorphToManyRelation.getDefaultStubsPath()), stubName);
+		return (0, path.join)(this.resolveConfigPath("stubs", require_relationship.getDefaultStubsPath()), stubName);
 	}
 	/**
 	* Generate a factory file for a given model name.
@@ -1958,7 +1949,7 @@ var CliApp = class {
 	* @returns An object containing the name and path of the generated migration file.
 	*/
 	makeMigration(name) {
-		const generated = require_MorphToManyRelation.generateMigrationFile(name, {
+		const generated = require_relationship.generateMigrationFile(name, {
 			directory: this.resolveConfigPath("migrations", (0, path.join)(process.cwd(), "database", "migrations")),
 			extension: this.resolveOutputExt()
 		});
@@ -2027,13 +2018,13 @@ var CliApp = class {
 		const schemaPath = (0, path.join)(process.cwd(), "prisma", "schema.prisma");
 		if (!(0, fs.existsSync)(schemaPath)) return void 0;
 		const source = (0, fs.readFileSync)(schemaPath, "utf-8");
-		const existingByTable = require_MorphToManyRelation.findModelBlock(source, tableName);
+		const existingByTable = require_relationship.findModelBlock(source, tableName);
 		const existingByName = new RegExp(`model\\s+${modelName}\\s*\\{`, "m").test(source);
 		if (existingByTable || existingByName) return {
 			path: schemaPath,
 			updated: false
 		};
-		(0, fs.writeFileSync)(schemaPath, require_MorphToManyRelation.applyCreateTableOperation(source, {
+		(0, fs.writeFileSync)(schemaPath, require_relationship.applyCreateTableOperation(source, {
 			type: "createTable",
 			table: tableName,
 			columns: [{
@@ -2285,8 +2276,8 @@ var CliApp = class {
 		};
 	}
 	applyPersistedFieldMetadata(structure) {
-		const persistedMetadata = require_MorphToManyRelation.getPersistedTableMetadata(structure.table, {
-			features: require_MorphToManyRelation.resolvePersistedMetadataFeatures(this.getConfig("features")),
+		const persistedMetadata = require_relationship.getPersistedTableMetadata(structure.table, {
+			features: require_relationship.resolvePersistedMetadataFeatures(this.getConfig("features")),
 			strict: true
 		});
 		if (Object.keys(persistedMetadata.columns).length === 0 && Object.keys(persistedMetadata.enums).length === 0) return structure;
@@ -2303,7 +2294,7 @@ var CliApp = class {
 					...field,
 					name: logicalName
 				};
-				const enumType = require_MorphToManyRelation.getPersistedEnumTsType(enumValues);
+				const enumType = require_relationship.getPersistedEnumTsType(enumValues);
 				const isArray = /^Array<.+>$/.test(field.type);
 				return {
 					...field,
@@ -2321,7 +2312,7 @@ var CliApp = class {
 	*/
 	parsePrismaEnums(schema) {
 		const enums = /* @__PURE__ */ new Map();
-		for (const match of schema.matchAll(require_MorphToManyRelation.PRISMA_ENUM_REGEX)) {
+		for (const match of schema.matchAll(require_relationship.PRISMA_ENUM_REGEX)) {
 			const enumName = match[1];
 			const values = match[0].split("\n").slice(1, -1).map((line) => line.trim()).filter((line) => Boolean(line) && !line.startsWith("//")).map((line) => {
 				return line.match(/^([A-Za-z][A-Za-z0-9_]*)\b/)?.[1];
@@ -2537,18 +2528,21 @@ var CliApp = class {
 * @since 0.1.0
 */
 var InitCommand = class extends _h3ravel_musket.Command {
-	signature = `init
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `init
         {--force : Force overwrite if config file already exists (existing file will be backed up) }
     `;
-	description = "Initialize Arkormˣ by creating a default config file in the current directory";
+		this.description = "Initialize Arkormˣ by creating a default config file in the current directory";
+	}
 	/**
 	* Command handler for the init command.
 	*/
 	async handle() {
 		this.app.command = this;
 		const outputDir = (0, node_path.join)(process.cwd(), "arkormx.config.js");
-		const { stubs } = require_MorphToManyRelation.getUserConfig("paths") ?? {};
-		const stubsDir = typeof stubs === "string" && stubs.trim().length > 0 ? stubs : require_MorphToManyRelation.getDefaultStubsPath();
+		const { stubs } = require_relationship.getUserConfig("paths") ?? {};
+		const stubsDir = typeof stubs === "string" && stubs.trim().length > 0 ? stubs : require_relationship.getDefaultStubsPath();
 		const preferredStubPath = (0, node_path.join)(stubsDir, "arkormx.config.stub");
 		const legacyStubPath = (0, node_path.join)(stubsDir, "arkorm.config.stub");
 		const stubPath = (0, fs.existsSync)(preferredStubPath) ? preferredStubPath : legacyStubPath;
@@ -2576,11 +2570,14 @@ var InitCommand = class extends _h3ravel_musket.Command {
 * @since 0.1.0
 */
 var MakeFactoryCommand = class extends _h3ravel_musket.Command {
-	signature = `make:factory
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `make:factory
         {name : Name of the factory to create}
         {--f|force : Overwrite existing file}
     `;
-	description = "Create a new model factory class";
+		this.description = "Create a new model factory class";
+	}
 	/**
 	* Command handler for the make:factory command.
 	* 
@@ -2604,10 +2601,13 @@ var MakeFactoryCommand = class extends _h3ravel_musket.Command {
 * @since 0.1.0
 */
 var MakeMigrationCommand = class extends _h3ravel_musket.Command {
-	signature = `make:migration
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `make:migration
         {name : Name of the migration to create}
     `;
-	description = "Create a new migration class file";
+		this.description = "Create a new migration class file";
+	}
 	/**
 	* Command handler for the make:migration command.
 	* 
@@ -2632,7 +2632,9 @@ var MakeMigrationCommand = class extends _h3ravel_musket.Command {
 * @since 0.1.0
 */
 var MakeModelCommand = class extends _h3ravel_musket.Command {
-	signature = `make:model
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `make:model
         {name : Name of the model to create}
         {--f|force : Overwrite existing files}
         {--factory : Create and link a factory}
@@ -2641,7 +2643,8 @@ var MakeModelCommand = class extends _h3ravel_musket.Command {
         {--p|pivot : Indicate the required model is an intermediate pivot model}
         {--all : Create and link factory, seeder, and migration}
     `;
-	description = "Create a new model and optional linked resources";
+		this.description = "Create a new model and optional linked resources";
+	}
 	/**
 	* Command handler for the make:model command.
 	* 
@@ -2671,11 +2674,14 @@ var MakeModelCommand = class extends _h3ravel_musket.Command {
 * @since 0.1.0
 */
 var MakeSeederCommand = class extends _h3ravel_musket.Command {
-	signature = `make:seeder
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `make:seeder
         {name : Name of the seeder to create}
         {--f|force : Overwrite existing file}
     `;
-	description = "Create a new seeder class";
+		this.description = "Create a new seeder class";
+	}
 	/**
 	* Command handler for the make:seeder command.
 	*/
@@ -2700,7 +2706,9 @@ const MIGRATION_BRAND = Symbol.for("arkormx.migration");
 * @since 0.1.0
 */
 var Migration = class {
-	static [MIGRATION_BRAND] = true;
+	static {
+		this[MIGRATION_BRAND] = true;
+	}
 };
 
 //#endregion
@@ -2713,7 +2721,9 @@ var Migration = class {
 * @since 0.1.0
 */
 var MigrateCommand = class extends _h3ravel_musket.Command {
-	signature = `migrate
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `migrate
         {name? : Migration class or file name}
         {--all : Run all migrations from the configured migrations directory}
         {--deploy : Use prisma migrate deploy instead of migrate dev}
@@ -2723,7 +2733,8 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
         {--schema= : Explicit prisma schema path}
         {--migration-name= : Name for prisma migrate dev}
     `;
-	description = "Apply migration classes to schema.prisma and run Prisma workflow";
+		this.description = "Apply migration classes to schema.prisma and run Prisma workflow";
+	}
 	/**
 	* Command handler for the migrate command.
 	* This method is responsible for orchestrating the migration 
@@ -2741,20 +2752,20 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 		const schemaPath = this.option("schema") ? (0, node_path.resolve)(String(this.option("schema"))) : (0, node_path.join)(process.cwd(), "prisma", "schema.prisma");
 		const classes = this.option("all") || !this.argument("name") ? await this.loadAllMigrations(migrationsDir) : (await this.loadNamedMigration(migrationsDir, this.argument("name"))).filter(([cls]) => cls !== void 0);
 		if (classes.length === 0) return void this.error("Error: No migration classes found to run.");
-		const stateFilePath = require_MorphToManyRelation.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
-		let appliedState = await require_MorphToManyRelation.readAppliedMigrationsStateFromStore(this.app.getConfig("adapter"), stateFilePath);
+		const stateFilePath = require_relationship.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		let appliedState = await require_relationship.readAppliedMigrationsStateFromStore(this.app.getConfig("adapter"), stateFilePath);
 		const adapter = this.app.getConfig("adapter");
-		const useDatabaseMigrations = require_MorphToManyRelation.supportsDatabaseMigrationExecution(adapter);
-		const persistedFeatures = require_MorphToManyRelation.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
+		const useDatabaseMigrations = require_relationship.supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = require_relationship.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
 		const skipped = [];
 		const changed = [];
 		const pending = classes.filter(([migrationClass, file]) => {
 			if (!appliedState) return true;
-			const identity = require_MorphToManyRelation.buildMigrationIdentity(file, migrationClass.name);
-			const checksum = require_MorphToManyRelation.computeMigrationChecksum(file);
-			const alreadyApplied = require_MorphToManyRelation.isMigrationApplied(appliedState, identity, checksum);
+			const identity = require_relationship.buildMigrationIdentity(file, migrationClass.name);
+			const checksum = require_relationship.computeMigrationChecksum(file);
+			const alreadyApplied = require_relationship.isMigrationApplied(appliedState, identity, checksum);
 			if (alreadyApplied) skipped.push([migrationClass, file]);
-			else if (require_MorphToManyRelation.findAppliedMigration(appliedState, identity)) changed.push([migrationClass, file]);
+			else if (require_relationship.findAppliedMigration(appliedState, identity)) changed.push([migrationClass, file]);
 			return !alreadyApplied;
 		});
 		skipped.forEach(([migrationClass, file]) => {
@@ -2765,7 +2776,7 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 		});
 		if (pending.length === 0) {
 			if (appliedState) try {
-				await require_MorphToManyRelation.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
+				await require_relationship.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
 			} catch (error) {
 				this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 				return;
@@ -2774,17 +2785,17 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 			return;
 		}
 		if (useDatabaseMigrations) try {
-			await require_MorphToManyRelation.validatePersistedMetadataFeaturesForMigrations(pending, persistedFeatures);
+			await require_relationship.validatePersistedMetadataFeaturesForMigrations(pending, persistedFeatures);
 		} catch (error) {
 			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 			return;
 		}
 		for (const [MigrationClassItem] of pending) {
 			if (useDatabaseMigrations) {
-				await require_MorphToManyRelation.applyMigrationToDatabase(adapter, MigrationClassItem);
+				await require_relationship.applyMigrationToDatabase(adapter, MigrationClassItem);
 				continue;
 			}
-			await require_MorphToManyRelation.applyMigrationToPrismaSchema(MigrationClassItem, {
+			await require_relationship.applyMigrationToPrismaSchema(MigrationClassItem, {
 				schemaPath,
 				write: true
 			});
@@ -2792,32 +2803,32 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 		if (appliedState) {
 			const runAppliedIds = [];
 			for (const [migrationClass, file] of pending) {
-				const identity = require_MorphToManyRelation.buildMigrationIdentity(file, migrationClass.name);
-				appliedState = require_MorphToManyRelation.markMigrationApplied(appliedState, {
+				const identity = require_relationship.buildMigrationIdentity(file, migrationClass.name);
+				appliedState = require_relationship.markMigrationApplied(appliedState, {
 					id: identity,
 					file,
 					className: migrationClass.name,
 					appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					checksum: require_MorphToManyRelation.computeMigrationChecksum(file)
+					checksum: require_relationship.computeMigrationChecksum(file)
 				});
 				runAppliedIds.push(identity);
 			}
-			appliedState = require_MorphToManyRelation.markMigrationRun(appliedState, {
-				id: require_MorphToManyRelation.buildMigrationRunId(),
+			appliedState = require_relationship.markMigrationRun(appliedState, {
+				id: require_relationship.buildMigrationRunId(),
 				appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				migrationIds: runAppliedIds
 			});
-			await require_MorphToManyRelation.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+			await require_relationship.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
 			try {
-				await require_MorphToManyRelation.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
+				await require_relationship.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
 			} catch (error) {
 				this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 				return;
 			}
 		}
-		if (!useDatabaseMigrations && !this.option("skip-generate")) require_MorphToManyRelation.runPrismaCommand(["generate"], process.cwd());
-		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) require_MorphToManyRelation.runPrismaCommand(["migrate", "deploy"], process.cwd());
-		else require_MorphToManyRelation.runPrismaCommand([
+		if (!useDatabaseMigrations && !this.option("skip-generate")) require_relationship.runPrismaCommand(["generate"], process.cwd());
+		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) require_relationship.runPrismaCommand(["migrate", "deploy"], process.cwd());
+		else require_relationship.runPrismaCommand([
 			"migrate",
 			"dev",
 			"--name",
@@ -2866,7 +2877,7 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 	* @returns 
 	*/
 	async loadMigrationClassesFromFile(filePath) {
-		const imported = await require_MorphToManyRelation.RuntimeModuleLoader.load(filePath);
+		const imported = await require_relationship.RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -2879,76 +2890,79 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 //#endregion
 //#region src/cli/commands/MigrateFreshCommand.ts
 var MigrateFreshCommand = class extends _h3ravel_musket.Command {
-	signature = `migrate:fresh
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `migrate:fresh
         {--skip-generate : Skip prisma generate}
         {--skip-migrate : Skip prisma database sync}
         {--state-file= : Path to applied migration state file}
         {--schema= : Explicit prisma schema path}
     `;
-	description = "Reset the database and rerun all migration classes";
+		this.description = "Reset the database and rerun all migration classes";
+	}
 	async handle() {
 		this.app.command = this;
 		const configuredMigrationsDir = this.app.getConfig("paths")?.migrations ?? (0, node_path.join)(process.cwd(), "database", "migrations");
 		const migrationsDir = this.app.resolveRuntimeDirectoryPath(configuredMigrationsDir);
 		if (!(0, node_fs.existsSync)(migrationsDir)) return void this.error(`Error: Migrations directory not found: ${this.app.formatPathForLog(configuredMigrationsDir)}`);
 		const adapter = this.app.getConfig("adapter");
-		const useDatabaseMigrations = require_MorphToManyRelation.supportsDatabaseMigrationExecution(adapter);
-		const persistedFeatures = require_MorphToManyRelation.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
+		const useDatabaseMigrations = require_relationship.supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = require_relationship.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
 		const schemaPath = this.option("schema") ? (0, node_path.resolve)(String(this.option("schema"))) : (0, node_path.join)(process.cwd(), "prisma", "schema.prisma");
-		const stateFilePath = require_MorphToManyRelation.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		const stateFilePath = require_relationship.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
 		const migrations = await this.loadAllMigrations(migrationsDir);
 		if (migrations.length === 0) return void this.error("Error: No migration classes found to run.");
 		if (useDatabaseMigrations) try {
-			await require_MorphToManyRelation.validatePersistedMetadataFeaturesForMigrations(migrations, persistedFeatures);
+			await require_relationship.validatePersistedMetadataFeaturesForMigrations(migrations, persistedFeatures);
 		} catch (error) {
 			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 			return;
 		}
 		if (useDatabaseMigrations) {
-			if (!require_MorphToManyRelation.supportsDatabaseReset(adapter)) {
+			if (!require_relationship.supportsDatabaseReset(adapter)) {
 				this.error("Error: Your current database adapter does not support database reset.");
 				return;
 			}
 			await adapter.resetDatabase();
 		} else {
 			if (!(0, node_fs.existsSync)(schemaPath)) return void this.error(`Error: Prisma schema file not found: ${this.app.formatPathForLog(schemaPath)}`);
-			(0, node_fs.writeFileSync)(schemaPath, require_MorphToManyRelation.stripPrismaSchemaModelsAndEnums((0, node_fs.readFileSync)(schemaPath, "utf-8")));
+			(0, node_fs.writeFileSync)(schemaPath, require_relationship.stripPrismaSchemaModelsAndEnums((0, node_fs.readFileSync)(schemaPath, "utf-8")));
 		}
-		let appliedState = require_MorphToManyRelation.createEmptyAppliedMigrationsState();
-		await require_MorphToManyRelation.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		let appliedState = require_relationship.createEmptyAppliedMigrationsState();
+		await require_relationship.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
 		for (const [MigrationClassItem] of migrations) {
 			if (useDatabaseMigrations) {
-				await require_MorphToManyRelation.applyMigrationToDatabase(adapter, MigrationClassItem);
+				await require_relationship.applyMigrationToDatabase(adapter, MigrationClassItem);
 				continue;
 			}
-			await require_MorphToManyRelation.applyMigrationToPrismaSchema(MigrationClassItem, {
+			await require_relationship.applyMigrationToPrismaSchema(MigrationClassItem, {
 				schemaPath,
 				write: true
 			});
 		}
-		for (const [migrationClass, file] of migrations) appliedState = require_MorphToManyRelation.markMigrationApplied(appliedState, {
-			id: require_MorphToManyRelation.buildMigrationIdentity(file, migrationClass.name),
+		for (const [migrationClass, file] of migrations) appliedState = require_relationship.markMigrationApplied(appliedState, {
+			id: require_relationship.buildMigrationIdentity(file, migrationClass.name),
 			file,
 			className: migrationClass.name,
 			appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			checksum: require_MorphToManyRelation.computeMigrationChecksum(file)
+			checksum: require_relationship.computeMigrationChecksum(file)
 		});
-		appliedState = require_MorphToManyRelation.markMigrationRun(appliedState, {
-			id: require_MorphToManyRelation.buildMigrationRunId(),
+		appliedState = require_relationship.markMigrationRun(appliedState, {
+			id: require_relationship.buildMigrationRunId(),
 			appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
 			migrationIds: appliedState.migrations.map((migration) => migration.id)
 		});
-		await require_MorphToManyRelation.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		await require_relationship.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
 		try {
-			await require_MorphToManyRelation.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, migrations, persistedFeatures);
+			await require_relationship.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, migrations, persistedFeatures);
 		} catch (error) {
 			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 			return;
 		}
 		if (!useDatabaseMigrations) {
 			const schemaArgs = this.option("schema") ? ["--schema", schemaPath] : [];
-			if (!this.option("skip-generate")) require_MorphToManyRelation.runPrismaCommand(["generate", ...schemaArgs], process.cwd());
-			if (!this.option("skip-migrate")) require_MorphToManyRelation.runPrismaCommand([
+			if (!this.option("skip-generate")) require_relationship.runPrismaCommand(["generate", ...schemaArgs], process.cwd());
+			if (!this.option("skip-migrate")) require_relationship.runPrismaCommand([
 				"db",
 				"push",
 				"--force-reset",
@@ -2963,7 +2977,7 @@ var MigrateFreshCommand = class extends _h3ravel_musket.Command {
 		return (await Promise.all(files.map(async (file) => (await this.loadMigrationClassesFromFile(file)).map((cls) => [cls, file])))).flat();
 	}
 	async loadMigrationClassesFromFile(filePath) {
-		const imported = await require_MorphToManyRelation.RuntimeModuleLoader.load(filePath);
+		const imported = await require_relationship.RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -2983,7 +2997,9 @@ var MigrateFreshCommand = class extends _h3ravel_musket.Command {
 * @since 0.2.4
 */
 var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
-	signature = `migrate:rollback
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `migrate:rollback
         {--step= : Number of latest applied migration classes to rollback}
         {--dry-run : Preview rollback targets without applying changes}
         {--deploy : Use prisma migrate deploy instead of migrate dev}
@@ -2993,23 +3009,24 @@ var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
         {--schema= : Explicit prisma schema path}
         {--migration-name= : Name for prisma migrate dev}
     `;
-	description = "Rollback migration classes from schema.prisma and run Prisma workflow";
+		this.description = "Rollback migration classes from schema.prisma and run Prisma workflow";
+	}
 	async handle() {
 		this.app.command = this;
 		const configuredMigrationsDir = this.app.getConfig("paths")?.migrations ?? (0, node_path.join)(process.cwd(), "database", "migrations");
 		const migrationsDir = this.app.resolveRuntimeDirectoryPath(configuredMigrationsDir);
 		if (!(0, node_fs.existsSync)(migrationsDir)) return void this.error(`Error: Migrations directory not found: ${this.app.formatPathForLog(configuredMigrationsDir)}`);
 		const schemaPath = this.option("schema") ? (0, node_path.resolve)(String(this.option("schema"))) : (0, node_path.join)(process.cwd(), "prisma", "schema.prisma");
-		const stateFilePath = require_MorphToManyRelation.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		const stateFilePath = require_relationship.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
 		const adapter = this.app.getConfig("adapter");
-		const useDatabaseMigrations = require_MorphToManyRelation.supportsDatabaseMigrationExecution(adapter);
-		const persistedFeatures = require_MorphToManyRelation.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
-		let appliedState = await require_MorphToManyRelation.readAppliedMigrationsStateFromStore(adapter, stateFilePath);
+		const useDatabaseMigrations = require_relationship.supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = require_relationship.resolvePersistedMetadataFeatures(this.app.getConfig("features"));
+		let appliedState = await require_relationship.readAppliedMigrationsStateFromStore(adapter, stateFilePath);
 		const stepOption = this.option("step");
 		const stepCount = stepOption == null ? void 0 : Number(stepOption);
 		if (stepCount != null && (!Number.isFinite(stepCount) || stepCount <= 0 || !Number.isInteger(stepCount))) return void this.error("Error: --step must be a positive integer.");
-		const targets = stepCount ? require_MorphToManyRelation.getLatestAppliedMigrations(appliedState, stepCount) : (() => {
-			const lastRun = require_MorphToManyRelation.getLastMigrationRun(appliedState);
+		const targets = stepCount ? require_relationship.getLatestAppliedMigrations(appliedState, stepCount) : (() => {
+			const lastRun = require_relationship.getLastMigrationRun(appliedState);
 			if (!lastRun) return [];
 			return lastRun.migrationIds.map((id) => appliedState.migrations.find((migration) => migration.id === id)).filter((migration) => Boolean(migration));
 		})();
@@ -3017,7 +3034,7 @@ var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
 		const available = await this.loadAllMigrations(migrationsDir);
 		const rollbackClasses = targets.map((target) => {
 			return available.find(([migrationClass, file]) => {
-				return require_MorphToManyRelation.buildMigrationIdentity(file, migrationClass.name) === target.id || migrationClass.name === target.className;
+				return require_relationship.buildMigrationIdentity(file, migrationClass.name) === target.id || migrationClass.name === target.className;
 			});
 		}).filter((entry) => Boolean(entry));
 		if (rollbackClasses.length === 0) return void this.error("Error: Unable to resolve rollback migration classes from tracked history.");
@@ -3028,28 +3045,28 @@ var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
 		}
 		for (const [MigrationClassItem] of rollbackClasses) {
 			if (useDatabaseMigrations) {
-				await require_MorphToManyRelation.applyMigrationRollbackToDatabase(adapter, MigrationClassItem);
+				await require_relationship.applyMigrationRollbackToDatabase(adapter, MigrationClassItem);
 				continue;
 			}
-			await require_MorphToManyRelation.applyMigrationRollbackToPrismaSchema(MigrationClassItem, {
+			await require_relationship.applyMigrationRollbackToPrismaSchema(MigrationClassItem, {
 				schemaPath,
 				write: true
 			});
 		}
 		for (const [migrationClass, file] of rollbackClasses) {
-			const identity = require_MorphToManyRelation.buildMigrationIdentity(file, migrationClass.name);
-			appliedState = require_MorphToManyRelation.removeAppliedMigration(appliedState, identity);
+			const identity = require_relationship.buildMigrationIdentity(file, migrationClass.name);
+			appliedState = require_relationship.removeAppliedMigration(appliedState, identity);
 		}
-		await require_MorphToManyRelation.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		await require_relationship.writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
 		try {
-			await require_MorphToManyRelation.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, available, persistedFeatures);
+			await require_relationship.syncPersistedColumnMappingsFromState(process.cwd(), appliedState, available, persistedFeatures);
 		} catch (error) {
 			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 			return;
 		}
-		if (!useDatabaseMigrations && !this.option("skip-generate")) require_MorphToManyRelation.runPrismaCommand(["generate"], process.cwd());
-		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) require_MorphToManyRelation.runPrismaCommand(["migrate", "deploy"], process.cwd());
-		else require_MorphToManyRelation.runPrismaCommand([
+		if (!useDatabaseMigrations && !this.option("skip-generate")) require_relationship.runPrismaCommand(["generate"], process.cwd());
+		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) require_relationship.runPrismaCommand(["migrate", "deploy"], process.cwd());
+		else require_relationship.runPrismaCommand([
 			"migrate",
 			"dev",
 			"--name",
@@ -3063,7 +3080,7 @@ var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
 		return (await Promise.all(files.map(async (file) => (await this.loadMigrationClassesFromFile(file)).map((cls) => [cls, file])))).flat();
 	}
 	async loadMigrationClassesFromFile(filePath) {
-		const imported = await require_MorphToManyRelation.RuntimeModuleLoader.load(filePath);
+		const imported = await require_relationship.RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -3082,22 +3099,25 @@ var MigrateRollbackCommand = class extends _h3ravel_musket.Command {
 * @since 0.2.4
 */
 var MigrationHistoryCommand = class extends _h3ravel_musket.Command {
-	signature = `migrate:history
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `migrate:history
         {--state-file= : Path to applied migration state file}
         {--reset : Clear tracked migration history file}
         {--delete : Delete tracked migration history file}
         {--json : Print raw JSON output}
     `;
-	description = "Inspect or reset tracked migration history";
+		this.description = "Inspect or reset tracked migration history";
+	}
 	async handle() {
 		this.app.command = this;
-		const stateFilePath = require_MorphToManyRelation.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		const stateFilePath = require_relationship.resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
 		const adapter = this.app.getConfig("adapter");
-		const usesDatabaseState = require_MorphToManyRelation.supportsDatabaseMigrationState(adapter);
+		const usesDatabaseState = require_relationship.supportsDatabaseMigrationState(adapter);
 		if (this.option("delete")) {
 			if (usesDatabaseState) {
-				await adapter.writeAppliedMigrationsState(require_MorphToManyRelation.createEmptyAppliedMigrationsState());
-				require_MorphToManyRelation.deletePersistedColumnMappingsState(require_MorphToManyRelation.resolveColumnMappingsFilePath(process.cwd()));
+				await adapter.writeAppliedMigrationsState(require_relationship.createEmptyAppliedMigrationsState());
+				require_relationship.deletePersistedColumnMappingsState(require_relationship.resolveColumnMappingsFilePath(process.cwd()));
 				this.success("Deleted tracked migration state from database.");
 				return;
 			}
@@ -3106,17 +3126,17 @@ var MigrationHistoryCommand = class extends _h3ravel_musket.Command {
 				return;
 			}
 			(0, node_fs.rmSync)(stateFilePath);
-			require_MorphToManyRelation.deletePersistedColumnMappingsState(require_MorphToManyRelation.resolveColumnMappingsFilePath(process.cwd()));
+			require_relationship.deletePersistedColumnMappingsState(require_relationship.resolveColumnMappingsFilePath(process.cwd()));
 			this.success(`Deleted migration state file: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
 		if (this.option("reset")) {
-			await require_MorphToManyRelation.writeAppliedMigrationsStateToStore(adapter, stateFilePath, require_MorphToManyRelation.createEmptyAppliedMigrationsState());
-			require_MorphToManyRelation.deletePersistedColumnMappingsState(require_MorphToManyRelation.resolveColumnMappingsFilePath(process.cwd()));
+			await require_relationship.writeAppliedMigrationsStateToStore(adapter, stateFilePath, require_relationship.createEmptyAppliedMigrationsState());
+			require_relationship.deletePersistedColumnMappingsState(require_relationship.resolveColumnMappingsFilePath(process.cwd()));
 			this.success(usesDatabaseState ? "Reset migration state in database." : `Reset migration state: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
-		const state = await require_MorphToManyRelation.readAppliedMigrationsStateFromStore(adapter, stateFilePath);
+		const state = await require_relationship.readAppliedMigrationsStateFromStore(adapter, stateFilePath);
 		if (this.option("json")) {
 			this.success(JSON.stringify({
 				path: usesDatabaseState ? "database" : stateFilePath,
@@ -3139,11 +3159,14 @@ var MigrationHistoryCommand = class extends _h3ravel_musket.Command {
 //#endregion
 //#region src/cli/commands/ModelsSyncCommand.ts
 var ModelsSyncCommand = class extends _h3ravel_musket.Command {
-	signature = `models:sync
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `models:sync
         {--schema= : Path to prisma schema file used when adapter introspection is unavailable}
         {--models= : Path to models directory}
     `;
-	description = "Sync model declare attributes from the active adapter when supported";
+		this.description = "Sync model declare attributes from the active adapter when supported";
+	}
 	async handle() {
 		this.app.command = this;
 		let result;
@@ -3180,7 +3203,9 @@ const SEEDER_BRAND = Symbol.for("arkormx.seeder");
 * @since 0.1.0
 */
 var Seeder = class Seeder {
-	static [SEEDER_BRAND] = true;
+	static {
+		this[SEEDER_BRAND] = true;
+	}
 	/**
 	* Runs one or more seeders.
 	* 
@@ -3226,11 +3251,14 @@ var Seeder = class Seeder {
 * @since 0.1.0
 */
 var SeedCommand = class extends _h3ravel_musket.Command {
-	signature = `seed
+	constructor(..._args) {
+		super(..._args);
+		this.signature = `seed
         {name? : Seeder class or file name}
         {--all : Run all seeders in the configured seeders directory}
     `;
-	description = "Run one or more seeders";
+		this.description = "Run one or more seeders";
+	}
 	/**
 	* Command handler for the seed command.
 	* 
@@ -3287,7 +3315,7 @@ var SeedCommand = class extends _h3ravel_musket.Command {
 	* @returns An array of seeder classes.
 	*/
 	async loadSeederClassesFromFile(filePath) {
-		const imported = await require_MorphToManyRelation.RuntimeModuleLoader.load(filePath);
+		const imported = await require_relationship.RuntimeModuleLoader.load(filePath);
 		return Object.values(imported).filter((value) => {
 			if (typeof value !== "function") return false;
 			const candidate = value;
@@ -3320,9 +3348,11 @@ var logo_default = String.raw`
 * @since 0.1.0
 */
 var ModelFactory = class {
-	amount = 1;
-	sequence = 0;
-	states = [];
+	constructor() {
+		this.amount = 1;
+		this.sequence = 0;
+		this.states = [];
+	}
 	/**
 	* Set the number of models to create.
 	* 
@@ -3418,7 +3448,6 @@ var ModelFactory = class {
 * @since 0.1.0
 */
 var InlineFactory = class extends ModelFactory {
-	model;
 	constructor(model, resolver) {
 		super();
 		this.resolver = resolver;
@@ -3450,8 +3479,7 @@ const defineFactory = (model, definition) => {
 * @author Legacy (3m1n3nc3)
 * @since 0.1.0
 */
-var ModelNotFoundException = class extends require_MorphToManyRelation.ArkormException {
-	modelName;
+var ModelNotFoundException = class extends require_relationship.ArkormException {
 	constructor(modelName, message = "No query results for the given model.", context = {}) {
 		super(message, {
 			code: "MODEL_NOT_FOUND",
@@ -3468,7 +3496,7 @@ var ModelNotFoundException = class extends require_MorphToManyRelation.ArkormExc
 
 //#endregion
 //#region src/Exceptions/QueryConstraintException.ts
-var QueryConstraintException = class extends require_MorphToManyRelation.ArkormException {
+var QueryConstraintException = class extends require_relationship.ArkormException {
 	constructor(message, context = {}) {
 		super(message, {
 			code: "QUERY_CONSTRAINT",
@@ -3480,7 +3508,7 @@ var QueryConstraintException = class extends require_MorphToManyRelation.ArkormE
 
 //#endregion
 //#region src/Exceptions/ScopeNotDefinedException.ts
-var ScopeNotDefinedException = class extends require_MorphToManyRelation.ArkormException {
+var ScopeNotDefinedException = class extends require_relationship.ArkormException {
 	constructor(message, context = {}) {
 		super(message, {
 			code: "SCOPE_NOT_DEFINED",
@@ -3492,7 +3520,7 @@ var ScopeNotDefinedException = class extends require_MorphToManyRelation.ArkormE
 
 //#endregion
 //#region src/Exceptions/UniqueConstraintResolutionException.ts
-var UniqueConstraintResolutionException = class extends require_MorphToManyRelation.ArkormException {
+var UniqueConstraintResolutionException = class extends require_relationship.ArkormException {
 	constructor(message, context = {}) {
 		super(message, {
 			code: "UNIQUE_CONSTRAINT_RESOLUTION_FAILED",
@@ -3513,19 +3541,6 @@ var UniqueConstraintResolutionException = class extends require_MorphToManyRelat
 * @since 0.1.0
 */
 var QueryBuilder = class QueryBuilder {
-	queryWhere;
-	legacyWhere;
-	queryRelationLoads;
-	queryOrderBy;
-	querySelect;
-	offsetValue;
-	limitValue;
-	eagerLoads = {};
-	includeTrashed = false;
-	onlyTrashedRecords = false;
-	randomOrderEnabled = false;
-	relationFilters = [];
-	relationAggregates = [];
 	/**
 	* Creates a new QueryBuilder instance.
 	* 
@@ -3534,11 +3549,17 @@ var QueryBuilder = class QueryBuilder {
 	constructor(model, adapter) {
 		this.model = model;
 		this.adapter = adapter;
+		this.eagerLoads = {};
+		this.includeTrashed = false;
+		this.onlyTrashedRecords = false;
+		this.randomOrderEnabled = false;
+		this.relationFilters = [];
+		this.relationAggregates = [];
 	}
 	resolvePaginationPage(page, options) {
 		if (typeof page !== "undefined") return Number.isFinite(page) ? Math.max(1, page) : 1;
 		const pageName = options.pageName ?? "page";
-		const resolvedPage = require_MorphToManyRelation.getRuntimePaginationCurrentPageResolver()?.(pageName, options);
+		const resolvedPage = require_relationship.getRuntimePaginationCurrentPageResolver()?.(pageName, options);
 		if (typeof resolvedPage !== "number" || !Number.isFinite(resolvedPage)) return 1;
 		return Math.max(1, resolvedPage);
 	}
@@ -3769,7 +3790,7 @@ var QueryBuilder = class QueryBuilder {
 	}
 	coerceDate(value) {
 		const parsed = value instanceof Date ? new Date(value.getTime()) : new Date(value);
-		if (Number.isNaN(parsed.getTime())) throw new require_MorphToManyRelation.ArkormException("Invalid date value for date-based query helper.");
+		if (Number.isNaN(parsed.getTime())) throw new require_relationship.ArkormException("Invalid date value for date-based query helper.");
 		return parsed;
 	}
 	/**
@@ -3801,7 +3822,7 @@ var QueryBuilder = class QueryBuilder {
 	orderBy(orderBy) {
 		this.randomOrderEnabled = false;
 		const normalized = this.normalizeQueryOrderBy(orderBy);
-		if (!normalized) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Order clauses must use Arkorm-normalizable column directions.", {
+		if (!normalized) throw new require_relationship.UnsupportedAdapterFeatureException("Order clauses must use Arkorm-normalizable column directions.", {
 			operation: "orderBy",
 			model: this.model.name
 		});
@@ -3856,7 +3877,7 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	include(include) {
 		const normalized = this.normalizeRelationLoads(include);
-		if (normalized === null) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Include clauses could not be normalized into Arkorm relation load plans.", {
+		if (normalized === null) throw new require_relationship.UnsupportedAdapterFeatureException("Include clauses could not be normalized into Arkorm relation load plans.", {
 			operation: "include",
 			model: this.model.name,
 			meta: { feature: "relationLoads" }
@@ -4186,7 +4207,7 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	select(select) {
 		const normalized = this.normalizeQuerySelect(select);
-		if (normalized === null) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Select clauses must use Arkorm-normalizable column projections.", {
+		if (normalized === null) throw new require_relationship.UnsupportedAdapterFeatureException("Select clauses must use Arkorm-normalizable column projections.", {
 			operation: "select",
 			model: this.model.name
 		});
@@ -4243,7 +4264,7 @@ var QueryBuilder = class QueryBuilder {
 		if (typeof adapter.inspectQuery !== "function") return null;
 		if (operation === "count") {
 			const spec = this.tryBuildAggregateSpec();
-			if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm aggregate specification.", {
+			if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm aggregate specification.", {
 				operation: "query.inspect",
 				model: this.model.name
 			});
@@ -4253,7 +4274,7 @@ var QueryBuilder = class QueryBuilder {
 			});
 		}
 		const spec = this.tryBuildSelectSpec(this.buildWhere());
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
 			operation: "query.inspect",
 			model: this.model.name
 		});
@@ -4302,7 +4323,7 @@ var QueryBuilder = class QueryBuilder {
 		} else filteredModels = await this.filterModelsByRelationConstraints(models, relationCache);
 		if (this.hasRelationAggregates() && useCompatibilityRelationFallback) await this.applyRelationAggregates(filteredModels, relationCache);
 		await this.eagerLoadModels(filteredModels);
-		return new require_MorphToManyRelation.ArkormCollection(filteredModels);
+		return new require_relationship.ArkormCollection(filteredModels);
 	}
 	/**
 	* Executes the query and returns the first result as a model 
@@ -4383,8 +4404,8 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	async pluck(column, key) {
 		const rows = await this.executeReadRows();
-		if (!key) return new require_MorphToManyRelation.ArkormCollection(rows.map((row) => row[column]));
-		return new require_MorphToManyRelation.ArkormCollection(rows.sort((leftRow, rightRow) => String(leftRow[key]).localeCompare(String(rightRow[key]))).map((row) => row[column]));
+		if (!key) return new require_relationship.ArkormCollection(rows.map((row) => row[column]));
+		return new require_relationship.ArkormCollection(rows.sort((leftRow, rightRow) => String(leftRow[key]).localeCompare(String(rightRow[key]))).map((row) => row[column]));
 	}
 	/**
 	* Creates a new record with the specified data and returns it as a model instance.
@@ -4697,7 +4718,7 @@ var QueryBuilder = class QueryBuilder {
 			const now = /* @__PURE__ */ new Date();
 			const primaryKeyValue = nextPayload[metadata.primaryKey];
 			if (primaryKeyValue === void 0 || primaryKeyValue === null) {
-				const generated = require_MorphToManyRelation.PrimaryKeyGenerationPlanner.generate(metadata.primaryKeyGeneration);
+				const generated = require_relationship.PrimaryKeyGenerationPlanner.generate(metadata.primaryKeyGeneration);
 				if (generated !== void 0) nextPayload[metadata.primaryKey] = generated;
 			}
 			for (const column of metadata.timestampColumns ?? []) {
@@ -4831,7 +4852,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	whereRaw(sql, bindings = []) {
-		if (!this.adapter?.capabilities?.rawWhere) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
+		if (!this.adapter?.capabilities?.rawWhere) throw new require_relationship.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
 			operation: "whereRaw",
 			model: this.model.name,
 			meta: { feature: "rawWhere" }
@@ -4851,7 +4872,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	orWhereRaw(sql, bindings = []) {
-		if (!this.adapter?.capabilities?.rawWhere) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
+		if (!this.adapter?.capabilities?.rawWhere) throw new require_relationship.UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
 			operation: "orWhereRaw",
 			model: this.model.name,
 			meta: { feature: "rawWhere" }
@@ -4878,11 +4899,11 @@ var QueryBuilder = class QueryBuilder {
 			const pageSize = Math.max(1, perPage);
 			const rows = (await this.get()).all();
 			const start = (currentPage - 1) * pageSize;
-			return new require_MorphToManyRelation.LengthAwarePaginator(new require_MorphToManyRelation.ArkormCollection(rows.slice(start, start + pageSize)), rows.length, pageSize, currentPage, options);
+			return new require_relationship.LengthAwarePaginator(new require_relationship.ArkormCollection(rows.slice(start, start + pageSize)), rows.length, pageSize, currentPage, options);
 		}
 		const pageSize = Math.max(1, perPage);
 		const total = await this.count();
-		return new require_MorphToManyRelation.LengthAwarePaginator(await this.clone().skip((currentPage - 1) * pageSize).take(pageSize).get(), total, pageSize, currentPage, options);
+		return new require_relationship.LengthAwarePaginator(await this.clone().skip((currentPage - 1) * pageSize).take(pageSize).get(), total, pageSize, currentPage, options);
 	}
 	/**
 	* Paginates results without calculating total row count.
@@ -4899,12 +4920,12 @@ var QueryBuilder = class QueryBuilder {
 			const start = (currentPage - 1) * pageSize;
 			const pageRows = rows.slice(start, start + pageSize);
 			const hasMorePages = start + pageSize < rows.length;
-			return new require_MorphToManyRelation.Paginator(new require_MorphToManyRelation.ArkormCollection(pageRows), pageSize, currentPage, hasMorePages, options);
+			return new require_relationship.Paginator(new require_relationship.ArkormCollection(pageRows), pageSize, currentPage, hasMorePages, options);
 		}
 		const pageSize = Math.max(1, perPage);
 		const items = await this.clone().skip((currentPage - 1) * pageSize).take(pageSize + 1).get();
 		const hasMorePages = items.all().length > pageSize;
-		return new require_MorphToManyRelation.Paginator(hasMorePages ? new require_MorphToManyRelation.ArkormCollection(items.all().slice(0, pageSize)) : items, pageSize, currentPage, hasMorePages, options);
+		return new require_relationship.Paginator(hasMorePages ? new require_relationship.ArkormCollection(items.all().slice(0, pageSize)) : items, pageSize, currentPage, hasMorePages, options);
 	}
 	/**
 	* Creates a clone of the current query builder instance with the same state.
@@ -5047,7 +5068,7 @@ var QueryBuilder = class QueryBuilder {
 	applyRelationLoadPlan(plan) {
 		if (plan.constraint) {
 			const normalizedWhere = this.toQuerySchemaWhere(plan.constraint);
-			if (!normalizedWhere) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Relation load plan constraints could not be normalized back into query where syntax.", {
+			if (!normalizedWhere) throw new require_relationship.UnsupportedAdapterFeatureException("Relation load plan constraints could not be normalized back into query where syntax.", {
 				operation: "relationLoads.applyPlan",
 				model: this.model.name
 			});
@@ -5135,7 +5156,7 @@ var QueryBuilder = class QueryBuilder {
 			});
 			return;
 		}
-		await new require_MorphToManyRelation.SetBasedEagerLoader(models, this.eagerLoads).load();
+		await new require_relationship.SetBasedEagerLoader(models, this.eagerLoads).load();
 	}
 	normalizeRelationLoadSelect(select) {
 		if (Array.isArray(select) || typeof select !== "object" || !select) return null;
@@ -5404,7 +5425,7 @@ var QueryBuilder = class QueryBuilder {
 		};
 	}
 	requireAdapter() {
-		if (!this.adapter) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query execution requires a configured database adapter.", {
+		if (!this.adapter) throw new require_relationship.UnsupportedAdapterFeatureException("Query execution requires a configured database adapter.", {
 			operation: "query.execute",
 			model: this.model.name,
 			meta: { feature: "adapter" }
@@ -5414,7 +5435,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeReadRows(whereOverride, useWhereOverride = false) {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildSelectSpec(useWhereOverride ? whereOverride : this.buildWhere(), useWhereOverride);
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
 			operation: "query.select",
 			model: this.model.name
 		});
@@ -5423,7 +5444,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeReadRow() {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildSelectSpec(this.buildWhere());
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
 			operation: "query.selectOne",
 			model: this.model.name
 		});
@@ -5432,7 +5453,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeReadCount() {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildAggregateSpec();
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm aggregate specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm aggregate specification.", {
 			operation: "query.count",
 			model: this.model.name
 		});
@@ -5441,7 +5462,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeReadExists() {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildSelectSpec(this.buildWhere());
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
 			operation: "query.exists",
 			model: this.model.name
 		});
@@ -5476,7 +5497,7 @@ var QueryBuilder = class QueryBuilder {
 		const payloads = this.normalizeInsertPayloads(values);
 		const timestampUpdateColumns = (this.model.getModelMetadata().timestampColumns ?? []).filter((column) => column.updatedAt).map((column) => column.column);
 		const normalizedUpdateColumns = updateColumns ? Array.from(new Set([...updateColumns, ...timestampUpdateColumns])) : updateColumns;
-		if (typeof adapter.upsert !== "function") throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Upsert is not supported by the current adapter.", {
+		if (typeof adapter.upsert !== "function") throw new require_relationship.UnsupportedAdapterFeatureException("Upsert is not supported by the current adapter.", {
 			operation: "query.upsert",
 			model: this.model.name
 		});
@@ -5485,7 +5506,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeUpdateRow(where, values) {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildUpdateSpec(where, this.normalizeUpdatePayload(values));
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Update could not be compiled into an Arkorm update specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Update could not be compiled into an Arkorm update specification.", {
 			operation: "query.update",
 			model: this.model.name
 		});
@@ -5497,7 +5518,7 @@ var QueryBuilder = class QueryBuilder {
 		const adapter = this.requireAdapter();
 		const normalizedValues = this.normalizeUpdatePayload(values);
 		const spec = this.tryBuildUpdateManySpec(where, normalizedValues);
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Update-many could not be compiled into an Arkorm update specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Update-many could not be compiled into an Arkorm update specification.", {
 			operation: "query.updateMany",
 			model: this.model.name
 		});
@@ -5521,7 +5542,7 @@ var QueryBuilder = class QueryBuilder {
 	async executeDeleteRow(where, failIfMissing = true) {
 		const adapter = this.requireAdapter();
 		const spec = this.tryBuildDeleteSpec(where);
-		if (!spec) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Delete could not be compiled into an Arkorm delete specification.", {
+		if (!spec) throw new require_relationship.UnsupportedAdapterFeatureException("Delete could not be compiled into an Arkorm delete specification.", {
 			operation: "query.delete",
 			model: this.model.name
 		});
@@ -5635,7 +5656,7 @@ var QueryBuilder = class QueryBuilder {
 		const adapter = this.adapter;
 		const sqlRelationFiltersRejected = this.hasUncompilableSqlRelationFilters(adapter);
 		const sqlRelationAggregatesRejected = this.hasUncompilableSqlRelationAggregates(adapter);
-		if (sqlRelationFiltersRejected || sqlRelationAggregatesRejected) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Relation filters or aggregates could not be compiled into Arkorm adapter specifications for the current query shape.", {
+		if (sqlRelationFiltersRejected || sqlRelationAggregatesRejected) throw new require_relationship.UnsupportedAdapterFeatureException("Relation filters or aggregates could not be compiled into Arkorm adapter specifications for the current query shape.", {
 			operation: "query.relations",
 			model: this.model.name,
 			meta: {
@@ -5802,7 +5823,7 @@ var QueryBuilder = class QueryBuilder {
 		if (cached) return await cached;
 		const resolver = (async () => {
 			const relationMethod = model[relation];
-			if (typeof relationMethod !== "function") throw new require_MorphToManyRelation.RelationResolutionException(`Relation [${relation}] is not defined on the model.`, {
+			if (typeof relationMethod !== "function") throw new require_relationship.RelationResolutionException(`Relation [${relation}] is not defined on the model.`, {
 				operation: "resolveRelatedResults",
 				model: this.model.name,
 				relation
@@ -5813,15 +5834,15 @@ var QueryBuilder = class QueryBuilder {
 			});
 			if (typeof relationInstance.get === "function") {
 				const results = await relationInstance.get();
-				if (results instanceof require_MorphToManyRelation.ArkormCollection) return results.all();
+				if (results instanceof require_relationship.ArkormCollection) return results.all();
 				return results;
 			}
 			if (typeof relationInstance.getResults === "function") {
 				const results = await relationInstance.getResults();
-				if (results instanceof require_MorphToManyRelation.ArkormCollection) return results.all();
+				if (results instanceof require_relationship.ArkormCollection) return results.all();
 				return results;
 			}
-			throw new require_MorphToManyRelation.RelationResolutionException(`Relation [${relation}] does not support result resolution.`, {
+			throw new require_relationship.RelationResolutionException(`Relation [${relation}] does not support result resolution.`, {
 				operation: "resolveRelatedResults",
 				model: this.model.name,
 				relation
@@ -5864,8 +5885,8 @@ const isCompatibilityClient = (value) => {
 	return Boolean(value) && typeof value === "object";
 };
 const getCompatibilitySources = (preferredClient) => {
-	const activeTransactionClient = require_MorphToManyRelation.getActiveTransactionClient();
-	const runtimeClient = require_MorphToManyRelation.getRuntimeClient();
+	const activeTransactionClient = require_relationship.getActiveTransactionClient();
+	const runtimeClient = require_relationship.getRuntimeClient();
 	return activeTransactionClient ? [
 		activeTransactionClient,
 		preferredClient,
@@ -5881,7 +5902,7 @@ const resolveRuntimeCompatibilityQuerySchema = (candidates, preferredClient) =>
 	return getCompatibilitySources(preferredClient).flatMap((source) => {
 		if (!isObjectLike(source)) return [];
 		return candidates.map((candidate) => source[candidate]);
-	}).find((candidate) => require_MorphToManyRelation.isQuerySchemaLike(candidate));
+	}).find((candidate) => require_relationship.isQuerySchemaLike(candidate));
 };
 const resolveRuntimeCompatibilityQuerySchemaOrThrow = (key, candidates, modelName, preferredClient) => {
 	const resolved = resolveRuntimeCompatibilityQuerySchema(candidates, preferredClient);
@@ -5901,8 +5922,6 @@ const defaultSoftDeleteConfig = {
 	column: "deletedAt"
 };
 var DB = class DB {
-	static adapter;
-	scopedAdapter;
 	constructor(adapter) {
 		this.scopedAdapter = adapter;
 	}
@@ -5910,7 +5929,7 @@ var DB = class DB {
 		this.adapter = adapter;
 	}
 	static getAdapter() {
-		const runtimeAdapter = require_MorphToManyRelation.getRuntimeAdapter();
+		const runtimeAdapter = require_relationship.getRuntimeAdapter();
 		if (runtimeAdapter) return runtimeAdapter;
 		if (this.adapter) return this.adapter;
 		return getRuntimeCompatibilityAdapter();
@@ -5929,11 +5948,11 @@ var DB = class DB {
 	}
 	async raw(sql, bindings = []) {
 		const adapter = this.getAdapter();
-		if (!adapter) throw new require_MorphToManyRelation.ArkormException("Raw queries require a configured database adapter.", {
+		if (!adapter) throw new require_relationship.ArkormException("Raw queries require a configured database adapter.", {
 			code: "ADAPTER_NOT_CONFIGURED",
 			operation: "db.raw"
 		});
-		if (!adapter.rawQuery) throw new require_MorphToManyRelation.UnsupportedAdapterFeatureException("Raw queries are not supported by the current adapter.", {
+		if (!adapter.rawQuery) throw new require_relationship.UnsupportedAdapterFeatureException("Raw queries are not supported by the current adapter.", {
 			operation: "db.raw",
 			meta: { feature: "rawQuery" }
 		});
@@ -5941,14 +5960,14 @@ var DB = class DB {
 			sql,
 			bindings
 		});
-		return require_MorphToManyRelation.ArkormCollection.make(rows);
+		return require_relationship.ArkormCollection.make(rows);
 	}
 	static async transaction(callback, context) {
 		return await new DB().transaction(callback, context);
 	}
 	async transaction(callback, context) {
 		const adapter = this.getAdapter();
-		if (!adapter) throw new require_MorphToManyRelation.ArkormException("DB transactions require a configured database adapter.", {
+		if (!adapter) throw new require_relationship.ArkormException("DB transactions require a configured database adapter.", {
 			code: "ADAPTER_NOT_CONFIGURED",
 			operation: "db.transaction"
 		});
@@ -6006,10 +6025,10 @@ var DB = class DB {
 			enums: {}
 		};
 		const persistedMetadataOptions = typeof options.persistedMetadata === "object" ? options.persistedMetadata : {};
-		return require_MorphToManyRelation.getPersistedTableMetadata(table, {
+		return require_relationship.getPersistedTableMetadata(table, {
 			cwd: persistedMetadataOptions.cwd,
 			configuredPath: persistedMetadataOptions.configuredPath,
-			features: require_MorphToManyRelation.resolvePersistedMetadataFeatures(require_MorphToManyRelation.getUserConfig("features")),
+			features: require_relationship.resolvePersistedMetadataFeatures(require_relationship.getUserConfig("features")),
 			strict: persistedMetadataOptions.strict ?? (Boolean(adapter) && !(adapter instanceof PrismaDatabaseAdapter))
 		});
 	}
@@ -6026,37 +6045,41 @@ var DB = class DB {
 * @since 0.1.0
 */
 var Model = class Model {
-	static lifecycleStates = /* @__PURE__ */ new WeakMap();
-	static emittedDeprecationWarnings = /* @__PURE__ */ new Set();
-	static eventsSuppressed = 0;
-	static factoryClass;
-	static adapter;
-	/**
-	* Compatibility-only runtime state retained for 2.x transition window.
-	* New setups should use adapter-first setup via `setAdapter(...)` or runtime config.
-	*/
-	static client;
-	/**
-	* @deprecated Use `table` instead. This remains as a compatibility alias during the transition.
-	*/
-	static delegate;
-	static table;
-	static primaryKey = "id";
-	static columns = {};
-	static softDeletes = false;
-	static deletedAtColumn = "deletedAt";
-	static globalScopes = {};
-	static eventListeners = {};
-	static dispatchesEvents = {};
-	casts = {};
-	hidden = [];
-	visible = [];
-	appends = [];
-	attributes;
-	original;
-	changes;
-	touchedAttributes;
+	static {
+		this.lifecycleStates = /* @__PURE__ */ new WeakMap();
+	}
+	static {
+		this.emittedDeprecationWarnings = /* @__PURE__ */ new Set();
+	}
+	static {
+		this.eventsSuppressed = 0;
+	}
+	static {
+		this.primaryKey = "id";
+	}
+	static {
+		this.columns = {};
+	}
+	static {
+		this.softDeletes = false;
+	}
+	static {
+		this.deletedAtColumn = "deletedAt";
+	}
+	static {
+		this.globalScopes = {};
+	}
+	static {
+		this.eventListeners = {};
+	}
+	static {
+		this.dispatchesEvents = {};
+	}
 	constructor(attributes = {}) {
+		this.casts = {};
+		this.hidden = [];
+		this.visible = [];
+		this.appends = [];
 		this.attributes = {};
 		this.original = {};
 		this.changes = {};
@@ -6106,13 +6129,13 @@ var Model = class Model {
 		this.adapter = adapter;
 	}
 	static getTable() {
-		require_MorphToManyRelation.ensureArkormConfigLoading();
+		require_relationship.ensureArkormConfigLoading();
 		if (this.table) return this.table;
 		if (this.delegate) {
 			Model.emitDeprecationWarning("ARKORM_MODEL_DELEGATE_DEPRECATED", "Model.delegate is deprecated and will be removed in Arkorm 3.0. Use Model.table instead.");
 			return this.delegate;
 		}
-		const modelTableCase = require_MorphToManyRelation.getUserConfig("naming")?.modelTableCase ?? "snake";
+		const modelTableCase = require_relationship.getUserConfig("naming")?.modelTableCase ?? "snake";
 		const modelName = (0, _h3ravel_support.str)(this.name);
 		if (modelTableCase === "camel") return `${modelName.camel().plural()}`;
 		if (modelTableCase === "kebab") return `${modelName.kebab().plural()}`;
@@ -6126,8 +6149,8 @@ var Model = class Model {
 		const adapter = this.getAdapter();
 		const shouldStrictlyValidatePersistedMappings = Boolean(adapter) && !(adapter instanceof PrismaDatabaseAdapter);
 		return {
-			...require_MorphToManyRelation.getPersistedTableMetadata(this.getTable(), {
-				features: require_MorphToManyRelation.resolvePersistedMetadataFeatures(require_MorphToManyRelation.getUserConfig("features")),
+			...require_relationship.getPersistedTableMetadata(this.getTable(), {
+				features: require_relationship.resolvePersistedMetadataFeatures(require_relationship.getUserConfig("features")),
 				strict: shouldStrictlyValidatePersistedMappings
 			}).columns,
 			...this.columns
@@ -6139,8 +6162,8 @@ var Model = class Model {
 	static getModelMetadata() {
 		const adapter = this.getAdapter();
 		const shouldStrictlyValidatePersistedMappings = Boolean(adapter) && !(adapter instanceof PrismaDatabaseAdapter);
-		const persistedMetadata = require_MorphToManyRelation.getPersistedTableMetadata(this.getTable(), {
-			features: require_MorphToManyRelation.resolvePersistedMetadataFeatures(require_MorphToManyRelation.getUserConfig("features")),
+		const persistedMetadata = require_relationship.getPersistedTableMetadata(this.getTable(), {
+			features: require_relationship.resolvePersistedMetadataFeatures(require_relationship.getUserConfig("features")),
 			strict: shouldStrictlyValidatePersistedMappings
 		});
 		return {
@@ -6165,7 +6188,7 @@ var Model = class Model {
 		if (typeof resolver !== "function") return null;
 		const instance = new this({});
 		const relation = resolver.call(instance);
-		if (!(relation instanceof require_MorphToManyRelation.Relation)) return null;
+		if (!(relation instanceof require_relationship.Relation)) return null;
 		return relation.getMetadata();
 	}
 	static setFactory(factoryClass) {
@@ -6173,7 +6196,7 @@ var Model = class Model {
 	}
 	static factory(count) {
 		const factoryClass = this.factoryClass;
-		if (!factoryClass) throw new require_MorphToManyRelation.ArkormException(`Factory is not configured for model [${this.name}].`, {
+		if (!factoryClass) throw new require_relationship.ArkormException(`Factory is not configured for model [${this.name}].`, {
 			code: "FACTORY_NOT_CONFIGURED",
 			operation: "factory",
 			model: this.name
@@ -6325,8 +6348,8 @@ var Model = class Model {
 	* @returns
 	*/
 	static async transaction(callback, options = {}) {
-		require_MorphToManyRelation.ensureArkormConfigLoading();
-		return await require_MorphToManyRelation.runArkormTransaction(async (context) => {
+		require_relationship.ensureArkormConfigLoading();
+		return await require_relationship.runArkormTransaction(async (context) => {
 			return await callback(context);
 		}, options, this.getAdapter());
 	}
@@ -6343,7 +6366,7 @@ var Model = class Model {
 	*/
 	static getDelegate(delegate) {
 		Model.emitDeprecationWarning("ARKORM_GET_DELEGATE_DEPRECATED", "Model.getDelegate() is deprecated and will be removed in Arkorm 3.0. Use Model.getAdapter() and adapter-backed execution instead.");
-		require_MorphToManyRelation.ensureArkormConfigLoading();
+		require_relationship.ensureArkormConfigLoading();
 		const key = delegate || this.delegate || this.getTable();
 		return resolveRuntimeCompatibilityQuerySchemaOrThrow(key, [
 			key,
@@ -6353,8 +6376,8 @@ var Model = class Model {
 		], this.name, this.client);
 	}
 	static getAdapter() {
-		require_MorphToManyRelation.ensureArkormConfigLoading();
-		const runtimeAdapter = require_MorphToManyRelation.getRuntimeAdapter();
+		require_relationship.ensureArkormConfigLoading();
+		const runtimeAdapter = require_relationship.getRuntimeAdapter();
 		if (runtimeAdapter) return runtimeAdapter;
 		if (this.adapter) return this.adapter;
 		return getRuntimeCompatibilityAdapter(this.client);
@@ -6489,6 +6512,16 @@ var Model = class Model {
 		});
 		return this;
 	}
+	async update(attributes) {
+		try {
+			const primaryKey = this.constructor.getPrimaryKey();
+			if (!this.getAttribute(primaryKey)) return false;
+			await this.fill(attributes).save();
+			return true;
+		} catch {
+			return false;
+		}
+	}
 	getAttribute(key) {
 		const attributeMutator = this.resolveAttributeMutator(key);
 		const mutator = this.resolveGetMutator(key);
@@ -6565,7 +6598,7 @@ var Model = class Model {
 		const constructor = this.constructor;
 		const primaryKey = constructor.getPrimaryKey();
 		const identifier = this.getAttribute(primaryKey);
-		if (identifier == null) throw new require_MorphToManyRelation.ArkormException(primaryKey === "id" ? "Cannot delete a model without an id." : `Cannot delete a model without a [${primaryKey}] value.`);
+		if (identifier == null) throw new require_relationship.ArkormException(primaryKey === "id" ? "Cannot delete a model without an id." : `Cannot delete a model without a [${primaryKey}] value.`);
 		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "deleting", this);
 		const softDeleteConfig = constructor.getSoftDeleteConfig();
@@ -6602,7 +6635,7 @@ var Model = class Model {
 		const constructor = this.constructor;
 		const primaryKey = constructor.getPrimaryKey();
 		const identifier = this.getAttribute(primaryKey);
-		if (identifier == null) throw new require_MorphToManyRelation.ArkormException(primaryKey === "id" ? "Cannot force delete a model without an id." : `Cannot force delete a model without a [${primaryKey}] value.`);
+		if (identifier == null) throw new require_relationship.ArkormException(primaryKey === "id" ? "Cannot force delete a model without an id." : `Cannot force delete a model without a [${primaryKey}] value.`);
 		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "forceDeleting", this);
 		await Model.dispatchEvent(constructor, "deleting", this);
@@ -6631,7 +6664,7 @@ var Model = class Model {
 		const constructor = this.constructor;
 		const primaryKey = constructor.getPrimaryKey();
 		const identifier = this.getAttribute(primaryKey);
-		if (identifier == null) throw new require_MorphToManyRelation.ArkormException(primaryKey === "id" ? "Cannot restore a model without an id." : `Cannot restore a model without a [${primaryKey}] value.`);
+		if (identifier == null) throw new require_relationship.ArkormException(primaryKey === "id" ? "Cannot restore a model without an id." : `Cannot restore a model without a [${primaryKey}] value.`);
 		const softDeleteConfig = constructor.getSoftDeleteConfig();
 		if (!softDeleteConfig.enabled) return this;
 		const previousOriginal = this.getOriginal();
@@ -6788,7 +6821,7 @@ var Model = class Model {
 	*/
 	hasOne(related, foreignKey, localKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.HasOneRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.HasOneRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a has many relationship.
@@ -6800,7 +6833,7 @@ var Model = class Model {
 	*/
 	hasMany(related, foreignKey, localKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.HasManyRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.HasManyRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a belongs to relationship.
@@ -6811,7 +6844,7 @@ var Model = class Model {
 	* @returns 
 	*/
 	belongsTo(related, foreignKey, ownerKey) {
-		return new require_MorphToManyRelation.BelongsToRelation(this, related, foreignKey, ownerKey ?? related.getPrimaryKey());
+		return new require_relationship.BelongsToRelation(this, related, foreignKey, ownerKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Define a belongs to many relationship.
@@ -6826,7 +6859,7 @@ var Model = class Model {
 	*/
 	belongsToMany(related, throughTable, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.BelongsToManyRelation(this, related, throughTable, foreignPivotKey, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
+		return new require_relationship.BelongsToManyRelation(this, related, throughTable, foreignPivotKey, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Define a has one through relationship.
@@ -6841,7 +6874,7 @@ var Model = class Model {
 	*/
 	hasOneThrough(related, throughTable, firstKey, secondKey, localKey, secondLocalKey = "id") {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.HasOneThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
+		return new require_relationship.HasOneThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
 	}
 	/**
 	* Define a has many through relationship.
@@ -6856,7 +6889,7 @@ var Model = class Model {
 	*/
 	hasManyThrough(related, throughTable, firstKey, secondKey, localKey, secondLocalKey = "id") {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.HasManyThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
+		return new require_relationship.HasManyThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
 	}
 	/**
 	* Define a polymorphic one to one relationship.
@@ -6868,7 +6901,7 @@ var Model = class Model {
 	*/
 	morphOne(related, morphName, localKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.MorphOneRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.MorphOneRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a polymorphic one to many relationship.
@@ -6880,7 +6913,7 @@ var Model = class Model {
 	*/
 	morphMany(related, morphName, localKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.MorphManyRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.MorphManyRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a polymorphic many to many relationship.
@@ -6895,7 +6928,7 @@ var Model = class Model {
 	*/
 	morphToMany(related, throughTable, morphName, relatedPivotKey, parentKey, relatedKey) {
 		const constructor = this.constructor;
-		return new require_MorphToManyRelation.MorphToManyRelation(this, related, throughTable, morphName, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
+		return new require_relationship.MorphToManyRelation(this, related, throughTable, morphName, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Resolve a get mutator method for a given attribute key, if it exists.
@@ -7094,7 +7127,7 @@ var Model = class Model {
 		if (!configured) return [];
 		return (Array.isArray(configured) ? configured : [configured]).map((entry) => {
 			const handler = typeof entry === "function" ? new entry() : entry;
-			if (!handler || typeof handler.handle !== "function") throw new require_MorphToManyRelation.ArkormException(`Invalid event handler configured for [${modelClass.name}.${event}].`);
+			if (!handler || typeof handler.handle !== "function") throw new require_relationship.ArkormException(`Invalid event handler configured for [${modelClass.name}.${event}].`);
 			return async (model) => {
 				await handler.handle(model);
 			};
@@ -7162,17 +7195,17 @@ var PivotModel = class extends Model {
 };
 
 //#endregion
-exports.ArkormCollection = require_MorphToManyRelation.ArkormCollection;
-exports.ArkormException = require_MorphToManyRelation.ArkormException;
+exports.ArkormCollection = require_relationship.ArkormCollection;
+exports.ArkormException = require_relationship.ArkormException;
 exports.Attribute = Attribute;
 exports.CliApp = CliApp;
 exports.DB = DB;
-exports.EnumBuilder = require_MorphToManyRelation.EnumBuilder;
-exports.ForeignKeyBuilder = require_MorphToManyRelation.ForeignKeyBuilder;
+exports.EnumBuilder = require_relationship.EnumBuilder;
+exports.ForeignKeyBuilder = require_relationship.ForeignKeyBuilder;
 exports.InitCommand = InitCommand;
 exports.InlineFactory = InlineFactory;
 exports.KyselyDatabaseAdapter = KyselyDatabaseAdapter;
-exports.LengthAwarePaginator = require_MorphToManyRelation.LengthAwarePaginator;
+exports.LengthAwarePaginator = require_relationship.LengthAwarePaginator;
 exports.MIGRATION_BRAND = MIGRATION_BRAND;
 exports.MakeFactoryCommand = MakeFactoryCommand;
 exports.MakeMigrationCommand = MakeMigrationCommand;
@@ -7188,131 +7221,131 @@ exports.Model = Model;
 exports.ModelFactory = ModelFactory;
 exports.ModelNotFoundException = ModelNotFoundException;
 exports.ModelsSyncCommand = ModelsSyncCommand;
-exports.PRISMA_ENUM_MEMBER_REGEX = require_MorphToManyRelation.PRISMA_ENUM_MEMBER_REGEX;
-exports.PRISMA_ENUM_REGEX = require_MorphToManyRelation.PRISMA_ENUM_REGEX;
-exports.PRISMA_MODEL_REGEX = require_MorphToManyRelation.PRISMA_MODEL_REGEX;
-exports.Paginator = require_MorphToManyRelation.Paginator;
+exports.PRISMA_ENUM_MEMBER_REGEX = require_relationship.PRISMA_ENUM_MEMBER_REGEX;
+exports.PRISMA_ENUM_REGEX = require_relationship.PRISMA_ENUM_REGEX;
+exports.PRISMA_MODEL_REGEX = require_relationship.PRISMA_MODEL_REGEX;
+exports.Paginator = require_relationship.Paginator;
 exports.PivotModel = PivotModel;
-exports.PrimaryKeyGenerationPlanner = require_MorphToManyRelation.PrimaryKeyGenerationPlanner;
+exports.PrimaryKeyGenerationPlanner = require_relationship.PrimaryKeyGenerationPlanner;
 exports.PrismaDatabaseAdapter = PrismaDatabaseAdapter;
 exports.QueryBuilder = QueryBuilder;
 exports.QueryConstraintException = QueryConstraintException;
 exports.QueryExecutionException = QueryExecutionException;
-exports.RelationResolutionException = require_MorphToManyRelation.RelationResolutionException;
-exports.RuntimeModuleLoader = require_MorphToManyRelation.RuntimeModuleLoader;
+exports.RelationResolutionException = require_relationship.RelationResolutionException;
+exports.RuntimeModuleLoader = require_relationship.RuntimeModuleLoader;
 exports.SEEDER_BRAND = SEEDER_BRAND;
-exports.SchemaBuilder = require_MorphToManyRelation.SchemaBuilder;
+exports.SchemaBuilder = require_relationship.SchemaBuilder;
 exports.ScopeNotDefinedException = ScopeNotDefinedException;
 exports.SeedCommand = SeedCommand;
 exports.Seeder = Seeder;
-exports.TableBuilder = require_MorphToManyRelation.TableBuilder;
-exports.URLDriver = require_MorphToManyRelation.URLDriver;
+exports.TableBuilder = require_relationship.TableBuilder;
+exports.URLDriver = require_relationship.URLDriver;
 exports.UniqueConstraintResolutionException = UniqueConstraintResolutionException;
-exports.UnsupportedAdapterFeatureException = require_MorphToManyRelation.UnsupportedAdapterFeatureException;
-exports.applyAlterTableOperation = require_MorphToManyRelation.applyAlterTableOperation;
-exports.applyCreateTableOperation = require_MorphToManyRelation.applyCreateTableOperation;
-exports.applyDropTableOperation = require_MorphToManyRelation.applyDropTableOperation;
-exports.applyMigrationRollbackToDatabase = require_MorphToManyRelation.applyMigrationRollbackToDatabase;
-exports.applyMigrationRollbackToPrismaSchema = require_MorphToManyRelation.applyMigrationRollbackToPrismaSchema;
-exports.applyMigrationToDatabase = require_MorphToManyRelation.applyMigrationToDatabase;
-exports.applyMigrationToPrismaSchema = require_MorphToManyRelation.applyMigrationToPrismaSchema;
-exports.applyOperationsToPersistedColumnMappingsState = require_MorphToManyRelation.applyOperationsToPersistedColumnMappingsState;
-exports.applyOperationsToPrismaSchema = require_MorphToManyRelation.applyOperationsToPrismaSchema;
-exports.bindAdapterToModels = require_MorphToManyRelation.bindAdapterToModels;
-exports.buildEnumBlock = require_MorphToManyRelation.buildEnumBlock;
-exports.buildFieldLine = require_MorphToManyRelation.buildFieldLine;
-exports.buildIndexLine = require_MorphToManyRelation.buildIndexLine;
-exports.buildInverseRelationLine = require_MorphToManyRelation.buildInverseRelationLine;
-exports.buildMigrationIdentity = require_MorphToManyRelation.buildMigrationIdentity;
-exports.buildMigrationRunId = require_MorphToManyRelation.buildMigrationRunId;
-exports.buildMigrationSource = require_MorphToManyRelation.buildMigrationSource;
-exports.buildModelBlock = require_MorphToManyRelation.buildModelBlock;
-exports.buildRelationLine = require_MorphToManyRelation.buildRelationLine;
-exports.computeMigrationChecksum = require_MorphToManyRelation.computeMigrationChecksum;
-exports.configureArkormRuntime = require_MorphToManyRelation.configureArkormRuntime;
-exports.createEmptyAppliedMigrationsState = require_MorphToManyRelation.createEmptyAppliedMigrationsState;
-exports.createEmptyPersistedColumnMappingsState = require_MorphToManyRelation.createEmptyPersistedColumnMappingsState;
+exports.UnsupportedAdapterFeatureException = require_relationship.UnsupportedAdapterFeatureException;
+exports.applyAlterTableOperation = require_relationship.applyAlterTableOperation;
+exports.applyCreateTableOperation = require_relationship.applyCreateTableOperation;
+exports.applyDropTableOperation = require_relationship.applyDropTableOperation;
+exports.applyMigrationRollbackToDatabase = require_relationship.applyMigrationRollbackToDatabase;
+exports.applyMigrationRollbackToPrismaSchema = require_relationship.applyMigrationRollbackToPrismaSchema;
+exports.applyMigrationToDatabase = require_relationship.applyMigrationToDatabase;
+exports.applyMigrationToPrismaSchema = require_relationship.applyMigrationToPrismaSchema;
+exports.applyOperationsToPersistedColumnMappingsState = require_relationship.applyOperationsToPersistedColumnMappingsState;
+exports.applyOperationsToPrismaSchema = require_relationship.applyOperationsToPrismaSchema;
+exports.bindAdapterToModels = require_relationship.bindAdapterToModels;
+exports.buildEnumBlock = require_relationship.buildEnumBlock;
+exports.buildFieldLine = require_relationship.buildFieldLine;
+exports.buildIndexLine = require_relationship.buildIndexLine;
+exports.buildInverseRelationLine = require_relationship.buildInverseRelationLine;
+exports.buildMigrationIdentity = require_relationship.buildMigrationIdentity;
+exports.buildMigrationRunId = require_relationship.buildMigrationRunId;
+exports.buildMigrationSource = require_relationship.buildMigrationSource;
+exports.buildModelBlock = require_relationship.buildModelBlock;
+exports.buildRelationLine = require_relationship.buildRelationLine;
+exports.computeMigrationChecksum = require_relationship.computeMigrationChecksum;
+exports.configureArkormRuntime = require_relationship.configureArkormRuntime;
+exports.createEmptyAppliedMigrationsState = require_relationship.createEmptyAppliedMigrationsState;
+exports.createEmptyPersistedColumnMappingsState = require_relationship.createEmptyPersistedColumnMappingsState;
 exports.createKyselyAdapter = createKyselyAdapter;
-exports.createMigrationTimestamp = require_MorphToManyRelation.createMigrationTimestamp;
+exports.createMigrationTimestamp = require_relationship.createMigrationTimestamp;
 exports.createPrismaAdapter = createPrismaAdapter;
 exports.createPrismaCompatibilityAdapter = createPrismaCompatibilityAdapter;
 exports.createPrismaDatabaseAdapter = createPrismaDatabaseAdapter;
 exports.createPrismaDelegateMap = createPrismaDelegateMap;
-exports.defineConfig = require_MorphToManyRelation.defineConfig;
+exports.defineConfig = require_relationship.defineConfig;
 exports.defineFactory = defineFactory;
-exports.deleteAppliedMigrationsStateFromStore = require_MorphToManyRelation.deleteAppliedMigrationsStateFromStore;
-exports.deletePersistedColumnMappingsState = require_MorphToManyRelation.deletePersistedColumnMappingsState;
-exports.deriveCollectionFieldName = require_MorphToManyRelation.deriveCollectionFieldName;
-exports.deriveInverseRelationAlias = require_MorphToManyRelation.deriveInverseRelationAlias;
-exports.deriveRelationAlias = require_MorphToManyRelation.deriveRelationAlias;
-exports.deriveRelationFieldName = require_MorphToManyRelation.deriveRelationFieldName;
-exports.deriveSingularFieldName = require_MorphToManyRelation.deriveSingularFieldName;
-exports.emitRuntimeDebugEvent = require_MorphToManyRelation.emitRuntimeDebugEvent;
-exports.ensureArkormConfigLoading = require_MorphToManyRelation.ensureArkormConfigLoading;
-exports.escapeRegex = require_MorphToManyRelation.escapeRegex;
-exports.findAppliedMigration = require_MorphToManyRelation.findAppliedMigration;
-exports.findEnumBlock = require_MorphToManyRelation.findEnumBlock;
-exports.findModelBlock = require_MorphToManyRelation.findModelBlock;
-exports.formatDefaultValue = require_MorphToManyRelation.formatDefaultValue;
-exports.formatEnumDefaultValue = require_MorphToManyRelation.formatEnumDefaultValue;
-exports.formatRelationAction = require_MorphToManyRelation.formatRelationAction;
-exports.generateMigrationFile = require_MorphToManyRelation.generateMigrationFile;
-exports.getActiveTransactionAdapter = require_MorphToManyRelation.getActiveTransactionAdapter;
-exports.getActiveTransactionClient = require_MorphToManyRelation.getActiveTransactionClient;
-exports.getDefaultStubsPath = require_MorphToManyRelation.getDefaultStubsPath;
-exports.getLastMigrationRun = require_MorphToManyRelation.getLastMigrationRun;
-exports.getLatestAppliedMigrations = require_MorphToManyRelation.getLatestAppliedMigrations;
-exports.getMigrationPlan = require_MorphToManyRelation.getMigrationPlan;
-exports.getPersistedColumnMap = require_MorphToManyRelation.getPersistedColumnMap;
-exports.getPersistedEnumMap = require_MorphToManyRelation.getPersistedEnumMap;
-exports.getPersistedEnumTsType = require_MorphToManyRelation.getPersistedEnumTsType;
-exports.getPersistedPrimaryKeyGeneration = require_MorphToManyRelation.getPersistedPrimaryKeyGeneration;
-exports.getPersistedTableMetadata = require_MorphToManyRelation.getPersistedTableMetadata;
-exports.getPersistedTimestampColumns = require_MorphToManyRelation.getPersistedTimestampColumns;
-exports.getRuntimeAdapter = require_MorphToManyRelation.getRuntimeAdapter;
-exports.getRuntimeClient = require_MorphToManyRelation.getRuntimeClient;
+exports.deleteAppliedMigrationsStateFromStore = require_relationship.deleteAppliedMigrationsStateFromStore;
+exports.deletePersistedColumnMappingsState = require_relationship.deletePersistedColumnMappingsState;
+exports.deriveCollectionFieldName = require_relationship.deriveCollectionFieldName;
+exports.deriveInverseRelationAlias = require_relationship.deriveInverseRelationAlias;
+exports.deriveRelationAlias = require_relationship.deriveRelationAlias;
+exports.deriveRelationFieldName = require_relationship.deriveRelationFieldName;
+exports.deriveSingularFieldName = require_relationship.deriveSingularFieldName;
+exports.emitRuntimeDebugEvent = require_relationship.emitRuntimeDebugEvent;
+exports.ensureArkormConfigLoading = require_relationship.ensureArkormConfigLoading;
+exports.escapeRegex = require_relationship.escapeRegex;
+exports.findAppliedMigration = require_relationship.findAppliedMigration;
+exports.findEnumBlock = require_relationship.findEnumBlock;
+exports.findModelBlock = require_relationship.findModelBlock;
+exports.formatDefaultValue = require_relationship.formatDefaultValue;
+exports.formatEnumDefaultValue = require_relationship.formatEnumDefaultValue;
+exports.formatRelationAction = require_relationship.formatRelationAction;
+exports.generateMigrationFile = require_relationship.generateMigrationFile;
+exports.getActiveTransactionAdapter = require_relationship.getActiveTransactionAdapter;
+exports.getActiveTransactionClient = require_relationship.getActiveTransactionClient;
+exports.getDefaultStubsPath = require_relationship.getDefaultStubsPath;
+exports.getLastMigrationRun = require_relationship.getLastMigrationRun;
+exports.getLatestAppliedMigrations = require_relationship.getLatestAppliedMigrations;
+exports.getMigrationPlan = require_relationship.getMigrationPlan;
+exports.getPersistedColumnMap = require_relationship.getPersistedColumnMap;
+exports.getPersistedEnumMap = require_relationship.getPersistedEnumMap;
+exports.getPersistedEnumTsType = require_relationship.getPersistedEnumTsType;
+exports.getPersistedPrimaryKeyGeneration = require_relationship.getPersistedPrimaryKeyGeneration;
+exports.getPersistedTableMetadata = require_relationship.getPersistedTableMetadata;
+exports.getPersistedTimestampColumns = require_relationship.getPersistedTimestampColumns;
+exports.getRuntimeAdapter = require_relationship.getRuntimeAdapter;
+exports.getRuntimeClient = require_relationship.getRuntimeClient;
 exports.getRuntimeCompatibilityAdapter = getRuntimeCompatibilityAdapter;
-exports.getRuntimeDebugHandler = require_MorphToManyRelation.getRuntimeDebugHandler;
-exports.getRuntimePaginationCurrentPageResolver = require_MorphToManyRelation.getRuntimePaginationCurrentPageResolver;
-exports.getRuntimePaginationURLDriverFactory = require_MorphToManyRelation.getRuntimePaginationURLDriverFactory;
-exports.getRuntimePrismaClient = require_MorphToManyRelation.getRuntimePrismaClient;
-exports.getUserConfig = require_MorphToManyRelation.getUserConfig;
+exports.getRuntimeDebugHandler = require_relationship.getRuntimeDebugHandler;
+exports.getRuntimePaginationCurrentPageResolver = require_relationship.getRuntimePaginationCurrentPageResolver;
+exports.getRuntimePaginationURLDriverFactory = require_relationship.getRuntimePaginationURLDriverFactory;
+exports.getRuntimePrismaClient = require_relationship.getRuntimePrismaClient;
+exports.getUserConfig = require_relationship.getUserConfig;
 exports.inferDelegateName = inferDelegateName;
-exports.isDelegateLike = require_MorphToManyRelation.isDelegateLike;
-exports.isMigrationApplied = require_MorphToManyRelation.isMigrationApplied;
-exports.isQuerySchemaLike = require_MorphToManyRelation.isQuerySchemaLike;
-exports.isTransactionCapableClient = require_MorphToManyRelation.isTransactionCapableClient;
-exports.loadArkormConfig = require_MorphToManyRelation.loadArkormConfig;
-exports.markMigrationApplied = require_MorphToManyRelation.markMigrationApplied;
-exports.markMigrationRun = require_MorphToManyRelation.markMigrationRun;
-exports.pad = require_MorphToManyRelation.pad;
-exports.readAppliedMigrationsState = require_MorphToManyRelation.readAppliedMigrationsState;
-exports.readAppliedMigrationsStateFromStore = require_MorphToManyRelation.readAppliedMigrationsStateFromStore;
-exports.readPersistedColumnMappingsState = require_MorphToManyRelation.readPersistedColumnMappingsState;
-exports.rebuildPersistedColumnMappingsState = require_MorphToManyRelation.rebuildPersistedColumnMappingsState;
-exports.removeAppliedMigration = require_MorphToManyRelation.removeAppliedMigration;
-exports.resetArkormRuntimeForTests = require_MorphToManyRelation.resetArkormRuntimeForTests;
-exports.resetPersistedColumnMappingsCache = require_MorphToManyRelation.resetPersistedColumnMappingsCache;
+exports.isDelegateLike = require_relationship.isDelegateLike;
+exports.isMigrationApplied = require_relationship.isMigrationApplied;
+exports.isQuerySchemaLike = require_relationship.isQuerySchemaLike;
+exports.isTransactionCapableClient = require_relationship.isTransactionCapableClient;
+exports.loadArkormConfig = require_relationship.loadArkormConfig;
+exports.markMigrationApplied = require_relationship.markMigrationApplied;
+exports.markMigrationRun = require_relationship.markMigrationRun;
+exports.pad = require_relationship.pad;
+exports.readAppliedMigrationsState = require_relationship.readAppliedMigrationsState;
+exports.readAppliedMigrationsStateFromStore = require_relationship.readAppliedMigrationsStateFromStore;
+exports.readPersistedColumnMappingsState = require_relationship.readPersistedColumnMappingsState;
+exports.rebuildPersistedColumnMappingsState = require_relationship.rebuildPersistedColumnMappingsState;
+exports.removeAppliedMigration = require_relationship.removeAppliedMigration;
+exports.resetArkormRuntimeForTests = require_relationship.resetArkormRuntimeForTests;
+exports.resetPersistedColumnMappingsCache = require_relationship.resetPersistedColumnMappingsCache;
 exports.resolveCast = resolveCast;
-exports.resolveColumnMappingsFilePath = require_MorphToManyRelation.resolveColumnMappingsFilePath;
-exports.resolveEnumName = require_MorphToManyRelation.resolveEnumName;
-exports.resolveMigrationClassName = require_MorphToManyRelation.resolveMigrationClassName;
-exports.resolveMigrationStateFilePath = require_MorphToManyRelation.resolveMigrationStateFilePath;
-exports.resolvePersistedMetadataFeatures = require_MorphToManyRelation.resolvePersistedMetadataFeatures;
-exports.resolvePrismaType = require_MorphToManyRelation.resolvePrismaType;
+exports.resolveColumnMappingsFilePath = require_relationship.resolveColumnMappingsFilePath;
+exports.resolveEnumName = require_relationship.resolveEnumName;
+exports.resolveMigrationClassName = require_relationship.resolveMigrationClassName;
+exports.resolveMigrationStateFilePath = require_relationship.resolveMigrationStateFilePath;
+exports.resolvePersistedMetadataFeatures = require_relationship.resolvePersistedMetadataFeatures;
+exports.resolvePrismaType = require_relationship.resolvePrismaType;
 exports.resolveRuntimeCompatibilityQuerySchema = resolveRuntimeCompatibilityQuerySchema;
 exports.resolveRuntimeCompatibilityQuerySchemaOrThrow = resolveRuntimeCompatibilityQuerySchemaOrThrow;
-exports.runArkormTransaction = require_MorphToManyRelation.runArkormTransaction;
-exports.runMigrationWithPrisma = require_MorphToManyRelation.runMigrationWithPrisma;
-exports.runPrismaCommand = require_MorphToManyRelation.runPrismaCommand;
-exports.stripPrismaSchemaModelsAndEnums = require_MorphToManyRelation.stripPrismaSchemaModelsAndEnums;
-exports.supportsDatabaseMigrationExecution = require_MorphToManyRelation.supportsDatabaseMigrationExecution;
-exports.supportsDatabaseMigrationState = require_MorphToManyRelation.supportsDatabaseMigrationState;
-exports.supportsDatabaseReset = require_MorphToManyRelation.supportsDatabaseReset;
-exports.syncPersistedColumnMappingsFromState = require_MorphToManyRelation.syncPersistedColumnMappingsFromState;
-exports.toMigrationFileSlug = require_MorphToManyRelation.toMigrationFileSlug;
-exports.toModelName = require_MorphToManyRelation.toModelName;
-exports.validatePersistedMetadataFeaturesForMigrations = require_MorphToManyRelation.validatePersistedMetadataFeaturesForMigrations;
-exports.writeAppliedMigrationsState = require_MorphToManyRelation.writeAppliedMigrationsState;
-exports.writeAppliedMigrationsStateToStore = require_MorphToManyRelation.writeAppliedMigrationsStateToStore;
-exports.writePersistedColumnMappingsState = require_MorphToManyRelation.writePersistedColumnMappingsState;
+exports.runArkormTransaction = require_relationship.runArkormTransaction;
+exports.runMigrationWithPrisma = require_relationship.runMigrationWithPrisma;
+exports.runPrismaCommand = require_relationship.runPrismaCommand;
+exports.stripPrismaSchemaModelsAndEnums = require_relationship.stripPrismaSchemaModelsAndEnums;
+exports.supportsDatabaseMigrationExecution = require_relationship.supportsDatabaseMigrationExecution;
+exports.supportsDatabaseMigrationState = require_relationship.supportsDatabaseMigrationState;
+exports.supportsDatabaseReset = require_relationship.supportsDatabaseReset;
+exports.syncPersistedColumnMappingsFromState = require_relationship.syncPersistedColumnMappingsFromState;
+exports.toMigrationFileSlug = require_relationship.toMigrationFileSlug;
+exports.toModelName = require_relationship.toModelName;
+exports.validatePersistedMetadataFeaturesForMigrations = require_relationship.validatePersistedMetadataFeaturesForMigrations;
+exports.writeAppliedMigrationsState = require_relationship.writeAppliedMigrationsState;
+exports.writeAppliedMigrationsStateToStore = require_relationship.writeAppliedMigrationsStateToStore;
+exports.writePersistedColumnMappingsState = require_relationship.writePersistedColumnMappingsState;