@danceroutine/tango-orm 1.11.0 → 1.11.2

package/dist/{registerModelObjects-Djpt45KK.js → registerModelObjects-DZfZ20fa.js}

@@ -1,13 +1,42 @@
-import { InternalQNodeType, InternalRelationKind, InternalSqlValidationPlanKind, ModelQuerySet, OrmSqlSafetyAdapter, QBuilder, QueryResult, QuerySet, TableMetaFactory, isQNodeLike } from "./query-DUZnBFhf.js";
-import { RuntimeBoundClient, TransactionEngine, getTangoRuntime } from "./defaultRuntime-DzqBQ9Hb.js";
+import { a as isQNodeLike, c as InternalRelationKind, f as OrmSqlSafetyAdapter, i as QBuilder, l as QueryResult, m as InternalQNodeType, n as ModelQuerySet, p as InternalSqlValidationPlanKind, r as QuerySet, s as TableMetaFactory } from "./query-CP1UMIX6.js";
+import { a as RuntimeBoundClient, o as TransactionEngine, t as getTangoRuntime } from "./defaultRuntime-CdTX8cXm.js";
 import { NotFoundError } from "@danceroutine/tango-core";
 import { ModelRegistry, registerModelAugmentor } from "@danceroutine/tango-schema";
-
 //#region src/manager/relations/ManyToManyRelatedQuerySet.ts
 function applyShape(rows, shape) {
 	return typeof shape === "function" ? rows.map(shape) : rows.map((row) => shape.parse(row));
 }
+/**
+* {@link QuerySet} returned by `post.tags.all()` on a many-to-many related
+* manager.
+*
+* Behaves like a normal `QuerySet` over the target model from an application
+* developer's perspective: you can chain `filter`, `exclude`, `orderBy`,
+* `limit`, `offset`, and terminate with `fetch`, `fetchOne`, or `count`.
+* Each chainable call returns another `ManyToManyRelatedQuerySet` so the
+* chain keeps the membership scoping of the owning record.
+*
+* Two behaviors differ from a plain `QuerySet` and matter to application
+* developers:
+*
+* - When the relation was loaded by `prefetchRelated(...)` and no chainable
+*   state has been added (no `filter`, `orderBy`, etc.), `fetch()` and
+*   `count()` resolve from the prefetch cache without issuing SQL.
+* - Mutating the membership via `post.tags.add(tag)` or
+*   `post.tags.remove(tag)` invalidates that cache so follow-up reads go
+*   back to the database.
+*
+* @example
+* ```ts
+* const post = await PostModel.objects.getOrThrow(postId);
+* await post.tags.add(tag);
+* const tags = await post.tags.all().filter({ color: 'red' }).orderBy('name').fetch();
+* ```
+*
+* @template TTarget - The persisted target record shape (e.g. `Tag`).
+*/
 var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet {
+	bridge;
 	constructor(executor, bridge, state = {}) {
 		super(executor, state);
 		this.bridge = bridge;
@@ -15,10 +44,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 	async fetch(shape) {
 		if (this.isStateTrivial()) {
 			const cache = this.bridge.getCache();
-			if (cache !== null) {
-				const results = shape ? applyShape(cache, shape) : [...cache];
-				return new QueryResult(results);
-			}
+			if (cache !== null) return new QueryResult(shape ? applyShape(cache, shape) : [...cache]);
 		}
 		const ids = await this.bridge.fetchTargetIds();
 		if (ids.length === 0) return new QueryResult([]);
@@ -26,8 +52,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		return shape ? scopedQs.fetch(shape) : scopedQs.fetch();
 	}
 	async fetchOne(shape) {
-		const result = shape ? await this.fetch(shape) : await this.fetch();
-		return result.items[0] ?? null;
+		return (shape ? await this.fetch(shape) : await this.fetch()).items[0] ?? null;
 	}
 	async count() {
 		if (this.isStateTrivial()) {
@@ -37,8 +62,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		const ids = await this.bridge.fetchTargetIds();
 		if (ids.length === 0) return 0;
 		if (this.isStateTrivial()) return ids.length;
-		const scopedQs = new ModelQuerySet(this.executor, this.scopedState(ids));
-		return scopedQs.count();
+		return new ModelQuerySet(this.executor, this.scopedState(ids)).count();
 	}
 	spawn(state) {
 		return new ManyToManyRelatedQuerySet(this.executor, this.bridge, state);
@@ -59,13 +83,15 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		};
 	}
 };
-
 //#endregion
 //#region src/manager/internal/MutationCompiler.ts
 const InternalDuplicateInsertPolicy = {
 	ERROR: "error",
 	IGNORE: "ignore"
 };
+/**
+* Internal compiler for manager-owned INSERT/UPDATE/DELETE statements.
+*/
 var MutationCompiler = class {
 	adapter;
 	placeholders;
@@ -144,16 +170,26 @@ var MutationCompiler = class {
 		};
 	}
 };
