joist-core 2.4.0-next.5 → 2.4.0-next.51

package/build/BaseEntity.d.cts

@@ -8,13 +8,13 @@ import { Entity, IdType } from "./Entity.cjs";
  *
  * This should be treated as an internal API and may change without notice.
  */
-declare function getInstanceData(entity: Entity): InstanceData;
+export declare function getInstanceData(entity: Entity): InstanceData;
 /**
  * The base class for all entities.
  *
  * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
  */
-declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
+export declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
   static getInstanceData(entity: Entity): InstanceData;
   protected readonly __data: InstanceData;
   /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */
@@ -67,7 +67,6 @@ declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = I
  * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
  * on its `Object.create`-d instances.
  */
-declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
+export declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
 //#endregion
-export { BaseEntity, baseEntityCstr, getInstanceData };
 //# sourceMappingURL=BaseEntity.d.cts.map

package/build/BaseEntity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEntity.d.cts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;iBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;uBAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;iBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}
+{"version":3,"file":"BaseEntity.d.cts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;wBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;8BAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;wBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}

package/build/BaseEntity.d.mts

@@ -8,13 +8,13 @@ import { Entity, IdType } from "./Entity.mjs";
  *
  * This should be treated as an internal API and may change without notice.
  */
-declare function getInstanceData(entity: Entity): InstanceData;
+export declare function getInstanceData(entity: Entity): InstanceData;
 /**
  * The base class for all entities.
  *
  * Currently, this just adds the `.load(lensFn)` method for declarative reference traversal.
  */
-declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
+export declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = IdType> implements Entity {
   static getInstanceData(entity: Entity): InstanceData;
   protected readonly __data: InstanceData;
   /** The single-arg constructor is our psuedo-public API that can only be called by the EntityManager. */
@@ -67,7 +67,6 @@ declare abstract class BaseEntity<EM extends EntityManager, I extends IdType = I
  * The constructor logic for `BaseEntity` but exposed so that `newEntity` can use it too
  * on its `Object.create`-d instances.
  */
-declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
+export declare function baseEntityCstr(em: EntityManager, entity: BaseEntity<any, any>, isNew: boolean): void;
 //#endregion
-export { BaseEntity, baseEntityCstr, getInstanceData };
 //# sourceMappingURL=BaseEntity.d.mts.map

package/build/BaseEntity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseEntity.d.mts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;iBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;uBAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;iBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}
+{"version":3,"file":"BaseEntity.d.mts","names":[],"sources":["../src/BaseEntity.ts"],"mappings":";;;;;;;;;;wBAiBgB,gBAAgB,QAAQ,SAAS;;;;;;8BAS3B,WAAW,WAAW,eAAe,UAAU,SAAS,mBAAmB;SACjF,gBAAgB,QAAQ,SAAS;qBAI5B,QAAS;;EAG5B,YAAY,IAAI;MAaZ;;WAKK,IAAI;;eAGA,WAAW;;WAGf,UAAU;;eAGN,iBAAiB;;MAG1B;WAIK,IAAI;;;;WAKJ,WAAW;;;;WAKX,eAAe,gBAAgB;;;;;;;MAQpC;MAIA;MAIA;EAIJ;EAKA;MAKW,MAAM;;;;;;;;EAWV;GAIN,OAAO;;WAcS,iBAAiB;;;;;;wBA0BpB,eAAe,IAAI,eAAe,QAAQ,sBAAsB"}

package/build/Entity.d.cts

@@ -1,10 +1,10 @@
 import { EntityManager, TaggedId } from "./EntityManager.cjs";
 //#region src/Entity.d.ts
-declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
+export declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
 /** All the types we support for entity `id` fields. */
-type IdType = number | string;
+export type IdType = number | string;
 /** A marker/base interface for all of our entity types. */
-interface Entity {
+export interface Entity {
   /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */
   id: IdType;
   idMaybe: IdType | undefined;
@@ -38,5 +38,4 @@ interface Entity {
   toTaggedString(): string;
 }
 //#endregion
-export { Entity, IdType, isEntity };
 //# sourceMappingURL=Entity.d.cts.map

package/build/Entity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.d.cts","names":[],"sources":["../src/Entity.ts"],"mappings":";;iBAGgB,SAAS,uBAAuB,eAAe;;KAKnD;;UAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}
+{"version":3,"file":"Entity.d.cts","names":[],"sources":["../src/Entity.ts"],"mappings":";;wBAGgB,SAAS,uBAAuB,eAAe;;YAKnD;;iBAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}

package/build/Entity.d.mts

@@ -1,10 +1,10 @@
 import { EntityManager, TaggedId } from "./EntityManager.mjs";
 //#region src/Entity.d.ts
-declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
+export declare function isEntity(maybeEntity: unknown): maybeEntity is Entity;
 /** All the types we support for entity `id` fields. */
-type IdType = number | string;
+export type IdType = number | string;
 /** A marker/base interface for all of our entity types. */
-interface Entity {
+export interface Entity {
   /** The entity id, either tagged or untagged; the per-application `Entity` will specialize appropriately. */
   id: IdType;
   idMaybe: IdType | undefined;
@@ -38,5 +38,4 @@ interface Entity {
   toTaggedString(): string;
 }
 //#endregion
-export { Entity, IdType, isEntity };
 //# sourceMappingURL=Entity.d.mts.map

package/build/Entity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.d.mts","names":[],"sources":["../src/Entity.ts"],"mappings":";;iBAGgB,SAAS,uBAAuB,eAAe;;KAKnD;;UAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}
+{"version":3,"file":"Entity.d.mts","names":[],"sources":["../src/Entity.ts"],"mappings":";;wBAGgB,SAAS,uBAAuB,eAAe;;YAKnD;;iBAGK;;EAEf,IAAI;EACJ,SAAS;;EAET,UAAU;EACV,eAAe;WACN,IAAI;WACJ;WACA;WACA;WACA,iBAAiB;EAC1B,IAAI;EACJ,WAAW;EACX,eAAe,gBAAgB;;;;;;;;;;EAU/B;;;;;;;EAOA"}

package/build/EntityFields.d.cts

@@ -1,7 +1,7 @@
 //#region src/EntityFields.d.ts
 /** All the fields for an entity in the `FieldsOf` / `EntityField` format. */
-type EntityFields<T> = { [K in keyof T]: EntityField; };
-type EntityField = {
+export type EntityFields<T> = { [K in keyof T]: EntityField; };
+export type EntityField = {
   kind: "primitive";
   type: unknown;
   unique: boolean;
@@ -22,7 +22,7 @@ type EntityField = {
   nullable: never | unknown;
 };
 /** The subset of primitive, enum, and m2o fields from the `F` that are settable, i.e. not derived. */
-type SettableFields<F> = { [K in keyof F]: F[K] extends {
+export type SettableFields<F> = { [K in keyof F]: F[K] extends {
   kind: "primitive";
   derived: false;
 } ? F[K] : F[K] extends {
@@ -32,5 +32,4 @@ type SettableFields<F> = { [K in keyof F]: F[K] extends {
   derived: false;
 } ? F[K] : never; };
 //#endregion
-export { EntityField, EntityFields, SettableFields };
 //# sourceMappingURL=EntityFields.d.cts.map

package/build/EntityFields.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityFields.d.cts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;KACY,aAAa,QACtB,WAAW,IAAI;KAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;KAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}
+{"version":3,"file":"EntityFields.d.cts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;YACY,aAAa,QACtB,WAAW,IAAI;YAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;YAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}

package/build/EntityFields.d.mts

@@ -1,7 +1,7 @@
 //#region src/EntityFields.d.ts
 /** All the fields for an entity in the `FieldsOf` / `EntityField` format. */
-type EntityFields<T> = { [K in keyof T]: EntityField; };
-type EntityField = {
+export type EntityFields<T> = { [K in keyof T]: EntityField; };
+export type EntityField = {
   kind: "primitive";
   type: unknown;
   unique: boolean;
@@ -22,7 +22,7 @@ type EntityField = {
   nullable: never | unknown;
 };
 /** The subset of primitive, enum, and m2o fields from the `F` that are settable, i.e. not derived. */
-type SettableFields<F> = { [K in keyof F]: F[K] extends {
+export type SettableFields<F> = { [K in keyof F]: F[K] extends {
   kind: "primitive";
   derived: false;
 } ? F[K] : F[K] extends {
@@ -32,5 +32,4 @@ type SettableFields<F> = { [K in keyof F]: F[K] extends {
   derived: false;
 } ? F[K] : never; };
 //#endregion
-export { EntityField, EntityFields, SettableFields };
 //# sourceMappingURL=EntityFields.d.mts.map

package/build/EntityFields.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityFields.d.mts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;KACY,aAAa,QACtB,WAAW,IAAI;KAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;KAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}
+{"version":3,"file":"EntityFields.d.mts","names":[],"sources":["../src/EntityFields.ts"],"mappings":";;YACY,aAAa,QACtB,WAAW,IAAI;YAGN;EACN;EAAmB;EAAe;EAAiB;EAA6B;;EAChF;EAAc;EAAe;;EAC7B;EAAa;EAAe;EAA2B;;EACvD;EAAc;EAAe;;;YAGvB,eAAe,QACxB,WAAW,IAAI,EAAE;EAAa;EAAmB;IAC9C,EAAE,KACF,EAAE;EAAa;IACb,EAAE,KACF,EAAE;EAAa;EAAa;IAC1B,EAAE"}

package/build/EntityManager.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
 const require_batchloaders_BatchLoader = require("./batchloaders/BatchLoader.cjs");
 require("./relations/Collection.cjs");
+const require_newEntity = require("./newEntity.cjs");
 const require_relations_CustomCollection = require("./relations/CustomCollection.cjs");
 const require_relations_CustomReference = require("./relations/CustomReference.cjs");
 const require_normalizeHints = require("./normalizeHints.cjs");
@@ -14,7 +15,6 @@ const require_reactivity_reactiveHints = require("./reactivity/reactiveHints.cjs
 const require_loading_loadHints = require("./loading/loadHints.cjs");
 const require_relations_hasAsyncMethod = require("./relations/hasAsyncMethod.cjs");
 const require_relations_AsyncProperty = require("./relations/AsyncProperty.cjs");
-const require_fields = require("./fields.cjs");
 const require_keys = require("./keys.cjs");
 const require_RowData = require("./RowData.cjs");
 const require_relations_LazyField = require("./relations/LazyField.cjs");
@@ -30,11 +30,12 @@ const require_relations_OneToOneReference = require("./relations/OneToOneReferen
 const require_relations_PolymorphicReference = require("./relations/PolymorphicReference.cjs");
 require("./relations/index.cjs");
 const require_utils = require("./utils.cjs");
-const require_newEntity = require("./newEntity.cjs");
+const require_fields = require("./fields.cjs");
+const require_flush_ReadDrift = require("./flush/ReadDrift.cjs");
 require("./typeMap.cjs");
 const require_rules = require("./rules.cjs");
-const require_configure = require("./configure.cjs");
 const require_config = require("./config.cjs");
+const require_configure = require("./configure.cjs");
 const require_EntityMetadata = require("./EntityMetadata.cjs");
 const require_trusted = require("./trusted.cjs");
 const require_defaults = require("./defaults.cjs");
@@ -109,6 +110,8 @@ var EntityManager = class EntityManager {
 	#entitiesByTag = /* @__PURE__ */ new Map();
 	#indexManager = new require_IndexManager.IndexManager();
 	#isValidating = false;
+	/** The error that failed a previous `em.flush`, after which this EntityManager can't flush again. */
+	#flushError = void 0;
 	#findRestricted = false;
 	#pendingPercolate = /* @__PURE__ */ new Map();
 	#preloadedRelations = /* @__PURE__ */ new Map();
@@ -135,6 +138,8 @@ var EntityManager = class EntityManager {
 		beforeCommit: [],
 		afterCommit: []
 	};
+	#forceTransaction = false;
+	#readSet = /* @__PURE__ */ new Set();
 	#preloader;
 	#fieldLogger = require_logging_FieldLogger.noopFieldLogger;
 	#isLoadedCache = new require_loading_IsLoadedCache.IsLoadedCache();
@@ -157,6 +162,7 @@ var EntityManager = class EntityManager {
 				beforeCommit: [...opts.em.#hooks.beforeCommit],
 				afterCommit: [...opts.em.#hooks.afterCommit]
 			};
+			this.#forceTransaction = opts.em.#forceTransaction;
 			opts.em.__api.pluginManager.cloneTo(pluginManager);
 		}
 		const em = this;
@@ -300,7 +306,7 @@ var EntityManager = class EntityManager {
 		this.#assertFindAllowed("query");
 		const em = this;
 		return (async function query() {
-			const plan = require_queries_sql_query.parseUserQuery(q);
+			const plan = require_queries_sql_query.parseRootQuery(q);
 			if (options?.populate && plan.output.kind !== "entity") require_utils.fail("em.query populate requires an entity selection");
 			const { rows } = await em.driver.executeQuery(em, plan.sql, plan.bindings);
 			const result = plan.decodeRows(em, rows);
@@ -519,18 +525,22 @@ var EntityManager = class EntityManager {
 		return require_upsert.upsert(this, type, input);
 	}
 	async clone(entityOrArray, opts) {
-		const { deep = {}, skipIf, skip = {}, postClone } = opts ?? {};
+		const { deep = {}, skipIf, skip = {}, overrides, postClone } = opts ?? {};
 		const todo = /* @__PURE__ */ new Set();
 		const skipMap = /* @__PURE__ */ new WeakMap();
 		await crawl(todo, skipMap, Array.isArray(entityOrArray) ? entityOrArray : [entityOrArray], deep, {
-			skipIf,
+			skipIf: (entity) => invokeCloneCallback(skipIf, entity) ?? false,
 			skip
 		});
 		const deferredRelations = [];
+		const overrideMap = /* @__PURE__ */ new WeakMap();
 		const clones = [...todo].map((entity) => {
 			const skip = skipMap.get(entity) ?? [];
+			const override = invokeCloneCallback(overrides, entity) ?? {};
+			overrideMap.set(entity, override);
 			const meta = require_EntityMetadata.getMetadata(entity);
 			const copy = Object.fromEntries(Object.values(meta.allFields).map((f) => {
+				if (Object.hasOwn(override, f.fieldName)) return [f.fieldName, override[f.fieldName]];
 				if (skip.includes(f.fieldName)) return void 0;
 				switch (f.kind) {
 					case "primitive": if (!f.derived && !f.protected) return [f.fieldName, require_fields.getField(entity, f.fieldName)];
@@ -560,11 +570,15 @@ var EntityManager = class EntityManager {
 					default: require_utils.assertNever(f);
 				}
 			}).filter(isDefined));
-			return [entity, this.create(require_index.asConcreteCstr(meta.cstr), copy)];
+			return [entity, this.create(require_index.asConcreteCstr(meta.cstr), {
+				...copy,
+				...override
+			})];
 		});
 		const entityToClone = new Map(clones);
-		clones.forEach(([, clone]) => {
+		clones.forEach(([original, clone]) => {
 			require_index.getRelationEntries(clone).forEach(([fieldName, value]) => {
+				if (Object.hasOwn(overrideMap.get(original), fieldName)) return;
 				if (value instanceof require_relations_ManyToOneReference.ManyToOneReferenceImpl || value instanceof require_relations_PolymorphicReference.PolymorphicReferenceImpl || value instanceof require_relations_ReactiveReference.ReactiveReferenceImpl) {
 					const existingIdOrEntity = require_fields.getField(clone, fieldName);
 					const existing = require_Entity.isEntity(existingIdOrEntity) ? existingIdOrEntity : this.getEntity(existingIdOrEntity);
@@ -575,7 +589,7 @@ var EntityManager = class EntityManager {
 		deferredRelations.forEach(([source, fieldName, target]) => {
 			entityToClone.get(source)[fieldName].set(entityToClone.get(target));
 		});
-		if (postClone) await Promise.all(clones.map(([original, clone]) => postClone(original, clone)));
+		if (postClone) await Promise.all(clones.map((pair) => invokeCloneCallback(postClone, ...pair)));
 		return Array.isArray(entityOrArray) ? entityOrArray.filter((original) => entityToClone.has(original)).map((original) => entityToClone.get(original)) : clones[0] ? clones[0][1] : require_utils.fail("no entities were cloned given the provided options");
 	}
 	/**
@@ -866,6 +880,7 @@ var EntityManager = class EntityManager {
 	}
 	async #flush(flushOptions = {}) {
 		if (this.mode === "read-only") throw new ReadOnlyError();
+		if (this.#flushError !== void 0) throw new FailedFlushError(this.#flushError);
 		const { skipValidation = false } = flushOptions;
 		this.#fl.startLock();
 		const allFlushedEntities = /* @__PURE__ */ new Set();
@@ -990,9 +1005,11 @@ var EntityManager = class EntityManager {
 			await runValidation(entityTodos, joinRowTodos, !skipValidation);
 			this.#rm.throwIfAnySuppressedTypeErrors();
 			if (suppressedDefaultTypeErrors.length > 0) throw suppressedDefaultTypeErrors[0];
-			if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
+			if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0 || this.#rm.hasPendingCommitTransitions() || this.#readSet.size > 0 || this.#forceTransaction) {
+				const checkedReads = /* @__PURE__ */ new Set();
 				await this.driver.transaction(this, async () => {
 					do {
+						if (this.#readSet.size > 0) await require_flush_ReadDrift.checkReadDrift(this, this.#readSet, allFlushedEntities, checkedReads);
 						if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
 							await this.driver.flush(this, entityTodos, joinRowTodos);
 							collectCommitRuleTodos(entityTodos, joinRowTodos);
@@ -1021,6 +1038,8 @@ var EntityManager = class EntityManager {
 						await runCommitValidation(commitRuleTodos, commitRuleJoinRowTodos);
 					}
 					await beforeCommit(this.ctx, allFlushedEntities);
+					await this.#rm.runCommitTransitions();
+					if (this.#readSet.size > 0) await require_flush_ReadDrift.checkReadDrift(this, this.#readSet, allFlushedEntities, checkedReads);
 					if (this.mode === "in-memory-writes") throw new InMemoryRollbackError();
 				});
 				await afterCommit(this.ctx, allFlushedEntities);
@@ -1040,12 +1059,14 @@ var EntityManager = class EntityManager {
 				this.#dataloaders = {};
 				this.#batchLoaders = {};
 				this.#preloadedRelations = /* @__PURE__ */ new Map();
-				this.#rm.clear();
 			}
 			for (const e of createdThenDeleted) require_BaseEntity.getInstanceData(e).fixupCreatedThenDeleted();
 			this.#merging?.clear();
+			this.#rm.clear();
+			this.#readSet.clear();
 			return [...allFlushedEntities].sort((a, b) => require_BaseEntity.getInstanceData(a).entityIndex - require_BaseEntity.getInstanceData(b).entityIndex);
 		} catch (e) {
+			if (!(e instanceof InMemoryRollbackError)) this.#flushError = e;
 			if (e instanceof require_relations_RecursiveCycleError.RecursiveCycleError) {
 				const entity = e.entities[0];
 				for (const meta of require_EntityMetadata.getBaseAndSelfMetas(require_EntityMetadata.getMetadata(entity))) {
@@ -1202,6 +1223,15 @@ var EntityManager = class EntityManager {
 		}
 		return entities;
 	}
+	assertUnchanged(entityOrEntities) {
+		const entities = require_Entity.isEntity(entityOrEntities) ? [entityOrEntities] : entityOrEntities;
+		for (const entity of entities) {
+			if (entity.em !== this) throw new Error("assertUnchanged requires entities from this EntityManager");
+			if (entity.isNewEntity) continue;
+			if (!require_EntityMetadata.getBaseMeta(require_EntityMetadata.getMetadata(entity)).timestampFields?.updatedAt) throw new Error(`assertUnchanged requires updatedAt on ${entity}`);
+			this.#readSet.add(entity);
+		}
+	}
 	touch(entityOrEntities) {
 		for (const entity of require_utils.toArray(entityOrEntities)) require_BaseEntity.getInstanceData(entity).markTouched();
 	}
@@ -1237,17 +1267,25 @@ var EntityManager = class EntityManager {
 		}));
 		await this.#rm.recalcPendingReactables("reactables");
 	}
-	beforeBegin(fn) {
+	/** Registers a hook to run before the transaction begins. */
+	beforeBegin(fn, opts = {}) {
 		this.#hooks.beforeBegin.push(fn);
+		this.#forceTransaction ||= opts.forceTransaction ?? false;
 	}
-	afterBegin(fn) {
+	/** Registers a hook to run after the transaction begins. */
+	afterBegin(fn, opts = {}) {
 		this.#hooks.afterBegin.push(fn);
+		this.#forceTransaction ||= opts.forceTransaction ?? false;
 	}
-	beforeCommit(fn) {
+	/** Registers a hook to run before the transaction commits. */
+	beforeCommit(fn, opts = {}) {
 		this.#hooks.beforeCommit.push(fn);
+		this.#forceTransaction ||= opts.forceTransaction ?? false;
 	}
-	afterCommit(fn) {
+	/** Registers a hook to run after the transaction commits. */
+	afterCommit(fn, opts = {}) {
 		this.#hooks.afterCommit.push(fn);
+		this.#forceTransaction ||= opts.forceTransaction ?? false;
 	}
 	/**
 	* Returns an EntityManager-scoped (i.e. request scoped) data loader.
@@ -1326,6 +1364,7 @@ var EntityManager = class EntityManager {
 		} else throw new Error("Unsupported override for setFieldLogging");
 	}
 	async [Symbol.asyncDispose]() {
+		if (this.#flushError !== void 0) return;
 		await this.flush();
 	}
 	/** Returns entities matching the filter using indexed search when available. */
@@ -1751,6 +1790,18 @@ function recalcSynchronousDerivedFields(todos) {
 		}
 	}
 }
+/** Invokes only the most specific handler, falling back to a base type when no concrete-type handler exists. */
+function invokeCloneCallback(callback, ...args) {
+	if (typeof callback === "function") return callback(...args);
+	if (!callback) return void 0;
+	const handlers = callback;
+	let meta = require_EntityMetadata.getMetadata(args[0]);
+	while (meta) {
+		const handler = Object.hasOwn(handlers, meta.type) ? handlers[meta.type] : void 0;
+		if (handler) return handler(...args);
+		meta = meta.baseType ? require_configure.getMetadataForType(meta.baseType) : void 0;
+	}
+}
 /** Recursively crawls through `entity`, with the given populate `deep` hint, and adds anything found to `found`. */
 async function crawl(found, skipMap, entities, deep, opts = {}) {
 	const { skipIf = () => false } = opts ?? {};
@@ -1801,7 +1852,7 @@ function maybeBumpUpdatedAt(rm, todos, now) {
 		const { updatedAt } = todo.metadata.timestampFields ?? {};
 		if (updatedAt) for (const e of todo.updates) {
 			const orm = require_BaseEntity.getInstanceData(e);
-			orm.markFieldDirty(updatedAt, require_fields.getField(e, updatedAt));
+			orm.markFieldDirty(updatedAt, require_fields.getField(e, updatedAt, true));
 			const serde = todo.metadata.fields[updatedAt].serde;
 			orm.data[updatedAt] = serde.mapFromNow(now);
 			rm.queueDownstreamReactables(e, updatedAt);
@@ -1861,6 +1912,12 @@ function hasPaginationSettings(options) {
 }
 /** An error we throw to get knex to `ROLLBACK`, but then catch. */
 var InMemoryRollbackError = class extends Error {};
+/** An error thrown by `em.flush` after a previous `em.flush` on the same EntityManager failed. */
+var FailedFlushError = class extends Error {
+	constructor(cause) {
+		super("EntityManager cannot flush after a previous flush failed, use a new EntityManager", { cause });
+	}
+};
 /** An error thrown when `em.mode === "read-only"` but entities are mutated/flushed. */
 var ReadOnlyError = class extends Error {
 	constructor() {
@@ -1912,6 +1969,7 @@ function createRowFromEntityData(e, opts = {}) {
 }
 //#endregion
 exports.EntityManager = EntityManager;
+exports.FailedFlushError = FailedFlushError;
 exports.NotFoundError = NotFoundError;
 exports.ReadOnlyError = ReadOnlyError;
 exports.TooManyError = TooManyError;
@@ -1923,6 +1981,7 @@ exports.driverBeforeBegin = driverBeforeBegin;
 exports.driverBeforeCommit = driverBeforeCommit;
 exports.getDefaultEntityLimit = getDefaultEntityLimit;
 exports.getEmInternalApi = getEmInternalApi;
+exports.invokeRule = invokeRule;
 exports.isDefined = isDefined;
 exports.isId = isId;
 exports.isKey = isKey;