-
 //#endregion
 //#region src/manager/relations/internal/ThroughTableManager.ts
+/**
+* Internal helper that issues the INSERT, DELETE, and SELECT statements for
+* a single many-to-many join table. Centralizes SQL safety validation and
+* compilation so {@link ManyToManyRelatedManager} implementations only deal
+* in primary-key values.
+*/
 var ThroughTableManager = class ThroughTableManager {
-	constructor(client, mutationCompiler, descriptor, adapter, sqlSafetyAdapter$1 = new OrmSqlSafetyAdapter()) {
+	client;
+	mutationCompiler;
+	descriptor;
+	adapter;
+	sqlSafetyAdapter;
+	constructor(client, mutationCompiler, descriptor, adapter, sqlSafetyAdapter = new OrmSqlSafetyAdapter()) {
 		this.client = client;
 		this.mutationCompiler = mutationCompiler;
 		this.descriptor = descriptor;
 		this.adapter = adapter;
-		this.sqlSafetyAdapter = sqlSafetyAdapter$1;
+		this.sqlSafetyAdapter = sqlSafetyAdapter;
 	}
 	/**
 	* Derive a {@link ThroughTableLinkDescriptor} from the through-model
@@ -198,8 +234,7 @@ var ThroughTableManager = class ThroughTableManager {
 		const targetColumn = validated.filterKeys[this.descriptor.targetColumn].field;
 		const placeholder = this.adapter.placeholders.at(1);
 		const sql = `SELECT ${targetColumn} AS target_id FROM ${validated.meta.table} WHERE ${sourceColumn} = ${placeholder}`;
-		const result = await this.client.query(sql, [ownerPrimaryKey]);
-		return result.rows.map((row) => row.target_id).filter((value) => typeof value === "string" || typeof value === "number");
+		return (await this.client.query(sql, [ownerPrimaryKey])).rows.map((row) => row.target_id).filter((value) => typeof value === "string" || typeof value === "number");
 	}
 	async insertLink(ownerPrimaryKey, targetPrimaryKey, options = {}) {
 		await this.insertLinks(ownerPrimaryKey, [targetPrimaryKey], options);
@@ -258,10 +293,32 @@ var ThroughTableManager = class ThroughTableManager {
 		await this.client.query(sql, [ownerPrimaryKey]);
 	}
 };
-
 //#endregion
 //#region src/manager/relations/ManyToManyRelatedManager.ts
+/**
+* Django-style related manager exposed on materialized model records for each
+* many-to-many relation.
+*
+* Use the manager to add or remove join-table membership and to query the
+* related target rows. The owning record's primary key and the relation name
+* are bound when the manager is attached, so application code does not need
+* to pass them on every call.
+*
+* Prefetched memberships seed an internal cache that the queryset returned
+* from `all()` short-circuits to without re-querying. Mutations through
+* `add`, `remove`, `set`, `clear`, and `create` invalidate the cache so
+* subsequent reads observe the updated membership. `set(...)` applies
+* Django-shaped replacement semantics:
+* it diffs the current relation membership against the supplied targets,
+* removes any missing links, and inserts any new links inside one atomic
+* write boundary. `clear()` removes every join row for the owner, and
+* `create(...)` persists a new target row plus its join-row link inside one
+* atomic boundary.
+*
+* @template TTarget - The persisted target record shape returned by `all()`.
+*/
 var ManyToManyRelatedManager = class ManyToManyRelatedManager {
+	inputs;
 	static BRAND = "tango.orm.m2m_related_manager";
 	__tangoBrand = ManyToManyRelatedManager.BRAND;
 	prefetchCache = null;
@@ -319,7 +376,7 @@ var ManyToManyRelatedManager = class ManyToManyRelatedManager {
 		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
 		if (targetPrimaryKeys.length === 0) return;
 		if (targetPrimaryKeys.length === 1) await this.insertTargetPrimaryKeys(targetPrimaryKeys);
-else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimaryKeys));
+		else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimaryKeys));
 		this.invalidateCache();
 	}
 	/**
@@ -331,7 +388,7 @@ else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimar
 		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
 		if (targetPrimaryKeys.length === 0) return;
 		if (targetPrimaryKeys.length === 1) await this.deleteTargetPrimaryKeys(targetPrimaryKeys);
-else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimaryKeys));
+		else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimaryKeys));
 		this.invalidateCache();
 	}
 	/**
@@ -438,7 +495,7 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 	}
 	resolveTargetPrimaryKeys(targets) {
 		const resolved = [];
-		const seen = new Set();
+		const seen = /* @__PURE__ */ new Set();
 		for (const target of targets) {
 			const primaryKey = this.resolveTargetPrimaryKey(target);
 			const canonical = this.canonicalizePrimaryKey(primaryKey);
@@ -452,7 +509,7 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 		if (typeof target === "string" || typeof target === "number") return target;
 		if (typeof target === "object" && target !== null) {
 			const targetPrimaryKey = target[this.inputs.targetPrimaryKeyField];
-			if (targetPrimaryKey === undefined || targetPrimaryKey === null) throw new Error(`Cannot resolve target primary key '${this.inputs.targetPrimaryKeyField}' for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'.`);
+			if (targetPrimaryKey === void 0 || targetPrimaryKey === null) throw new Error(`Cannot resolve target primary key '${this.inputs.targetPrimaryKeyField}' for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'.`);
 			return targetPrimaryKey;
 		}
 		throw new Error(`Unsupported target reference for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'. Expected a record, a primary-key carrier, or a primary-key value.`);
@@ -467,10 +524,12 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 		}
 	}
 };
-
 //#endregion
 //#region src/manager/ModelManager.ts
 const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
+/**
+* Model-backed data access API exposed as `Model.objects`.
+*/
 var ModelManager = class ModelManager {
 	static BRAND = "tango.orm.model_manager";
 	__tangoBrand = ModelManager.BRAND;
@@ -493,8 +552,7 @@ var ModelManager = class ModelManager {
 			client: this.client,
 			adapter: this.adapter,
 			run: async (compiled) => {
-				const result = await this.client.query(compiled.sql, compiled.params);
-				return result.rows;
+				return (await this.client.query(compiled.sql, compiled.params)).rows;
 			},
 			attachPersistedRecordAccessors: (record, modelKey) => {
 				this.attachManyToManyRelatedManagers(record, modelKey ?? this.model.metadata.key);
@@ -521,42 +579,34 @@ var ModelManager = class ModelManager {
 		return validatedMeta;
 	}
 	static mergeCreatePayloadFromWhere(modelName, pkColumn, where, defaults) {
-		const hasDefaultsArg = defaults !== undefined;
-		const providedDefaults = defaults !== undefined ? { ...defaults } : undefined;
+		const hasDefaultsArg = defaults !== void 0;
+		const providedDefaults = defaults !== void 0 ? { ...defaults } : void 0;
 		if (isQNodeLike(where)) {
 			if (!hasDefaultsArg || !providedDefaults || Object.keys(providedDefaults).length === 0) throw new Error(`Cannot create ${modelName} from Q filters without defaults.`);
-			const fromQ = ModelManager.collectPlainFieldsFromQNode(modelName, where);
-			const merged$1 = {
-				...fromQ,
+			const merged = {
+				...ModelManager.collectPlainFieldsFromQNode(modelName, where),
 				...providedDefaults
 			};
-			const keys$1 = Object.keys(merged$1).filter((key) => merged$1[key] !== undefined);
-			const nonPkKeys$1 = keys$1.filter((key) => key !== pkColumn);
-			if (nonPkKeys$1.length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
-			return merged$1;
+			if (Object.keys(merged).filter((key) => merged[key] !== void 0).filter((key) => key !== pkColumn).length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
+			return merged;
 		}
-		const atom = where;
-		const entries = Object.entries(atom);
+		const entries = Object.entries(where);
 		const plainEntries = entries.filter(([key]) => !String(key).includes("__"));
 		const lookupOnly = entries.length > 0 && plainEntries.length === 0;
-		const fromAtom = plainEntries.length > 0 ? Object.fromEntries(plainEntries) : undefined;
 		const mergeBase = {
-			...fromAtom,
+			...plainEntries.length > 0 ? Object.fromEntries(plainEntries) : void 0,
 			...providedDefaults
 		};
 		if (lookupOnly && ModelManager.countDefinedValues(mergeBase, pkColumn) === 0) throw new Error(`Cannot create ${modelName} from lookup-only filters without defaults.`);
-		const cleanedAtom = plainEntries.length > 0 ? Object.fromEntries(plainEntries) : {};
 		const merged = {
-			...cleanedAtom,
+			...plainEntries.length > 0 ? Object.fromEntries(plainEntries) : {},
 			...mergeBase
 		};
-		const keys = Object.keys(merged).filter((key) => merged[key] !== undefined);
-		const nonPkKeys = keys.filter((key) => key !== pkColumn);
-		if (nonPkKeys.length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
+		if (Object.keys(merged).filter((key) => merged[key] !== void 0).filter((key) => key !== pkColumn).length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
 		return merged;
 	}
 	static countDefinedValues(payload, pkColumn) {
-		return Object.entries(payload).filter(([key, value]) => key !== pkColumn && value !== undefined).length;
+		return Object.entries(payload).filter(([key, value]) => key !== pkColumn && value !== void 0).length;
 	}
 	static collectPlainFieldsFromQNode(modelName, node) {
 		switch (node.kind) {
@@ -566,8 +616,7 @@ var ModelManager = class ModelManager {
 				return ModelManager.mergeCompatiblePartials(partials);
 			}
 			case InternalQNodeType.OR: {
-				const partials = (node.nodes ?? []).map((child) => ModelManager.collectPlainFieldsFromQNode(modelName, child));
-				const nonEmpty = partials.filter((partial) => Object.keys(partial).length > 0);
+				const nonEmpty = (node.nodes ?? []).map((child) => ModelManager.collectPlainFieldsFromQNode(modelName, child)).filter((partial) => Object.keys(partial).length > 0);
 				if (nonEmpty.length > 1) throw new Error(`Cannot derive a create payload from ${modelName} OR filters with multiple predicates. Supply defaults that fully describe the insert.`);
 				return nonEmpty.length === 1 ? nonEmpty[0] : {};
 			}
@@ -582,7 +631,7 @@ var ModelManager = class ModelManager {
 		const merged = {};
 		for (const partial of partials) for (const [key, value] of Object.entries(partial)) {
 			const existing = merged[key];
-			if (existing !== undefined && existing !== value) throw new Error(`Conflicting values for '${key}' while deriving create payload from Q filters.`);
+			if (existing !== void 0 && existing !== value) throw new Error(`Conflicting values for '${key}' while deriving create payload from Q filters.`);
 			merged[key] = value;
 		}
 		return merged;
@@ -604,18 +653,16 @@ var ModelManager = class ModelManager {
 	}
 	async getOrCreate(args) {
 		try {
-			const record$1 = await this.query().get(args.where);
 			return {
-				record: record$1,
+				record: await this.query().get(args.where),
 				created: false
 			};
 		} catch (error) {
 			if (!NotFoundError.isNotFoundError(error)) throw error;
 		}
 		const merged = ModelManager.mergeCreatePayloadFromWhere(this.model.metadata.name, this.meta.pk, args.where, args.defaults);
-		const record = await this.create(merged);
 		return {
-			record,
+			record: await this.create(merged),
 			created: true
 		};
 	}
@@ -628,9 +675,8 @@ var ModelManager = class ModelManager {
 		}
 		if (!existing) {
 			const merged = ModelManager.mergeCreatePayloadFromWhere(this.model.metadata.name, this.meta.pk, args.where, args.defaults);
-			const record$1 = await this.create(merged);
 			return {
-				record: record$1,
+				record: await this.create(merged),
 				created: true,
 				updated: false
 			};
@@ -642,9 +688,8 @@ var ModelManager = class ModelManager {
 			updated: false
 		};
 		const id = existing[this.meta.pk];
-		const record = await this.update(id, patch);
 		return {
-			record,
+			record: await this.update(id, patch),
 			created: false,
 			updated: true
 		};
@@ -659,8 +704,7 @@ var ModelManager = class ModelManager {
 			writeKeys: preparedKeys
 		});
 		const compiled = this.mutationCompiler.compileInsert(validatedPlan, preparedKeys.map((key) => prepared[key]));
-		const result = await this.queryExecutor.client.query(compiled.sql, compiled.params);
-		const created = result.rows[0];
+		const created = (await this.queryExecutor.client.query(compiled.sql, compiled.params)).rows[0];
 		this.attachOwnRelatedManagers(created);
 		await this.model.hooks?.afterCreate?.({
 			record: created,
@@ -681,8 +725,7 @@ var ModelManager = class ModelManager {
 			writeKeys: preparedKeys
 		});
 		const compiled = this.mutationCompiler.compileUpdate(validatedPlan, preparedKeys.map((key) => prepared[key]), id);
-		const result = await this.queryExecutor.client.query(compiled.sql, compiled.params);
-		const updated = result.rows[0];
+		const updated = (await this.queryExecutor.client.query(compiled.sql, compiled.params)).rows[0];
 		this.attachOwnRelatedManagers(updated);
 		await this.model.hooks?.afterUpdate?.({
 			id,
@@ -727,8 +770,7 @@ var ModelManager = class ModelManager {
 	*/
 	createManyToManyRelatedManager(relationName, ownerPrimaryKey) {
 		const relation = this.requireManyToManyEdge(relationName);
-		const registry = ModelRegistry.getOwner(this.model);
-		const throughModel = registry.getByKey(relation.throughModelKey);
+		const throughModel = ModelRegistry.getOwner(this.model).getByKey(relation.throughModelKey);
 		return ManyToManyRelatedManager.create({
 			ownerPrimaryKey,
 			relationName,
@@ -748,6 +790,14 @@ var ModelManager = class ModelManager {
 			runAtomic: (work) => TransactionEngine.forRuntime(this.runtime).atomic(() => work())
 		});
 	}
+	/**
+	* Insert multiple rows in a single multi-row INSERT statement.
+	*
+	* All rows must share the same field set after hook processing. Rows with
+	* extra or missing fields relative to the first row will cause an error.
+	* If you need to insert rows with different field sets, use individual
+	* {@link create} calls instead.
+	*/
 	async bulkCreate(inputs) {
 		if (inputs.length === 0) return [];
 		const perRowPrepared = await Promise.all(inputs.map((input) => this.runBeforeCreate(input)));
@@ -759,6 +809,7 @@ var ModelManager = class ModelManager {
 		}) ?? perRowPrepared;
 		const preparedKeys = Object.keys(batchPrepared[0] ?? {});
 		if (preparedKeys.length === 0) throw new Error(`Cannot create ${this.model.metadata.name} without any values.`);
+		this.assertUniformRowShape(batchPrepared, new Set(preparedKeys));
 		const validatedPlan = sqlSafetyAdapter.validate({
 			kind: InternalSqlValidationPlanKind.INSERT,
 			meta: this.meta,
@@ -800,7 +851,7 @@ var ModelManager = class ModelManager {
 		const relations = meta.relations;
 		if (!relations) return;
 		const ownerPrimaryKey = record[meta.pk];
-		if (ownerPrimaryKey === undefined || ownerPrimaryKey === null) return;
+		if (ownerPrimaryKey === void 0 || ownerPrimaryKey === null) return;
 		for (const [relationName, relation] of Object.entries(relations)) {
 			if (relation.kind !== InternalRelationKind.MANY_TO_MANY) continue;
 			if (Object.prototype.hasOwnProperty.call(record, relationName)) continue;
@@ -809,14 +860,19 @@ var ModelManager = class ModelManager {
 				value: relatedManager,
 				writable: true,
 				configurable: true,
+				/**
+				* Non-enumerable so `Object.keys(record)`, `JSON.stringify(record)`,
+				* `{ ...record }`, and similar enumeration paths continue to
+				* see only the persisted columns. Application code reaches the
+				* manager through `record.tags`, never through enumeration.
+				*/
 				enumerable: false
 			});
 		}
 	}
 	resolveManagerForModelKey(modelKey) {
 		if (modelKey === this.model.metadata.key) return this;
-		const registry = ModelRegistry.getOwner(this.model);
-		const otherModel = registry.getByKey(modelKey);
+		const otherModel = ModelRegistry.getOwner(this.model).getByKey(modelKey);
 		if (!otherModel) return null;
 		const candidate = otherModel.objects;
 		return ModelManager.isModelManager(candidate) ? candidate : null;
@@ -857,11 +913,32 @@ var ModelManager = class ModelManager {
 	getHookTransaction() {
 		return TransactionEngine.forRuntime(this.runtime).getActiveTransaction();
 	}
+	assertUniformRowShape(batch, referenceKeys) {
+		const divergentRows = batch.slice(1).map((row, i) => {
+			const rowKeys = new Set(Object.keys(row));
+			const missing = [...referenceKeys].filter((k) => !rowKeys.has(k)).sort();
+			const extra = [...rowKeys].filter((k) => !referenceKeys.has(k)).sort();
+			return {
+				index: i + 1,
+				missing,
+				extra
+			};
+		}).filter((r) => r.missing.length > 0 || r.extra.length > 0);
+		if (divergentRows.length === 0) return;
+		const sortedReferenceKeys = [...referenceKeys].sort();
+		const indices = divergentRows.map((r) => r.index);
+		const details = divergentRows.map((r) => {
+			const parts = [];
+			if (r.missing.length > 0) parts.push(`missing [${r.missing.join(", ")}]`);
+			if (r.extra.length > 0) parts.push(`extra [${r.extra.join(", ")}]`);
+			return `Row at index ${r.index}: ${parts.join(", ")}.`;
+		}).join("\n");
+		throw new Error(`bulkCreate failed after hook processing: rows at indices [${indices.join(", ")}] have mismatched fields.\n${details}\nExpected fields (from row at index 0): [${sortedReferenceKeys.join(", ")}].`);
+	}
 };
-
 //#endregion
 //#region src/manager/registerModelObjects.ts
-const managerCache = new WeakMap();
+const managerCache = /* @__PURE__ */ new WeakMap();
 let hasRegisteredModelObjects = false;
 function defineObjectsProperty(model) {
 	Object.defineProperty(model, "objects", {
@@ -880,12 +957,16 @@ function defineObjectsProperty(model) {
 		}
 	});
 }
+/**
+* Install the schema model augmentor that exposes `Model.objects`.
+* This registration is idempotent so multiple Tango entrypoints can safely call it.
+*/
 function registerModelObjects() {
 	if (hasRegisteredModelObjects) return;
 	registerModelAugmentor(defineObjectsProperty);
 	hasRegisteredModelObjects = true;
 }
-
 //#endregion
-export { ManyToManyRelatedManager, ManyToManyRelatedQuerySet, ModelManager, registerModelObjects };
-//# sourceMappingURL=registerModelObjects-Djpt45KK.js.map
+export { ManyToManyRelatedQuerySet as i, ModelManager as n, ManyToManyRelatedManager as r, registerModelObjects as t };
+
+//# sourceMappingURL=registerModelObjects-DZfZ20fa.js.map