joist-core 2.3.0 → 2.4.0-next.10

package/build/EntityManager.js

@@ -1,2312 +1,1913 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadOnlyError = exports.TooManyError = exports.NotFoundError = exports.EntityManager = void 0;
-exports.isId = isId;
-exports.getEmInternalApi = getEmInternalApi;
-exports.getDefaultEntityLimit = getDefaultEntityLimit;
-exports.setDefaultEntityLimit = setDefaultEntityLimit;
-exports.resetDefaultEntityLimit = resetDefaultEntityLimit;
-exports.isKey = isKey;
-exports.sameEntity = sameEntity;
-exports.sameReference = sameReference;
-exports.driverBeforeBegin = driverBeforeBegin;
-exports.driverAfterBegin = driverAfterBegin;
-exports.driverBeforeCommit = driverBeforeCommit;
-exports.driverAfterCommit = driverAfterCommit;
-exports.isDefined = isDefined;
-exports.setLastNow = setLastNow;
-exports.appendStack = appendStack;
-exports.createRowFromEntityData = createRowFromEntityData;
-const dataloader_1 = __importDefault(require("dataloader"));
-const BaseEntity_1 = require("./BaseEntity");
-const BatchLoader_1 = require("./batchloaders/BatchLoader");
-const defaults_1 = require("./defaults");
-const fields_1 = require("./fields");
-const IndexManager_1 = require("./IndexManager");
-// We alias `Entity => EntityW` to denote "Entity wide" i.e. the non-narrowed Entity
-const loadBatchLoader_1 = require("./batchloaders/loadBatchLoader");
-const populateBatchLoader_1 = require("./batchloaders/populateBatchLoader");
-const config_1 = require("./config");
-const configure_1 = require("./configure");
-const findByUniqueDataLoader_1 = require("./dataloaders/findByUniqueDataLoader");
-const findCountDataLoader_1 = require("./dataloaders/findCountDataLoader");
-const findDataLoader_1 = require("./dataloaders/findDataLoader");
-const findIdsDataLoader_1 = require("./dataloaders/findIdsDataLoader");
-const findOrCreateDataLoader_1 = require("./dataloaders/findOrCreateDataLoader");
-const findPaginatedDataLoader_1 = require("./dataloaders/findPaginatedDataLoader");
-const Entity_1 = require("./Entity");
-const FlushLock_1 = require("./FlushLock");
-const index_1 = require("./index");
-const IsLoadedCache_1 = require("./IsLoadedCache");
-const JoinRows_1 = require("./JoinRows");
-const loadHints_1 = require("./loadHints");
-const newEntity_1 = require("./newEntity");
-const newTestInstance_1 = require("./newTestInstance");
-const PluginManager_1 = require("./PluginManager");
-const ReactionsManager_1 = require("./ReactionsManager");
-const reactiveHints_1 = require("./reactiveHints");
-const relations_1 = require("./relations");
-const AsyncProperty_1 = require("./relations/AsyncProperty");
-const hasAsyncMethod_1 = require("./relations/hasAsyncMethod");
-const RecursiveCollection_1 = require("./relations/RecursiveCollection");
-const scopes_1 = require("./scopes");
-const Todo_1 = require("./Todo");
-const trusted_1 = require("./trusted");
-const upsert_1 = require("./upsert");
-const utils_1 = require("./utils");
-// polyfill
+import { BatchLoader } from "./batchloaders/BatchLoader.js";
+import "./relations/Collection.js";
+import { CustomCollection } from "./relations/CustomCollection.js";
+import { CustomReference } from "./relations/CustomReference.js";
+import { deepNormalizeHint } from "./normalizeHints.js";
+import "./batchloaders/recursiveChildrenBatchLoader.js";
+import "./batchloaders/recursiveM2mBatchLoader.js";
+import "./batchloaders/recursiveParentsBatchLoader.js";
+import { RecursiveCycleError } from "./relations/RecursiveCycleError.js";
+import "./relations/RecursiveCollection.js";
+import { followReverseHint } from "./reactivity/reactiveHints.js";
+import { assertLoaded, isLoadedForPopulate } from "./loading/loadHints.js";
+import { AsyncMethodPopulateSecret } from "./relations/hasAsyncMethod.js";
+import { AsyncPropertyImpl } from "./relations/AsyncProperty.js";
+import { getField, setField } from "./fields.js";
+import { keyToNumber, keyToTaggedId, tagId, toTaggedId } from "./keys.js";
+import { PojoRowData } from "./RowData.js";
+import { LazyFieldImpl } from "./relations/LazyField.js";
+import { isLoadedReference } from "./relations/Reference.js";
+import "./batchloaders/manyToManyBatchLoader.js";
+import "./batchloaders/oneToManyBatchLoader.js";
+import { isSelectAllFilter } from "./queries/find/scopes.js";
+import { OneToManyCollection } from "./relations/OneToManyCollection.js";
+import { ManyToOneReferenceImpl } from "./relations/ManyToOneReference.js";
+import "./batchloaders/oneToOneBatchLoader.js";
+import { ReactiveReferenceImpl } from "./relations/ReactiveReference.js";
+import { OneToOneReferenceImpl } from "./relations/OneToOneReference.js";
+import { PolymorphicReferenceImpl } from "./relations/PolymorphicReference.js";
+import "./relations/index.js";
+import { assertNever, fail, failIfAnyRejected, getOrSet, groupBy, hasAnyKey, partition, toArray } from "./utils.js";
+import { newEntity } from "./newEntity.js";
+import "./typeMap.js";
+import { ValidationErrors } from "./rules.js";
+import { getConstructorFromTag, getConstructorFromTaggedId, getMetadataForType } from "./configure.js";
+import { constraintNameToValidationError } from "./config.js";
+import { getBaseAndSelfMetas, getBaseMeta, getBaseSelfAndSubMetas, getMetadata } from "./EntityMetadata.js";
+import { runInTrustedContext } from "./trusted.js";
+import { setAsyncDefaults, setSyncDefaults } from "./defaults.js";
+import "./dataloaders/lensDataLoader.js";
+import { loadLens } from "./loading/loadLens.js";
+import "./logging/FactoryLogger.js";
+import { resetFactoryCreated } from "./newTestInstance.js";
+import { mergeFindOptions } from "./queries/find/EntityFilter.js";
+import { JoinRows } from "./flush/JoinRows.js";
+import { PluginManager } from "./PluginManager.js";
+import { optimizeCollectionJoins } from "./queries/find/QueryParser.collectionJoins.js";
+import { Todo, combineJoinRows, createTodos, getTodo } from "./flush/Todo.js";
+import { findDataLoader } from "./dataloaders/findDataLoader.js";
+import "./drivers/index.js";
+import { FieldLogger, noopFieldLogger } from "./logging/FieldLogger.js";
+import { ReactionLogger } from "./logging/ReactionLogger.js";
+import "./plugins/PreloadPlugin.js";
+import { parseRootQuery } from "./queries/sql/query.js";
+import { upsert } from "./upsert.js";
+import { NoIdError, asConcreteCstr, getRelationEntries, getRelations, setOpts } from "./index.js";
+import "./batchloaders/enumCollectionBatchLoader.js";
+import { loadBatchLoader } from "./batchloaders/loadBatchLoader.js";
+import { populateBatchLoader } from "./batchloaders/populateBatchLoader.js";
+import { findByUniqueDataLoader } from "./dataloaders/findByUniqueDataLoader.js";
+import { findCountDataLoader, mergeCountOptions } from "./dataloaders/findCountDataLoader.js";
+import { findIdsDataLoader } from "./dataloaders/findIdsDataLoader.js";
+import { entityMatches, findOrCreateDataLoader } from "./dataloaders/findOrCreateDataLoader.js";
+import { findPaginatedDataLoader } from "./dataloaders/findPaginatedDataLoader.js";
+import { FlushLock } from "./flush/FlushLock.js";
+import { IndexManager } from "./IndexManager.js";
+import { IsLoadedCache } from "./loading/IsLoadedCache.js";
+import { decodeStatementResult, isMutation, parseStatement } from "./queries/sql/execute.js";
+import { ReactionsManager } from "./reactivity/ReactionsManager.js";
+import { isEntity } from "./Entity.js";
+import { getInstanceData } from "./BaseEntity.js";
+import DataLoader from "dataloader";
+//#region src/EntityManager.ts
 Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
 function isId(value) {
-    return value && typeof value === "string";
+	return value && typeof value === "string";
 }
 /**
- * The EntityManager is the primary way nearly all code, i.e. anything that finds/creates/updates/deletes entities,
- * will interact with the database.
- *
- * It acts both an Identity Cache (preventing loading the same row twice into memory as separate entities, and then
- * having drift between the two instances) and as a Unit of Work (tracking all changes to entities and then batch
- * flushing only the entities that have changed).
- *
- * Note that the type parameters (C, I, and Entity) will be filled in by codegen with the values specific to your
- * application, so you can import your app-specific EntityManager like:
- *
- * ```ts
- * import { EntityManager } from "src/entities";
- * ```
- *
- * @param C The type of your application-specific app-wide/request-wide Context object that will be passed to hooks
- * @typeParam C - the application-specific context (typically the request-level context)
- * @typeParam Entity - the application's based entity type (i.e. with number ids or string ids)
- * @typeParamTX - the application's Transaction type, i.e. `Knex`
- */
-class EntityManager {
-    ctx;
-    driver;
-    /** When we're flushing, the connection/transaction. */
-    txn;
-    entityLimit = defaultEntityLimit;
-    #entitiesArray = [];
-    // Incrementally track dirty entities so we don't have to scan `#entityArray` during flush
-    #maybePendingFlushEntities = new Set();
-    // Indexes the currently loaded entities by their tagged ids and `toTaggedString` ids (i.e. `a#`). This fixes
-    // real-world performance issues where `findExistingInstance` scanning `#entities` was an `O(n^2)`.
-    #entitiesById = new Map();
-    #entitiesByTag = new Map();
-    // Provides field-based indexing for entity types with >1000 entities to optimize findWithNewOrChanged
-    #indexManager = new IndexManager_1.IndexManager();
-    #isValidating = false;
-    #pendingPercolate = new Map();
-    #preloadedRelations = new Map();
-    /**
-     * Tracks cascade deletes.
-     *
-     * We originally used a beforeDelete lifecycle hook to implement this, but tracking this
-     * individually allows us to a) recursively cascade deletes even during the 1st iteration
-     * of our `flush` loop, and b) cascade deletions before we recalc fields & run user hooks,
-     * so that both see the most accurate state.
-     */
-    #pendingDeletes = [];
-    #hasAnyDeletes = false;
-    #dataloaders = {};
-    #batchLoaders = {};
-    #joinRows = {};
-    /** Stores any `source -> downstream` reactions to recalc during `em.flush`. */
-    #rm = new ReactionsManager_1.ReactionsManager(this);
-    /** Ensures our `em.flush` method is not interrupted. */
-    #fl = new FlushLock_1.FlushLock();
-    #hooks = {
-        beforeBegin: [],
-        afterBegin: [],
-        beforeCommit: [],
-        afterCommit: [],
-    };
-    #preloader;
-    #fieldLogger;
-    #isLoadedCache = new IsLoadedCache_1.IsLoadedCache();
-    #merging;
-    /** Track `a#1`, `a#2`, etc indexes for `em.create`-d entities. */
-    #createCounter = undefined;
-    __api;
-    #isRefreshing = false;
-    mode = "writes";
-    constructor(ctx, driverOrOpts) {
-        const opts = (driverOrOpts.constructor === Object ? driverOrOpts : { driver: driverOrOpts });
-        this.ctx = ctx;
-        this.driver = opts.driver ?? opts.em.driver;
-        this.#preloader = opts.preloadPlugin ?? (opts.em ? opts.em.#preloader : this.driver.defaultPlugins.preloadPlugin);
-        const pluginManager = new PluginManager_1.PluginManager(this);
-        if (opts.em) {
-            this.#hooks = {
-                beforeBegin: [...opts.em.#hooks.beforeBegin],
-                afterBegin: [...opts.em.#hooks.afterBegin],
-                beforeCommit: [...opts.em.#hooks.beforeCommit],
-                afterCommit: [...opts.em.#hooks.afterCommit],
-            };
-            opts.em.__api.pluginManager.cloneTo(pluginManager);
-        }
-        // Expose some of our private fields as the EntityManagerInternalApi
-        const em = this;
-        this.__api = {
-            preloader: this.#preloader,
-            pendingPercolate: this.#pendingPercolate,
-            mutatedCollections: new Set(),
-            pendingLoads: new Set(),
-            hooks: this.#hooks,
-            rm: this.#rm,
-            indexManager: this.#indexManager,
-            isLoadedCache: this.#isLoadedCache,
-            pluginManager,
-            markMaybePending(entity) {
-                em.#maybePendingFlushEntities.add(entity);
-            },
-            unmarkMaybePending(entity) {
-                em.#maybePendingFlushEntities.delete(entity);
-            },
-            hasAnyDeletes() {
-                return em.#hasAnyDeletes;
-            },
-            pendingDeleteIds(type) {
-                return em.#pendingDeletes
-                    .filter((entity) => entity instanceof type && entity.idMaybe !== undefined)
-                    .map((entity) => (0, index_1.keyToNumber)((0, index_1.getMetadata)(entity), entity.id));
-            },
-            isMerging(entity) {
-                return em.#merging?.has(entity) ?? false;
-            },
-            joinRows(m2m) {
-                return (0, utils_1.getOrSet)(em.#joinRows, m2m.joinTableName, () => new JoinRows_1.JoinRows(m2m, em.#rm));
-            },
-            /** Returns `a:1.books` if it's in our preload cache. */
-            getPreloadedRelation(taggedId, fieldName) {
-                return em.#preloadedRelations.get(taggedId)?.get(fieldName);
-            },
-            /** Stores `a:1.books` in our preload cache. */
-            setPreloadedRelation(taggedId, fieldName, children) {
-                let map = em.#preloadedRelations.get(taggedId);
-                if (!map) {
-                    map = new Map();
-                    em.#preloadedRelations.set(taggedId, map);
-                }
-                map.set(fieldName, children);
-            },
-            get isValidating() {
-                return em.#isValidating;
-            },
-            checkWritesAllowed() {
-                if (em.mode === "read-only")
-                    throw new ReadOnlyError();
-                return em.#fl.checkWritesAllowed();
-            },
-            get fieldLogger() {
-                return em.#fieldLogger;
-            },
-            clearDataloaders() {
-                em.#dataloaders = {};
-                em.#batchLoaders = {};
-            },
-            clearPreloadedRelations() {
-                em.#preloadedRelations = new Map();
-            },
-            setIsRefreshing(isRefreshing) {
-                em.#isRefreshing = isRefreshing;
-            },
-        };
-    }
-    /** Returns a read-only shallow copy of the currently-loaded entities. */
-    get entities() {
-        return [...this.#entitiesArray];
-    }
-    /** Returns a list of all pending creates, updates, deletes, and m2m changes that would be flushed. */
-    get pendingChanges() {
-        const changes = [];
-        for (const entity of this.#entitiesArray) {
-            const op = (0, BaseEntity_1.getInstanceData)(entity).pendingOperation;
-            switch (op) {
-                case "insert":
-                    changes.push({ kind: "create", entity });
-                    break;
-                case "update":
-                    changes.push({ kind: "update", entity });
-                    break;
-                case "delete":
-                    changes.push({ kind: "delete", entity });
-                    break;
-            }
-        }
-        for (const joinRows of Object.values(this.#joinRows)) {
-            const todo = joinRows.toTodo();
-            // Enum m2ms (EnumCollections) aren't entity-to-entity, so skip them here.
-            if (todo && !todo.m2m.otherEnum) {
-                for (const row of todo.newRows) {
-                    const entities = Object.values(row.columns);
-                    changes.push({ kind: "m2m", op: "add", joinTableName: todo.m2m.joinTableName, entities });
-                }
-                for (const row of todo.deletedRows) {
-                    const entities = Object.values(row.columns);
-                    changes.push({ kind: "m2m", op: "remove", joinTableName: todo.m2m.joinTableName, entities });
-                }
-            }
-        }
-        return changes;
-    }
-    /** Returns a read-only list of the currently-loaded entities of `type`. */
-    getEntities(type) {
-        const meta = (0, index_1.getMetadata)(type);
-        const entities = this.#entitiesByTag.get(meta.tagName) ?? [];
-        // If we're a subtype, `entities` might have base/other subtypes
-        return (meta.baseType ? entities.filter((e) => e instanceof type) : entities);
-    }
-    getEntity(id) {
-        // Skip this both for performance + we allow toTaggedString-style `a#1` ids
-        // assertIdIsTagged(id);
-        return this.#entitiesById.get(id);
-    }
-    async find(type, where, options) {
-        const { populate, ...rest } = options || {};
-        const normalized = (0, index_1.mergeFindOptions)(where, rest);
-        const settings = { where: normalized.where, ...normalized.options };
-        const result = await (hasPaginationSettings(normalized.options)
-            ? (0, findPaginatedDataLoader_1.findPaginatedDataLoader)(this, type, settings, populate)
-            : (0, findDataLoader_1.findDataLoader)(this, type, settings, populate)).catch(function find(err) {
-            throw appendStack(err, new Error());
-        });
-        if (populate) {
-            await this.populate(result, populate);
-        }
-        return result;
-    }
-    /** Runs the post-parse find pipeline: plugins mutate the logical AST, then Joist optimizes/prunes before SQL. */
-    async executeFind(meta, operation, parsed, settings) {
-        const { checkLimit, findSettings } = this.prepareFind(meta, operation, parsed, settings);
-        return this.executePreparedFind(meta, operation, parsed, findSettings, checkLimit);
-    }
-    /** Executes a query that has already had find hooks and optimizations applied. */
-    async executePreparedFind(meta, operation, parsed, findSettings, checkLimit) {
-        const { pluginManager } = getEmInternalApi(this);
-        const rows = await this.driver.executeFind(this, parsed, findSettings);
-        // Check by default unless explicitly disabled or the caller removed the LIMIT via `limit: undefined`
-        const shouldCheck = checkLimit ?? !("limit" in findSettings && findSettings.limit === undefined);
-        if (shouldCheck && rows.length >= this.entityLimit) {
-            throw new Error(`Query returned more than ${this.entityLimit} entityLimit rows`);
-        }
-        pluginManager.afterFind(meta, operation, rows);
-        return rows;
-    }
-    /**
-     * Runs pre-SQL find hooks and optimizations against a parsed query.
-     *
-     * This allows plugins to see "pre-batched" / "logical" query ASTs, instead of our
-     * more complicated `_find` batched queries. The flow would be:
-     *
-     * - A loader calls `prepareFind(originalQuery)`
-     * - Plugins inspect/modify the query as/if needed
-     * - The loader crafts a new, more complicated query that embeds the originalQuery
-     * - The loader calls `executePreparedFind` with the 2nd query
-     */
-    prepareFind(meta, operation, parsed, settings) {
-        const { checkLimit, ...findSettings } = settings;
-        const { pluginManager } = getEmInternalApi(this);
-        // Plugins may mutate the settings object, so return the post-hook version that loaders must reuse.
-        pluginManager.beforeFind(meta, operation, parsed, findSettings);
-        (0, index_1.optimizeCollectionJoins)(parsed, settings);
-        return { checkLimit, findSettings };
-    }
-    async findGql(type, where, options) {
-        if (!options) {
-            return this.find(type, where);
-        }
-        const normalized = { ...options };
-        if ("limit" in normalized)
-            normalized.limit = normalized.limit ?? undefined;
-        if ("offset" in normalized)
-            normalized.offset = normalized.offset ?? undefined;
-        return this.find(type, where, normalized);
-    }
-    async findOne(type, where, options) {
-        const list = await this.find(type, where, options);
-        if (list.length === 0) {
-            return undefined;
-        }
-        else if (list.length === 1) {
-            return list[0];
-        }
-        else {
-            throw new TooManyError(`Found more than one: ${list.map((e) => e.toString()).join(", ")}`);
-        }
-    }
-    async findOneOrFail(type, where, options) {
-        const list = await this.find(type, where, options);
-        if (list.length === 0) {
-            throw new NotFoundError(`Did not find ${type.name} for given query`);
-        }
-        else if (list.length > 1) {
-            throw new TooManyError(`Found more than one: ${list.map((e) => e.toString()).join(", ")}`);
-        }
-        return list[0];
-    }
-    async findByUnique(type, where, options = {}) {
-        const { populate, softDeletes = "exclude" } = options;
-        const entries = Object.entries(where);
-        if (entries.length !== 1) {
-            throw new Error("findByUnique only accepts a single field");
-        }
-        const [fieldName, value] = entries[0];
-        const field = (0, index_1.getMetadata)(type).allFields[fieldName];
-        const row = await (0, findByUniqueDataLoader_1.findByUniqueDataLoader)(this, type, field, softDeletes)
-            .load(value)
-            .catch(function findByUnique(err) {
-            throw appendStack(err, new Error());
-        });
-        if (!row) {
-            return undefined;
-        }
-        else {
-            const [entity] = this.hydrate(type, [row]);
-            if (this.#hasAnyDeletes && entity.isDeletedEntity) {
-                return undefined;
-            }
-            if (populate) {
-                await this.populate(entity, populate);
-            }
-            return entity;
-        }
-    }
-    /**
-     * Returns the count of entities that match the `where` clause.
-     *
-     * The `where` clause, and any options.conditions, matches the same syntax
-     * as `em.find`.
-     *
-     * Note: this method is not currently auto-batched, so it will cause N+1s if called in a loop.
-     */
-    async findCount(type, where, options = {}) {
-        const normalized = (0, findCountDataLoader_1.mergeCountOptions)(where, options);
-        const settings = { where: normalized.where, ...normalized.options };
-        let count = await (0, findCountDataLoader_1.findCountDataLoader)(this, type, settings).catch(function findCount(err) {
-            throw appendStack(err, new Error());
-        });
-        // If the user is do "count all", we can adjust the number up/down based on
-        // WIP creates/deletes. We can't do this if the WHERE clause is populated b/c
-        // then we'd also have to eval each created/deleted entity against the WHERE
-        // clause before knowing if it should adjust teh amount.
-        const isSelectAll = (0, scopes_1.isSelectAllFilter)(where, options.conditions);
-        if (isSelectAll) {
-            const tagged = this.#entitiesByTag.get((0, index_1.getMetadata)(type).tagName) ?? [];
-            for (const entity of tagged) {
-                // Still do an `instanceof` to handle subtypes
-                if (entity instanceof type) {
-                    if (entity.isNewEntity) {
-                        count++;
-                    }
-                    else if (entity.isDeletedEntity) {
-                        count--;
-                    }
-                }
-            }
-        }
-        return count;
-    }
-    /**
-     * Returns the IDs of entities that match the `where` clause.
-     *
-     * The `where` clause, and any options.conditions, matches the same syntax
-     * as `em.find`.
-     */
-    async findIds(type, where, options = {}) {
-        const normalized = (0, findCountDataLoader_1.mergeCountOptions)(where, options);
-        const settings = { where: normalized.where, ...normalized.options };
-        return (0, findIdsDataLoader_1.findIdsDataLoader)(this, type, settings).catch(function findIds(err) {
-            throw appendStack(err, new Error());
-        });
-    }
-    async findWithNewOrChanged(type, where, options) {
-        const { softDeletes = "exclude", populate } = options ?? {};
-        // Make a copy of `where` because `em.find` will re-write new entities to `-1`, that our `entityMatches` could still match
-        // ...and also prune `undefined` here, since `em.find` will do it anyway, but `entityMatches` does not.
-        const copy = Object.fromEntries(Object.entries(where).filter(([, v]) => v !== undefined));
-        const persisted = await this.find(type, copy, { softDeletes });
-        const unchanged = persisted.filter((e) => !e.isNewEntity && !e.isDirtyEntity && !e.isDeletedEntity);
-        const maybeNew = this.filterEntities(type, where).filter((e) => (e.isNewEntity || e.isDirtyEntity) && !e.isDeletedEntity);
-        const found = [...unchanged, ...maybeNew];
-        if (populate) {
-            await this.populate(found, populate);
-        }
-        return found;
-    }
-    async findOrCreate(type, where, ifNew, upsert, options) {
-        const { softDeletes = "exclude", populate } = options ?? {};
-        const entity = await (0, findOrCreateDataLoader_1.findOrCreateDataLoader)(this, type, where, softDeletes)
-            .load({ ifNew: ifNew, upsert })
-            .catch(function findOrCreate(err) {
-            throw appendStack(err, new Error());
-        });
-        if (populate) {
-            await this.populate(entity, populate);
-        }
-        return entity;
-    }
-    /** Creates a new `type` and marks it as loaded, i.e. we know its collections are all safe to access in memory. */
-    create(type, opts) {
-        return this.#doCreate(type, opts, false);
-    }
-    /**
-     * Creates a new `type` but with `opts` that are nullable, to accept partial-update-style input.
-     *
-     * Note that `createPartial` doesn't support the full upsert behavior, i.e. this method:
-     *
-     * - always creates,
-     * - does not support relation markers like `op`, `delete`, and `remove`,
-     * - does not accept deep input, but
-     * - fields set to `undefined` will be skipped instead of unset
-     *
-     * See `upsert` for the upsert/deep upsert behavior.
-     */
-    createPartial(type, opts) {
-        return this.#doCreate(type, opts, true);
-    }
-    /**
-     * Create or updates `type` based on partial-update-style `input`.
-     *
-     * This supports upsert behavior, i.e.:
-     *
-     * - findOrCreate the primary entity being updated (based on the `id` key being provided),
-     * - upsert relation markers like `op`, `delete`, and `remove` are supported,
-     * - deep input is supported, i.e. `{ firstName: "Bob", books: [{ title: "b1" } ] }`, and
-     * - fields set to `undefined` will be skipped instead of unset
-     */
-    upsert(type, input) {
-        return (0, upsert_1.upsert)(this, type, input);
-    }
-    async clone(entityOrArray, opts) {
-        const { deep = {}, skipIf, skip = {}, postClone } = opts ?? {};
-        // Keep a list that we can work against synchronously after doing the async find/crawl
-        const todo = new Set();
-        const skipMap = new WeakMap();
-        // 1. Find all entities w/o mutating them yet
-        await crawl(todo, skipMap, Array.isArray(entityOrArray) ? entityOrArray : [entityOrArray], deep, {
-            skipIf: skipIf,
-            skip,
-        });
-        // 2. Clone each found entity
-        const clones = [...todo].map((entity) => {
-            const skip = skipMap.get(entity) ?? [];
-            // Use meta.fields to see which fields are derived (i.e. createdAt, updatedAt, initials)
-            // that only have getters, and so we shouldn't set (createdAt/updatedAt will be initialized
-            // by `em.register`).
-            const meta = (0, index_1.getMetadata)(entity);
-            const copy = Object.fromEntries(Object.values(meta.allFields)
-                .map((f) => {
-                if (skip.includes(f.fieldName))
-                    return undefined;
-                switch (f.kind) {
-                    case "primitive":
-                        if (!f.derived && !f.protected) {
-                            return [f.fieldName, (0, fields_1.getField)(entity, f.fieldName)];
-                        }
-                        else {
-                            return undefined;
-                        }
-                    case "m2o":
-                    case "enum":
-                        if (f.derived) {
-                            return undefined;
-                        }
-                        else {
-                            return [f.fieldName, (0, fields_1.getField)(entity, f.fieldName)];
-                        }
-                    case "poly":
-                        return [f.fieldName, (0, fields_1.getField)(entity, f.fieldName)];
-                    case "primaryKey":
-                    case "o2m":
-                    case "m2m":
-                    case "m2mEnum":
-                    case "o2o":
-                    case "lo2m":
-                        return undefined;
-                    default:
-                        (0, utils_1.assertNever)(f);
-                }
-            })
-                .filter(isDefined));
-            // Call `new` just like the user would do
-            // The `asConcreteCstr` is safe b/c we got meta from a concrete/already-instantiated entity
-            const clone = this.create((0, index_1.asConcreteCstr)(meta.cstr), copy);
-            return [entity, clone];
-        });
-        const entityToClone = new Map(clones);
-        // 3. Now mutate the m2o relations. We focus on only m2o's because they "own" the field/column,
-        // and will drive percolation to keep the other-side o2m & o2o updated.
-        clones.forEach(([, clone]) => {
-            (0, index_1.getRelationEntries)(clone).forEach(([fieldName, value]) => {
-                if (value instanceof relations_1.ManyToOneReferenceImpl ||
-                    value instanceof index_1.PolymorphicReferenceImpl ||
-                    value instanceof relations_1.ReactiveReferenceImpl) {
-                    // What's the existing entity? Have we cloned it?
-                    const existingIdOrEntity = (0, fields_1.getField)(clone, fieldName);
-                    // Use O(1) lookup via #entitiesById Map instead of O(N) .find() scan
-                    const existing = (0, Entity_1.isEntity)(existingIdOrEntity) ? existingIdOrEntity : this.getEntity(existingIdOrEntity);
-                    // If we didn't find a loaded entity for this value, assume that it a) itself is not being cloned,
-                    // and b) we don't need to bother telling it about the newly cloned entity
-                    if (existing) {
-                        clone[fieldName].set(entityToClone.get(existing) ?? existing);
-                    }
-                }
-            });
-        });
-        if (postClone) {
-            await Promise.all(clones.map(([original, clone]) => postClone(original, clone)));
-        }
-        return Array.isArray(entityOrArray)
-            ? entityOrArray
-                .filter((original) => entityToClone.has(original))
-                .map((original) => entityToClone.get(original))
-            : clones[0]
-                ? clones[0][1]
-                : (0, utils_1.fail)("no entities were cloned given the provided options");
-    }
-    /**
-     * Merges multiple source entities into a target entity by updating all references that point
-     * to the source entities to instead point to the target entity.
-     *
-     * This method loads all relations from the source entities, updates any entity that
-     * references a source entity to reference the target entity instead, and then automatically
-     * deletes the source entities.
-     *
-     * @param target - The entity that will become the target of all merged references
-     * @param sources - Array of entities whose references will be redirected to the target
-     * @param opts - Options to control merge behavior
-     *   @param autoDelete - Whether to automatically delete source entities (default: true)
-     * @returns Promise that resolves when all references have been updated and sources deleted
-     *
-     * @example
-     * // Merge duplicate authors - all books pointing to author2 will now point to author1
-     * // author2 will be automatically deleted
-     * await em.merge(author1, [author2]);
-     *
-     * @example
-     * // Merge multiple duplicate publishers into one
-     * // publisher2 and publisher3 will be automatically deleted
-     * await em.merge(publisher1, [publisher2, publisher3]);
-     *
-     * @example
-     * // Merge without auto-deleting sources (for custom cleanup logic)
-     * await em.merge(author1, [author2], { autoDelete: false });
-     * // Custom logic here...
-     * em.delete(author2);
-     */
-    async merge(target, sources, opts) {
-        const autoDelete = opts?.autoDelete ?? true;
-        if (sources.length === 0)
-            return [];
-        this.#merging ??= new Set();
-        // Allow cannotBeUpdated to see that anyone pointed to the new target is allowed to change
-        this.#merging.add(target);
-        // Make sure source and target are the same type (Before we call `populate` below which will fail on invalid load hints)
-        const targetMeta = (0, index_1.getMetadata)(target);
-        for (const source of sources) {
-            const sourceMeta = (0, index_1.getMetadata)(source);
-            if (sourceMeta.type !== targetMeta.type) {
-                throw new Error(`Cannot merge entities of different types: ${targetMeta.type} and ${sourceMeta.type}`);
-            }
-        }
-        const fields = Object.values(targetMeta.allFields)
-            .filter((field) => ["o2m", "m2o", "m2m", "o2o"].includes(field.kind))
-            .map((field) => field.fieldName);
-        await this.populate(sources, fields);
-        const changedEntities = [];
-        for (const source of sources) {
-            // Find all reverse relations (things that point to this entity)
-            for (const field of Object.values(targetMeta.allFields)) {
-                const { kind } = field;
-                if (kind === "o2m") {
-                    for (const other of source[field.fieldName].get) {
-                        this.#merging.add(other); // Tell ReactionsManager to react to normally-read-only fields
-                        other[field.otherFieldName].set(target);
-                        changedEntities.push(other);
-                    }
-                }
-                else if (kind === "o2o") {
-                    const otherField = field.otherMetadata().allFields[field.otherFieldName];
-                    if (otherField.kind === "m2o" && otherField.derived)
-                        continue;
-                    const other = source[field.fieldName].get;
-                    if (other) {
-                        this.#merging.add(other); // Tell ReactionsManager to react to normally-read-only fields
-                        other[field.otherFieldName].set(target);
-                        changedEntities.push(other);
-                    }
-                }
-                else if (kind === "m2m") {
-                    for (const other of source[field.fieldName].get) {
-                        this.#merging.add(other); // Tell ReactionsManager to react to normally-read-only fields
-                        const collection = other[field.otherFieldName];
-                        collection.remove(source);
-                        collection.add(target);
-                        changedEntities.push(other);
-                    }
-                }
-                else if (kind === "primitive" ||
-                    kind === "primaryKey" ||
-                    kind === "enum" ||
-                    kind === "m2mEnum" ||
-                    kind === "poly" ||
-                    kind === "m2o" ||
-                    kind === "lo2m") {
-                    // These field types don't need merge handling - they're either:
-                    // - primitive values that don't create references (primitive, enum)
-                    // - primary keys that shouldn't be merged
-                    // - forward references that we handle from the reverse side (m2o)
-                    // - large collections that are handled separately (lo2m)
-                }
-                else {
-                    (0, utils_1.assertNever)(kind);
-                }
-            }
-        }
-        // Auto-delete source entities if requested
-        if (autoDelete) {
-            for (const source of sources)
-                this.delete(source);
-        }
-        return changedEntities;
-    }
-    async load(typeOrId, id, hint) {
-        // Handle the `typeOrId` overload
-        let type;
-        if (typeof typeOrId === "string") {
-            // This must be a tagged id for the 1st overload to work
-            type = (0, index_1.getConstructorFromTaggedId)(typeOrId);
-            id = typeOrId;
-        }
-        else {
-            type = typeOrId;
-            id = id || (0, utils_1.fail)(`Invalid ${typeOrId.name} id: ${id}`);
-        }
-        const meta = (0, index_1.getMetadata)(type);
-        const taggedId = (0, index_1.toTaggedId)(meta, id);
-        let entity = this.findExistingInstance(taggedId);
-        if (!entity) {
-            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
-                .load({ taggedId, hint })
-                .catch(function load(err) {
-                throw appendStack(err, new Error());
-            });
-            entity = this.findExistingInstance(taggedId);
-        }
-        if (!entity) {
-            throw new NotFoundError(`${taggedId} was not found`);
-        }
-        if (hint) {
-            await this.populate(entity, hint);
-        }
-        if (meta.inheritanceType === "sti" && !(entity instanceof type)) {
-            throw new Error(`${entity} is ${entity.constructor.name} but should be ${type.name}`);
-        }
-        return entity;
-    }
-    async loadAll(type, _ids, hint) {
-        const meta = (0, index_1.getMetadata)(type);
-        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
-        const ids = new Array(_ids.length);
-        const entities = new Array(_ids.length);
-        let idsToLoad;
-        let positionsToLoad;
-        for (let i = 0; i < _ids.length; i++) {
-            const id = (0, index_1.tagId)(meta, _ids[i]);
-            ids[i] = id;
-            const entity = this.findExistingInstance(id);
-            if (entity) {
-                entities[i] = entity;
-            }
-            else {
-                (idsToLoad ??= []).push(id);
-                (positionsToLoad ??= []).push(i);
-            }
-        }
-        if (idsToLoad && idsToLoad.length > 0) {
-            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
-                .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
-                .catch(function loadAll(err) {
-                throw appendStack(err, new Error());
-            });
-            for (const i of positionsToLoad) {
-                entities[i] = this.findExistingInstance(ids[i]);
-            }
-        }
-        let idsNotFound;
-        for (let i = 0; i < entities.length; i++) {
-            if (entities[i] === undefined) {
-                (idsNotFound ??= []).push(ids[i]);
-            }
-        }
-        if (idsNotFound) {
-            throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
-        }
-        const loadedEntities = entities;
-        if (hint) {
-            await this.populate(loadedEntities, hint);
-        }
-        if (meta.inheritanceType === "sti" && meta.baseType) {
-            const wrongType = loadedEntities.filter((e) => !(e instanceof meta.cstr));
-            if (wrongType.length > 0) {
-                throw new Error(`${wrongType.join(", ")} were not of type ${meta.cstr.name}`);
-            }
-        }
-        return loadedEntities;
-    }
-    async loadAllIfExists(type, _ids, hint) {
-        const meta = (0, index_1.getMetadata)(type);
-        // Use pre-allocated arrays/for loops instead of `.filter`s since this can be a hot spot
-        const ids = new Array(_ids.length);
-        const entities = [];
-        let idsToLoad;
-        // Ensure the ids are tagged, and find any not-yet-loaded
-        for (let i = 0; i < _ids.length; i++) {
-            const id = (0, index_1.tagId)(meta, _ids[i]);
-            ids[i] = id;
-            const entity = this.findExistingInstance(id);
-            if (entity) {
-                entities.push(entity);
-            }
-            else {
-                (idsToLoad ??= []).push(id);
-            }
-        }
-        if (idsToLoad && idsToLoad.length > 0) {
-            await (0, loadBatchLoader_1.loadBatchLoader)(this, meta)
-                .loadAll(idsToLoad.map((id) => ({ taggedId: id, hint })))
-                .catch(function loadAllIfExists(err) {
-                throw appendStack(err, new Error());
-            });
-            // Now that everything is loaded, recalc `entities`
-            entities.length = 0;
-            for (const id of ids) {
-                const entity = this.findExistingInstance(id);
-                if (entity)
-                    entities.push(entity);
-            }
-        }
-        if (hint) {
-            await this.populate(entities, hint);
-        }
-        return entities;
-    }
-    async loadLens(entities, fn, populate) {
-        const result = await (0, index_1.loadLens)(entities, fn);
-        if (populate) {
-            await this.populate(result, populate);
-        }
-        return result;
-    }
-    loadFromQuery(type, rows, populate) {
-        if (Array.isArray(rows)) {
-            const entities = this.hydrate(type, rows);
-            if (populate)
-                return this.populate(entities, populate);
-            return entities;
-        }
-        else {
-            return rows.then((rows) => {
-                const entities = this.hydrate(type, rows);
-                if (populate)
-                    return this.populate(entities, populate);
-                return entities;
-            });
-        }
-    }
-    async loadFromRows(type, rows, populate) {
-        const entities = this.hydrate(type, rows);
-        if (populate) {
-            await this.populate(entities, populate);
-        }
-        return entities;
-    }
-    async populate(entityOrList, hintOrOpts, fn) {
-        const { hint: hintOpt, ...opts } = typeof hintOrOpts === "object" && "hint" in hintOrOpts ? hintOrOpts : { hint: hintOrOpts };
-        // Tell `AsyncMethodImpl.load` to not invoke its function
-        opts[hasAsyncMethod_1.AsyncMethodPopulateSecret] = true;
-        // I'm tempted to throw an error here, because at least internal callers should ideally pre-check
-        // that `list > 0` and `Object.keys(hint).length > 0` before calling `populate`, just as an optimization.
-        // But since it's a public API, we should just early exit.
-        const list = (0, utils_1.toArray)(entityOrList).filter((e) => {
-            // Check `isDeletedAndFlushed` so that pending-delete entities are still populated,
-            // because their hooks might do `getWithDeleted` calls and expect them to be loaded.
-            return e !== undefined && !(0, BaseEntity_1.getInstanceData)(e).isDeletedAndFlushed;
-        });
-        if (list.length === 0) {
-            return !fn ? entityOrList : fn(entityOrList);
-        }
-        // Avoid building a HintTree/batchloader for persisted entities when everything is already loaded; in the phase 9
-        // benchmark this moved already-loaded populates from ~1.10ms to ~0.89ms, and nested already-loaded populates from
-        // ~2.39ms to ~1.94ms.
-        if (!opts.forceReload && list.every((entity) => !entity.isNewEntity && (0, loadHints_1.isLoadedForPopulate)(entity, hintOpt))) {
-            return fn ? fn(entityOrList) : entityOrList;
-        }
-        const meta = (0, index_1.getMetadata)(list[0]);
-        if (this.#preloader) {
-            // If we can preload, prevent promise deadlocking by one large-batch preload populate (which can't have
-            // intra dependencies), then a 2nd small-batch non-preload populate.
-            const [preload, non] = this.#preloader.partitionHint(meta, hintOpt);
-            if (preload) {
-                const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, preload, "preload", opts);
-                await loader.loadAll(list.map((entity) => ({ entity, hint: preload }))).catch(function populate(err) {
-                    throw appendStack(err, new Error());
-                });
-            }
-            if (non) {
-                const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, non, "intermixed", opts);
-                await loader.loadAll(list.map((entity) => ({ entity, hint: non }))).catch(function populate(err) {
-                    throw appendStack(err, new Error());
-                });
-            }
-        }
-        else {
-            const loader = (0, populateBatchLoader_1.populateBatchLoader)(this, meta, hintOpt, "intermixed", opts);
-            await loader.loadAll(list.map((entity) => ({ entity, hint: hintOpt }))).catch(function populate(err) {
-                throw appendStack(err, new Error());
-            });
-        }
-        return fn ? fn(entityOrList) : entityOrList;
-    }
-    // For debugging EntityManager.populate.test.ts's "can be huge"
-    // populates: Record<string, number> = {};
-    /**
-     * Executes `fn` with a transaction, and automatically calls `flush`/`commit` at the end.
-     *
-     * This ensures both any `.find` and `.flush` operations happen within the same
-     * transaction, which is useful for enforcing cross-table/application-level invariants that
-     * cannot be enforced with database-level constraints.
-     */
-    async transaction(fn) {
-        return this.driver.transaction(this, async (txn) => {
-            const result = await fn(txn);
-            // The lambda may have done some interstitial flushes (that would not
-            // have committed the transaction), but go ahead and do a final one
-            // in case they didn't explicitly call flush.
-            await this.flush();
-            return result;
-        });
-    }
-    delete(entityOrArray) {
-        for (const entity of (0, utils_1.toArray)(entityOrArray)) {
-            // Early return if already deleted.
-            const alreadyMarked = (0, BaseEntity_1.getInstanceData)(entity).markDeleted();
-            if (!alreadyMarked)
-                continue;
-            // This monotonic flag lets find hot paths skip scanning results until a delete has ever happened in this EM.
-            this.#hasAnyDeletes = true;
-            // Any derived fields that read this entity will need recalc-d
-            this.#rm.queueAllDownstreamFields(entity, "deleted");
-            // Synchronously unhook the entity if the relations are loaded
-            getCascadeDeleteRelations(entity).forEach((r) => r.maybeCascadeDelete());
-            // And queue the cascade deletes
-            this.#pendingDeletes.push(entity);
-        }
-    }
-    async assignNewIds() {
-        let pendingEntities = this.entities.filter((e) => e.isNewEntity && !e.isDeletedEntity && !e.idTaggedMaybe);
-        await this.getLoader("assign-new-ids", "global", async (entities) => {
-            let todos = (0, Todo_1.createTodos)(entities);
-            await this.driver.assignNewIds(this, todos);
-            for (const e of entities)
-                this.#entitiesById.set(e.idTagged, e);
-            return entities;
-        })
-            .loadMany(pendingEntities)
-            .catch(function assignNewIds(err) {
-            throw appendStack(err, new Error());
-        });
-    }
-    /**
-     * Immediately assigns async defaults to `entities`.
-     *
-     * Normally async defaults wait until `em.flush` to run, because their async nature requires
-     * an `await` / `Promise` to be evaluated, and `em.create` is synchronous.
-     *
-     * This `assignDefaults` methods like you move that up, and immediately invoke
-     * any default logic against the `entities`.
-     */
-    async setDefaults(entities) {
-        return (0, trusted_1.runInTrustedContext)(async () => {
-            const suppressedTypeErrors = [];
-            const entitiesByType = (0, utils_1.groupBy)(entities.filter((e) => e.isNewEntity), (e) => (0, index_1.getMetadata)(e));
-            await (0, defaults_1.setAsyncDefaults)(suppressedTypeErrors, this.ctx, entitiesByType);
-        });
-    }
-    /**
-     * Flushes the SQL for any changed entities to the database.
-     *
-     * If this is run outside of an existing transaction, it will `BEGIN` and `COMMIT`
-     * a new transaction on every `.flush()` call so that all of the `INSERT`s/etc.
-     * happen atomically.
-     *
-     * If this is run within an existing transaction, i.e. `EntityManager.transaction`,
-     * then it will only issue `INSERT`s/etc. and defer to the caller to `COMMIT`
-     * the transaction.
-     *
-     * It returns entities that have changed (an entity is considered changed if it has been deleted, inserted, or updated)
-     */
-    async flush(flushOptions = {}) {
-        return (0, trusted_1.runInTrustedContext)(() => this.#flush(flushOptions));
-    }
-    async #flush(flushOptions = {}) {
-        if (this.mode === "read-only")
-            throw new ReadOnlyError();
-        const { skipValidation = false } = flushOptions;
-        this.#fl.startLock();
-        const allFlushedEntities = new Set();
-        try {
-            await this.#fl.allowWrites(async () => {
-                // Cascade deletes now that we're async (i.e. to keep `em.delete` synchronous).
-                // Also do this before calling `recalcPendingReactables` to avoid recalculating
-                // fields on entities that will be deleted (and probably have unset/invalid FKs
-                // that would NPE their logic anyway).
-                await this.flushDeletes();
-                // Recalc before we run hooks, so the hooks will see the latest calculated values.
-                await this.#rm.recalcPendingReactables("reactables");
-            });
-            const createdThenDeleted = new Set();
-            // We'll only invoke hooks once/entity (the 1st time that entity goes through runHooksOnPendingEntities)
-            const hooksInvoked = new Set();
-            // Make sure two AsyncReactiveFields don't ping-pong each other forever
-            let hookLoops = 0;
-            let now = getNow();
-            const suppressedDefaultTypeErrors = [];
-            // Make a lambda that we can invoke multiple times, if we loop for AsyncReactiveFields
-            const runHooksOnPendingEntities = async () => {
-                if (hookLoops++ >= 10)
-                    throw new Error("runHooksOnPendingEntities has ran 10 iterations, aborting");
-                // Resolve any pending o2m/m2m sets (set() called before load — need to load from DB to diff)
-                const pendingLoads = [...getEmInternalApi(this).pendingLoads];
-                if (pendingLoads.length > 0) {
-                    getEmInternalApi(this).pendingLoads.clear();
-                    await Promise.all(pendingLoads.map((collection) => collection.load()));
-                }
-                // Any dirty entities we find, even if we skipped firing their hooks on this loop
-                const pendingFlush = new Set();
-                // Subset of pendingFlush entities that we will run hooks on
-                const pendingHooks = new Set();
-                // Subset of pendingFlush entities that had hooks invoked in a prior `runHooksOnPendingEntities`
-                const alreadyRanHooks = new Set();
-                findPendingFlushEntities(this.#maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
-                // If we're re-looping for AsyncReactiveField, make sure to bump updatedAt
-                // each time, so that for an INSERT-then-UPDATE the triggers don't think the
-                // UPDATE forgot to self-bump updatedAt, and then "helpfully" bump it for us.
-                if (alreadyRanHooks.size > 0) {
-                    maybeBumpUpdatedAt(this.#rm, (0, Todo_1.createTodos)([...alreadyRanHooks]), now);
-                }
-                // Run hooks in a series of loops until things "settle down"
-                while (pendingHooks.size > 0) {
-                    await this.#fl.allowWrites(async () => {
-                        let todos = (0, Todo_1.createTodos)([...pendingHooks]);
-                        await (0, defaults_1.setAsyncDefaults)(suppressedDefaultTypeErrors, this.ctx, Todo_1.Todo.groupInsertsByTypeAndSubType(todos));
-                        maybeBumpUpdatedAt(this.#rm, todos, now);
-                        // Run our hooks
-                        for (const group of maybeSetupHookOrdering(todos)) {
-                            await beforeCreate(this.ctx, group);
-                            await beforeUpdate(this.ctx, group);
-                            await beforeFlush(this.ctx, group);
-                        }
-                        // Call `setField` just to get the column marked as dirty if needed.
-                        // This can come after the hooks, b/c if the hooks read any of these
-                        // fields, they'd be via the synchronous getter and would not be stale.
-                        recalcSynchronousDerivedFields(todos);
-                        // The hooks could have deleted this-loop or prior-loop entities, so re-cascade again.
-                        // Reactions (the recalc below) can themselves `em.delete` entities, so keep draining
-                        // until both deletes and recalcs have settled.
-                        do {
-                            await this.flushDeletes();
-                            // The hooks could have changed fields, so recalc again.
-                            await this.#rm.recalcPendingReactables("reactables");
-                        } while (this.#pendingDeletes.length > 0);
-                        // We may have reactables that failed earlier, but will succeed now that hooks have been run and cascade
-                        // deletes have been processed
-                        if (this.#rm.hasPendingTypeErrors) {
-                            await this.#rm.recalcPendingTypeErrors();
-                            // We need to re-run reactables again if we dirtied something while retrying type errors
-                            if (this.#rm.needsRecalc("reactables"))
-                                await this.#rm.recalcPendingReactables("reactables");
-                        }
-                        for (const e of pendingHooks)
-                            hooksInvoked.add(e);
-                        pendingHooks.clear();
-                        // See if the hooks mutated any new, not-yet-hooksInvoked entities
-                        findPendingFlushEntities(this.#maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
-                        // The final run of recalcPendingReactables could have left us with pending type errors and no entities in
-                        // pendingHooks.  If so, we need to re-run recalcPendingTypeErrors to get those errors to transition into
-                        // suppressed errors so that we will fail after simpleValidation.
-                        if (pendingHooks.size === 0 && this.#rm.hasPendingTypeErrors)
-                            await this.#rm.recalcPendingTypeErrors();
-                    });
-                }
-                // We might have invoked hooks that immediately deleted a new entity (weird but allowed);
-                // if so, filter it out so that we don't flush it, but keep track for later fixing up
-                // it's `#orm.deleted` field.
-                return [...pendingFlush].filter((e) => {
-                    const createThenDelete = e.isDeletedEntity && e.isNewEntity;
-                    if (createThenDelete)
-                        createdThenDeleted.add(e);
-                    return !createThenDelete;
-                });
-            };
-            const { pluginManager } = getEmInternalApi(this);
-            const runValidation = async (entityTodos, joinRowTodos, validate) => {
-                const changedEntities = entitiesFromTodos(entityTodos, joinRowTodos);
-                try {
-                    this.#isValidating = true;
-                    await pluginManager.beforeValidate(changedEntities);
-                    if (validate) {
-                        // Run simple rules first b/c it includes not-null/required rules, so that then when we run
-                        // `validateReactiveRules` next, the app's lambdas won't see fundamentally invalid entities & NPE.
-                        await validateSimpleRules(entityTodos);
-                        // After we've let any "author is not set" simple rules fail before prematurely throwing
-                        // the "of course that caused an NPE" `TypeError`s, if all the authors *were* valid/set,
-                        // and we still have TypeErrors (from derived valeus), they were real, unrelated errors
-                        // that the user should see.
-                        if (suppressedDefaultTypeErrors.length > 0)
-                            throw suppressedDefaultTypeErrors[0];
-                        await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
-                        await afterValidation(this.ctx, entityTodos);
-                    }
-                    await pluginManager.afterValidate(changedEntities);
-                }
-                finally {
-                    this.#isValidating = false;
-                }
-            };
-            // Run hooks (in iterative loops if hooks mutate new entities) on pending entities
-            let entitiesToFlush = await runHooksOnPendingEntities();
-            for (const e of entitiesToFlush)
-                allFlushedEntities.add(e);
-            // Recreate todos now that we've run hooks and recalculated fields so know
-            // the full set of entities that will be INSERT/UPDATE/DELETE-d in the database.
-            let entityTodos = (0, Todo_1.createTodos)(entitiesToFlush);
-            let joinRowTodos = (0, Todo_1.combineJoinRows)(this.#joinRows);
-            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) {
-                // The driver will handle the right thing if we're already in an existing transaction.
-                await this.driver.transaction(this, async () => {
-                    do {
-                        if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
-                            await this.driver.flush(this, entityTodos, joinRowTodos);
-                        }
-                        // Now that we've flushed, we can let plugins know what we've done.
-                        pluginManager.afterWrite(entityTodos, joinRowTodos);
-                        // And we can look for ReactiveQueries that need to be recalculated
-                        if (this.#rm.hasPendingReactiveQueries()) {
-                            // Reset all flushed entities to we only flush net-new changes
-                            for (const e of entitiesToFlush) {
-                                if (e.isNewEntity && !e.isDeletedEntity)
-                                    this.#entitiesById.set(e.idTagged, e);
-                                (0, BaseEntity_1.getInstanceData)(e).resetForRqfLoop();
-                            }
-                            // Actually do the recalc
-                            await this.#fl.allowWrites(async () => {
-                                await this.#rm.recalcPendingReactables("reactiveQueries");
-                                // If any ReactiveFields depended on AsyncReactiveFields, go ahead and calc those now
-                                await this.#rm.recalcPendingReactables("reactables");
-                            });
-                            // Advance `now` so that our triggers don't think our UPDATEs are forgetting to self-bump
-                            // updated_at, and bump it themselves, which could cause a subsequent error.
-                            now = getNow();
-                            // See if any RQFs actually changed any entities. If they did, run the hooks on them.
-                            entitiesToFlush = await runHooksOnPendingEntities();
-                            for (const e of entitiesToFlush)
-                                allFlushedEntities.add(e);
-                            // Recreate `entityTodos` against the only-the-just-changed entities
-                            entityTodos = (0, Todo_1.createTodos)(entitiesToFlush);
-                            joinRowTodos = (0, Todo_1.combineJoinRows)(this.#joinRows);
-                            await runValidation(entityTodos, joinRowTodos, true);
-                            this.#rm.throwIfAnySuppressedTypeErrors();
-                        }
-                        else {
-                            // Exit the loop
-                            entityTodos = {};
-                        }
-                    } while (Object.keys(entityTodos).length > 0);
-                    // Run `beforeCommit once right before COMMIT
-                    await beforeCommit(this.ctx, allFlushedEntities);
-                    if (this.mode === "in-memory-writes") {
-                        throw new InMemoryRollbackError();
-                    }
-                });
-                // TODO: This is really "after flush" if we're being called from a transaction that
-                // is going to make multiple `em.flush()` calls?
-                await afterCommit(this.ctx, allFlushedEntities);
-                // Update the `#orm` field to reflect the new state
-                for (const e of allFlushedEntities) {
-                    if (e.isNewEntity && !e.isDeletedEntity)
-                        this.#entitiesById.set(e.idTagged, e);
-                    (0, BaseEntity_1.getInstanceData)(e).resetAfterFlushed();
-                    // Reset AsyncQueryProperties since DB state may have changed
-                    for (const rel of Object.values((0, BaseEntity_1.getInstanceData)(e).relations)) {
-                        if (rel instanceof AsyncProperty_1.AsyncPropertyImpl)
-                            rel.resetAfterFlush();
-                    }
-                }
-                // Update the joinRows refs to reflect the new state
-                for (const joinRow of Object.values(joinRowTodos)) {
-                    joinRow.resetAfterFlushed();
-                }
-                const { mutatedCollections } = getEmInternalApi(this);
-                for (const o2m of mutatedCollections.values()) {
-                    o2m.resetAddedRemoved();
-                }
-                mutatedCollections.clear();
-                // Reset the find/preload caches b/c data will have changed in the db
-                this.#dataloaders = {};
-                this.#batchLoaders = {};
-                this.#preloadedRelations = new Map();
-                this.#rm.clear();
-            }
-            // Fixup the `deleted` field on entities that were created then immediately deleted
-            for (const e of createdThenDeleted)
-                (0, BaseEntity_1.getInstanceData)(e).fixupCreatedThenDeleted();
-            this.#merging?.clear();
-            return [...allFlushedEntities].sort((a, b) => (0, BaseEntity_1.getInstanceData)(a).entityIndex - (0, BaseEntity_1.getInstanceData)(b).entityIndex);
-        }
-        catch (e) {
-            if (e instanceof RecursiveCollection_1.RecursiveCycleError) {
-                const entity = e.entities[0];
-                // Look up a custom cycle message — check both the exact field name and its opposite
-                // direction, since the cycle may be detected from either side (e.g. walking
-                // childrenRecursive during reactive hint reversal when parentsRecursive was configured).
-                for (const meta of (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity))) {
-                    const messageFn = meta.config.__data.cycleMessages[e.fieldName] ??
-                        meta.config.__data.cycleMessages[entity[e.fieldName]?.otherFieldName];
-                    if (messageFn) {
-                        throw new index_1.ValidationErrors([{ entity, message: messageFn(entity, e.entities) }]);
-                    }
-                }
-            }
-            if (e && typeof e === "object" && "constraint" in e && typeof e.constraint === "string") {
-                // node-pg errors use `constraint` to indicate the constraint name
-                const message = config_1.constraintNameToValidationError[e.constraint];
-                if (message) {
-                    throw new index_1.ValidationErrors(message);
-                }
-            }
-            if (e instanceof InMemoryRollbackError) {
-                return [...allFlushedEntities].sort((a, b) => (0, BaseEntity_1.getInstanceData)(a).entityIndex - (0, BaseEntity_1.getInstanceData)(b).entityIndex);
-            }
-            throw e;
-        }
-        finally {
-            this.#rm.clearSuppressedTypeErrors();
-            this.#fl.releaseLock();
-            (0, newTestInstance_1.resetFactoryCreated)();
-        }
-    }
-    /**
-     * A very simple toJSON.
-     *
-     * This is not really meant to be useful, it's to prevent huge/circular output if
-     * an EntityManager accidentally ends up getting logged to something like pino that
-     * over-zealous toJSONs anything it touches.
-     */
-    toJSON() {
-        return `<EntityManager ${this.entities.length}>`;
-    }
-    async refresh(param) {
-        this.#isRefreshing = true;
-        this.#dataloaders = {};
-        this.#batchLoaders = {};
-        this.#preloadedRelations = new Map();
-        const deepLoad = param && "deepLoad" in param && param.deepLoad;
-        let todo = param === undefined
-            ? this.#entitiesArray
-            : Array.isArray(param)
-                ? param
-                : (0, Entity_1.isEntity)(param)
-                    ? [param]
-                    : this.#entitiesArray;
-        const done = new Set();
-        while (todo.length > 0) {
-            const copy = [...todo];
-            copy.forEach((e) => done.add(e));
-            todo = [];
-            // For any non-deleted entity with an id, get its latest data + relations from the database
-            const entitiesToRefresh = copy.filter((e) => e.idTaggedMaybe && !e.isDeletedEntity);
-            await Promise.all(entitiesToRefresh.map((entity) => {
-                // Pass loaded/all relation names as a hint so the preloader can inject JOINs
-                const hint = (0, index_1.getRelationEntries)(entity)
-                    .filter(([_, r]) => deepLoad || r.isLoaded)
-                    .map(([k]) => k);
-                return (0, loadBatchLoader_1.loadBatchLoader)(this, (0, index_1.getMetadata)(entity), true)
-                    .load({ taggedId: entity.idTagged, hint })
-                    .catch(function refresh(err) {
-                    throw appendStack(err, new Error());
-                });
-            }));
-            // Then refresh any loaded relations (the loadBatchLoader only hydrates the entity
-            // data, it doesn't get each relation into a loaded state.)
-            const [custom, builtin] = (0, utils_1.partition)(entitiesToRefresh
-                .filter((e) => !(0, BaseEntity_1.getInstanceData)(e).isDeletedEntity)
-                .flatMap((entity) => (0, index_1.getRelations)(entity).filter((r) => deepLoad || r.isLoaded)), isCustomRelation);
-            // Call `.load` on builtin relations first, because if we hit an already-loaded custom relation
-            // first, it will call `.get` internally, and might access built-in relations that we've not had a
-            // chance to `.load()` yet.
-            await Promise.all(builtin.map((r) => {
-                // If the relation is already loaded, we need to go through .load({ forceReload }), otherwise
-                // use preload to avoid the promise.
-                if (r.isPreloaded && !r.isLoaded) {
-                    r.preload();
-                    return undefined;
-                }
-                else {
-                    return r.load({ forceReload: true });
-                }
-            }));
-            await Promise.all(custom.map((r) => r.load({ forceReload: true })));
-            // If deep loading, get all entity/entities in the relation and push them on the list
-            if (deepLoad) {
-                todo.push(
-                // We skip recursing into CustomCollections and CustomReferences and PersistedAsyncReferencesImpl for two reasons:
-                // 1. It can be tricky to ensure `{ forceReload: true }` is passed all the way through their custom load
-                // implementations, and so it's easy to have `.get` accidentally come across a not-yet-loaded collection, and
-                // 2. Any custom load functions should use the underlying o2m/m2o/etc relations anyway, so if we crawl/refresh
-                // those, then when the user calls `.get` on custom collections/references, they should be talking to always-loaded
-                // relations, w/o us having to tackle the tricky bookkeeping problem passing `forceReload` all through their
-                // custom load function + any other collections they call.
-                ...builtin
-                    .filter((r) => "get" in r)
-                    .map((r) => r.get)
-                    .flatMap((value) => (Array.isArray(value) ? value : [value]))
-                    .filter((value) => (0, Entity_1.isEntity)(value) && !done.has(value)));
-            }
-        }
-        this.#isRefreshing = false;
-    }
-    get numberOfEntities() {
-        return this.entities.length;
-    }
-    // Handles our Unit of Work-style look up / deduplication of entity instances.
-    // Currently only public for the driver impls
-    findExistingInstance(id) {
-        return this.#entitiesById.get(id);
-    }
-    /**
-     * Takes a result `row` from a custom query and maps the db values into a new-or-existing domain object for that row.
-     *
-     * The `overwriteExisting` controls whether `row`'s values should overwrite the existing fields on
-     * an entity. By default this is true, as we assume the user calling this means they know the DB has
-     * updated values that should be put into the entities. A few internal callers set this to false,
-     * i.e. when we're loading collections and have db results that are potentially stale compared to
-     * the WIP entity state.
-     */
-    hydrate(type, rows, options) {
-        const maybeBaseMeta = (0, index_1.getMetadata)(type);
-        const taggedIdPrefix = `${maybeBaseMeta.tagName}:`;
-        const overwriteExisting = options?.overwriteExisting === true;
-        let i = 0;
-        const entities = new Array(rows.length);
-        for (const row of rows) {
-            const id = row["id"];
-            const taggedId = id === undefined || id === null ? (0, utils_1.fail)("No id column was available") : `${taggedIdPrefix}${id}`;
-            // See if this is already in our UoW
-            let entity = this.findExistingInstance(taggedId);
-            if (!entity) {
-                // Look for __class from the driver telling us which subtype to instantiate
-                const meta = findConcreteMeta(maybeBaseMeta, row);
-                // Pass id as a hint that we're in hydrate mode
-                entity = (0, newEntity_1.newEntity)(this, (0, index_1.asConcreteCstr)(meta.cstr), false);
-                (0, BaseEntity_1.getInstanceData)(entity).row = row;
-                this.#doRegister(entity, taggedId, meta, true);
-            }
-            else if (overwriteExisting) {
-                // Usually if the entity already exists, we don't write over it, but in this case we assume that
-                // `EntityManager.refresh` is telling us to explicitly load the latest data.
-                // First swap out the old row with the new row
-                const instanceData = (0, BaseEntity_1.getInstanceData)(entity);
-                instanceData.row = row;
-                // And then only refresh the data keys that have already been serde-d from rows
-                // (this keeps us from deserializing data out of rows that we don't need).
-                const { data } = instanceData;
-                const dataKeys = Object.keys(data);
-                if (dataKeys.length > 0) {
-                    const allFields = (0, index_1.getMetadata)(entity).allFields;
-                    const changedFields = entity.changes.fieldsWithoutRelations;
-                    if (changedFields.length === 0) {
-                        for (const fieldName of dataKeys) {
-                            const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
-                            serde.setOnEntity(data, row);
-                        }
-                    }
-                    else {
-                        for (const fieldName of dataKeys) {
-                            const serde = allFields[fieldName].serde ?? (0, utils_1.fail)(`Missing serde for ${fieldName}`);
-                            serde.setOnEntity(data, row);
-                            // Make the field look not-dirty
-                            if (changedFields.includes(fieldName)) {
-                                instanceData.markFieldClean(fieldName);
-                            }
-                        }
-                    }
-                }
-            }
-            entities[i++] = entity;
-        }
-        return entities;
-    }
-    touch(entityOrEntities) {
-        for (const entity of (0, utils_1.toArray)(entityOrEntities)) {
-            (0, BaseEntity_1.getInstanceData)(entity).markTouched();
-        }
-    }
-    async recalc(entityOrEntities) {
-        // Look for async reactive fields
-        const relations = (0, utils_1.toArray)(entityOrEntities).flatMap((entity) => Object.values((0, index_1.getMetadata)(entity).allFields)
-            .filter((f) => "derived" in f && f.derived === "async")
-            .map((field) => entity[field.fieldName]));
-        // Use forceReload: true to tell ReactiveReferences to recalc against their full graph
-        await Promise.all(relations.map((r) => r.load({ forceReload: true })));
-        // And also sync reactive fields
-        (0, utils_1.toArray)(entityOrEntities).flatMap((entity) => Object.values((0, index_1.getMetadata)(entity).allFields)
-            .filter((f) => "derived" in f && f.derived === "sync")
-            .forEach((field) => {
-            // This will be a noop if the value is the same
-            (0, fields_1.setField)(entity, field.fieldName, entity[field.fieldName]);
-        }));
-        // `.load()` recalculated the immediate relations, go ahead and recalc any downstream reactables.
-        // We'll still defer AsyncReactiveFields to the em.flush loop.
-        await this.#rm.recalcPendingReactables("reactables");
-    }
-    beforeBegin(fn) {
-        this.#hooks.beforeBegin.push(fn);
-    }
-    afterBegin(fn) {
-        this.#hooks.afterBegin.push(fn);
-    }
-    beforeCommit(fn) {
-        this.#hooks.beforeCommit.push(fn);
-    }
-    afterCommit(fn) {
-        this.#hooks.afterCommit.push(fn);
-    }
-    /**
-     * Returns an EntityManager-scoped (i.e. request scoped) data loader.
-     *
-     * @param operation the operation being batched, i.e. `load` or `o2m-load`, to avoid clashing batch keys
-     *   across fundamentally different operations
-     * @param batchKey for a given operation, i.e. `load`, a batch key `Author` to batch all Author loads together
-     * @param fn the batch load function, i.e. that will accept all `.load(...)`-d Author ids to load as a single db call
-     * @param opts optional DataLoader options
-     * @returns a DataLoader scoped to the `operation` + `batchKey` combination
-     */
-    getLoader(operation, batchKey, fn, opts) {
-        // If we wanted to, if not in a transaction, we could potentially do lookups against a global cache,
-        // to achieve cross-request batching. Granted we'd need all DataLoaders to have caching disabled, see:
-        // https://github.com/joist-orm/joist-orm/issues/629
-        const loadersForKind = (this.#dataloaders[operation] ??= {});
-        return (0, utils_1.getOrSet)(loadersForKind, batchKey, () => new dataloader_1.default(fn, opts));
-    }
-    /**
-     * Like `getLoader`, but returns a `BatchLoader` where all callers in the same tick
-     * share a single `Promise<void>` instead of getting per-key promises.
-     *
-     * The batch function should write results via side channels (e.g. `setPreloadedRelation`).
-     */
-    getBatchLoader(operation, batchKey, fn) {
-        const loadersForKind = (this.#batchLoaders[operation] ??= {});
-        return (0, utils_1.getOrSet)(loadersForKind, batchKey, () => new BatchLoader_1.BatchLoader(fn));
-    }
-    toString() {
-        return "EntityManager";
-    }
-    /** Recursively cascades any pending deletions. */
-    async flushDeletes() {
-        let entities = this.#pendingDeletes;
-        if (entities.length === 0)
-            return;
-        this.#pendingDeletes = [];
-        let relationsToCleanup = [];
-        // Loop if our deletes cascade to other deletes
-        while (entities.length > 0) {
-            // For cascade delete relations, cascade the delete...
-            const p = entities.flatMap(getCascadeDeleteRelations).map((r) => r.load().then(() => r.maybeCascadeDelete()));
-            await Promise.all(p);
-            // Run the beforeDelete hook before we unhook the entity
-            const todos = (0, Todo_1.createTodos)(entities);
-            await beforeDelete(this.ctx, todos);
-            // For all relations, unhook the entity from the other side; this append path is optimized for
-            // large deletes with ~100k relations by avoiding `flatMap` intermediates and `concat` copies.
-            for (const entity of entities) {
-                const relations = (0, index_1.getRelations)(entity);
-                const start = relationsToCleanup.length;
-                relationsToCleanup.length += relations.length;
-                for (let i = 0; i < relations.length; i++) {
-                    relationsToCleanup[start + i] = relations[i];
-                }
-            }
-            entities = this.#pendingDeletes;
-            this.#pendingDeletes = [];
-        }
-        // For all relations, unhook the entity from the other side
-        await Promise.all(relationsToCleanup.map((r) => r.cleanupOnEntityDeleted()));
-    }
-    setReactionLogging(arg) {
-        this.#rm.setLogger(typeof arg === "boolean" ? (arg ? new index_1.ReactionLogger() : undefined) : arg);
-    }
-    setFieldLogging(arg) {
-        if (arg instanceof index_1.FieldLogger) {
-            this.#fieldLogger = arg;
-            return;
-        }
-        const writeFn = getDefaultWriteFn(this.ctx);
-        if (typeof arg === "boolean") {
-            this.#fieldLogger = arg ? new index_1.FieldLogger([], writeFn) : undefined;
-        }
-        else if (typeof arg === "string" || Array.isArray(arg)) {
-            const specs = Array.isArray(arg) ? arg : [arg];
-            const watching = specs.map((spec) => {
-                // Regex to match Author.firstName,lastName! pattern
-                const regex = /^([^.!]+)(?:\.([^!]*))?(!)?$/;
-                const [_, entity, fields, breakpoint] = spec.match(regex) ?? (0, utils_1.fail)(`Unsupported spec ${spec}`);
-                const fieldNames = fields?.split(",");
-                // Ensure entity is valid, to avoid failing silently
-                const meta = (0, configure_1.getMetadataForType)(entity);
-                // Ensure the field names are valid, to avoid failing silently
-                fieldNames?.forEach((field) => {
-                    // We could probably check the `kind`, b/c things like o2o/o2m are not supported atm
-                    if (!meta.allFields[field]) {
-                        throw new Error(`Field ${field} not found on ${entity}`);
-                    }
-                });
-                return { entity, fieldNames, breakpoint: !!breakpoint };
-            });
-            this.#fieldLogger = new index_1.FieldLogger(watching, writeFn);
-        }
-        else {
-            throw new Error("Unsupported override for setFieldLogging");
-        }
-    }
-    async [Symbol.asyncDispose]() {
-        await this.flush();
-    }
-    /** Returns entities matching the filter using indexed search when available. */
-    filterEntities(cstr, where) {
-        const meta = (0, index_1.getMetadata)(cstr);
-        const entities = this.#entitiesByTag.get(meta.tagName) ?? [];
-        // Don't bother filtering if there's no where clause (particularly b/c IndexManager.findMatching
-        // really expects there to be at least 1 condition)
-        if (Object.entries(where).length === 0) {
-            return entities.filter((e) => e instanceof cstr && !e.isDeletedEntity);
-        }
-        if (this.#indexManager.shouldIndexType(entities.length)) {
-            this.#indexManager.enableIndexingForType(meta, entities, where);
-            return (this.#indexManager
-                .findMatching(meta, entities, where)
-                // Still filter by `instanceof cstr` to handle subtyping
-                .filter((e) => e instanceof cstr && !e.isDeletedEntity));
-        }
-        else {
-            return entities
-                // Still filter by `instanceof cstr` to handle subtyping
-                .filter((e) => e instanceof cstr && !e.isDeletedEntity && (0, findOrCreateDataLoader_1.entityMatches)(e, where));
-        }
-    }
-    /**
-     * Creates a new EntityManager that shares the same entities as the current one but allows independent changes.
-     *
-     * This is useful for scenarios where you want to:
-     *
-     * - Preload data for use as a cache
-     * - Make speculative changes that may or may not be committed
-     * - Escape a transaction scope
-     *
-     * The fork will:
-     *
-     * - Copy all currently loaded entities to the new EntityManager
-     * - Copy any loaded relation data to keep `.isLoaded` / `.get` state consistent
-     * - Copy and update references to the EntityManager and its entities in the context, which is itself shallowly copied
-     *
-     * The fork will NOT:
-     *
-     * - Copy any pending changes (must call .flush() first)
-     * - Share any changes made in either EntityManager with the other
-     *
-     * @param opts options to control the fork behavior
-     *  - allowPendingChanges - allows the em being forked to have pending changes and forces the resulting em to have
-     *  `mode` set to "in-memory-writes".  Changes to entities in the original em will be copied to the resulting em.
-     *  Optional. default: false
-     *
-     * @throws {Error} If called on an EntityManager with pending changes
-     * @returns A new EntityManager with copied entity state
-     */
-    fork(opts = {}) {
-        const { allowPendingChanges = false } = opts;
-        const oldEm = this;
-        // copy the context so that it's distinct between the two ems, and so we can update any references from the old em
-        // to the new one later
-        const ctx = { ...oldEm.ctx };
-        const newEm = new EntityManager(ctx, { em: oldEm });
-        if (allowPendingChanges)
-            newEm.mode = "in-memory-writes";
-        // hydrate (ie, create) each entity from the oldEm in the newEm
-        for (const [tag, entities] of oldEm.#entitiesByTag.entries()) {
-            // tags are always defined by the base constructor, so we use that as hydrate expects the base class as its argument
-            const baseCstr = (0, configure_1.getConstructorFromTag)(tag);
-            let rows = new Array(entities.length);
-            let i = 0;
-            for (const entity of entities) {
-                const instanceData = entity.__data;
-                if (!allowPendingChanges && instanceData.pendingOperation !== "none") {
-                    (0, utils_1.fail)("Cannot fork an EntityManager with pending changes");
-                }
-                else if (instanceData.isNewEntity) {
-                    // Create blank entities in newEm for each unpersisted entity from oldEm.  They will be populated later in the
-                    // allowPendingChanges step as they should not be present otherwise.
-                    // (I'd thought we should copy over `InstanceData.createId`, but since we're iterating over `oldEm.#entitiesByTag`
-                    // in stable as-created order, the `newEm.create` will assign the same/incrementing `createId`s as in oldEm.)
-                    newEm.create(entity.constructor, {});
-                }
-                else {
-                    // We copy the raw row data for each entity to avoid any potential conflict. Then we ensure the correct concrete
-                    // __class key is set for hydrate to use, if necessary (ie, cti), to actually instantiate the entity.
-                    rows[i] = createRowFromEntityData(entity);
-                    i++;
-                }
-            }
-            if (rows.length !== i)
-                rows = rows.slice(0, i);
-            newEm.hydrate(baseCstr, rows);
-        }
-        function mapEntity(oldEntity) {
-            if (oldEntity.isNewEntity) {
-                return newEm.#entitiesById.get(oldEntity.toTaggedString());
-            }
-            else {
-                return newEm.#entitiesById.get(oldEntity.idTagged);
-            }
-        }
-        function mapEntities(v) {
-            if (v === undefined)
-                return undefined;
-            const result = new Array(v.length);
-            for (let i = 0; i < v.length; i++)
-                result[i] = mapEntity(v[i]);
-            return result;
-        }
-        // If we are allowing pending changes, then we need to copy any changes across to newEm
-        if (allowPendingChanges) {
-            for (const oldEntity of oldEm.entities) {
-                const oldInstanceData = oldEntity.__data;
-                if (!(oldInstanceData.isNewEntity || oldInstanceData.isDirtyEntity))
-                    continue;
-                const { originalData: oldOriginalData, data: oldData } = oldInstanceData;
-                const newEntity = mapEntity(oldEntity);
-                const newInstanceData = newEntity.__data;
-                const { data: newData } = newInstanceData;
-                // for new entities, anything in `data` is changed and should be copied across. for existing entities, we
-                // only care about changed fields, which are enumerated by originalData
-                const maybeEntity = (value) => ((0, Entity_1.isEntity)(value) ? mapEntity(value) : value);
-                const fields = Object.keys(oldEntity.isNewEntity ? oldData : oldOriginalData);
-                for (const field of fields) {
-                    // copy over originalData so .changes is consistent across ems
-                    if (field in oldOriginalData)
-                        newInstanceData.markFieldDirty(field, maybeEntity(oldOriginalData[field]));
-                    newData[field] = maybeEntity(oldData[field]);
-                }
-            }
-        }
-        // import every loaded concrete (ie, not custom) relation into the new em
-        for (const oldEntity of oldEm.entities) {
-            const newEntity = mapEntity(oldEntity);
-            if (oldEntity.isDeletedEntity) {
-                // If the old entity was deleted, that should be persisted in the new em
-                newEntity.__data.markDeleted();
-                // deleted entities will fail if you try to `get` their relations, so skip them since they should be cleared
-                // out regardless
-                continue;
-            }
-            const { relations } = oldEntity.__data;
-            for (const [field, relation] of Object.entries(relations)) {
-                // With lazyRelation, custom relations are inserted into the `relations` map. Custom relations don't
-                // store any data, so we can ignore them by checking if the relation implements `import`
-                // TODO: add `import` to recursiveCollection
-                if (!("import" in relation))
-                    continue;
-                if (oldEntity.isNewEntity) {
-                    // every relation should be loaded on a new entity, so calling get should be safe
-                    const oldValue = relation.get;
-                    if (oldValue === undefined)
-                        continue;
-                    if (Array.isArray(oldValue) && oldValue.length === 0)
-                        continue;
-                    const newValue = Array.isArray(oldValue) ? mapEntities(oldValue) : mapEntity(oldValue);
-                    // we may have already copied over the instance data, in which case `setFromOpts` would detect this as
-                    // the same entity that's already set in data and early exit, so delete ourselves from data first
-                    delete newEntity.__data.data[field];
-                    newEntity[field].setFromOpts(newValue);
-                }
-                else {
-                    const isLoaded = "_isLoaded" in relation ? relation._isLoaded : relation.isLoaded;
-                    if (isLoaded)
-                        newEntity[field].import(relation, mapEntity, mapEntities);
-                }
-            }
-        }
-        // Inspect the top level keys in the context and replace any references from oldEm with newEm (ie, ctx.em === newEm)
-        // while also replacing any entities from oldEm with their version in newEm (eg, if the user is stored in the
-        // context, then `ctx.user.em === newEm`).
-        for (const [key, value] of Object.entries(ctx)) {
-            if ((0, Entity_1.isEntity)(value) && value.em === oldEm) {
-                ctx[key] = mapEntity(value);
-            }
-            else if (value === oldEm) {
-                ctx[key] = newEm;
-            }
-        }
-        return newEm;
-    }
-    importEntity(source, hint, normalizedHint) {
-        if (source.isNewEntity)
-            (0, utils_1.fail)("cannot import new entities");
-        if (source.isDeletedEntity)
-            (0, utils_1.fail)("cannot import deleted entities");
-        if (source.isDirtyEntity)
-            (0, utils_1.fail)("cannot import dirty entities");
-        hint ??= {};
-        if (!normalizedHint) {
-            (0, index_1.assertLoaded)(source, hint);
-            normalizedHint = (0, index_1.deepNormalizeHint)(hint);
-        }
-        if (source.em === this)
-            return source;
-        const meta = (0, index_1.getMetadata)(source);
-        let result = this.#entitiesById.get(source.idTagged);
-        if (!result) {
-            const meta = (0, index_1.getMetadata)(source);
-            const row = createRowFromEntityData(source);
-            result = this.hydrate((0, index_1.getBaseMeta)(meta).cstr, [row])[0];
-        }
-        for (const [fieldName, subHint] of Object.entries(normalizedHint)) {
-            const field = meta.allFields[fieldName];
-            const relationOrProp = result[fieldName];
-            if (!field) {
-                let loadHint = relationOrProp.loadHint ?? (0, utils_1.fail)(`${source}.${fieldName} cannot be imported as it has no loadHint`);
-                this.importEntity(source, loadHint);
-            }
-            else if ("import" in relationOrProp) {
-                // Tell our version of the entity (result) to accept/copy the relation state of the source
-                relationOrProp.import(source[fieldName], (e) => this.importEntity(e, subHint, subHint), (entities) => {
-                    if (entities === undefined)
-                        return undefined;
-                    const result = new Array(entities.length);
-                    for (let i = 0; i < entities.length; i++) {
-                        result[i] = this.importEntity(entities[i], subHint, subHint);
-                    }
-                    return result;
-                });
-            }
-        }
-        return result;
-    }
-    addPlugin(plugin) {
-        getEmInternalApi(this).pluginManager.addPlugin(plugin);
-    }
-    getPlugins() {
-        return getEmInternalApi(this).pluginManager.plugins;
-    }
-    get isRefreshing() {
-        return this.#isRefreshing;
-    }
-    get isFlushing() {
-        return this.#fl.isFlushing;
-    }
-    /** Creates a new `type` and marks it as loaded, i.e. we know its collections are all safe to access in memory. */
-    #doCreate(type, opts, partial) {
-        const entity = (0, newEntity_1.newEntity)(this, type, true);
-        // Assign the next `a#1`, `a#2`, etc. id
-        const meta = (0, index_1.getMetadata)(type);
-        const counter = (this.#createCounter ??= new Map());
-        const i = (counter.get(meta.tagName) ?? 0) + 1;
-        counter.set(meta.tagName, i);
-        (0, BaseEntity_1.getInstanceData)(entity).createId = String(i);
-        // Check opts.id for an explicitly-set id
-        this.#doRegister(entity, opts.id);
-        // Set a default createdAt/updatedAt
-        const baseMeta = (0, index_1.getBaseMeta)((0, index_1.getMetadata)(entity));
-        if (baseMeta.timestampFields) {
-            this.#assignTimestamps(entity, baseMeta);
-        }
-        // Set the discriminator for STI
-        if (baseMeta.inheritanceType === "sti") {
-            setStiDiscriminatorValue(baseMeta, entity);
-        }
-        // api will be undefined during getFakeInstance
-        const api = getEmInternalApi(this);
-        api?.fieldLogger?.logCreate(entity);
-        (0, index_1.setOpts)(entity, opts, { partial, calledFromConstructor: true });
-        // Apply any synchronous defaults, after the opts have been applied
-        if (!this.fakeInstance) {
-            (0, defaults_1.setSyncDefaults)(entity);
-        }
-        this.#rm.queueAllDownstreamFields(entity, "created");
-        return entity;
-    }
-    #assignTimestamps(entity, baseMeta) {
-        const { createdAt, updatedAt } = baseMeta.timestampFields ?? {};
-        const { data } = (0, BaseEntity_1.getInstanceData)(entity);
-        const now = new Date();
-        if (createdAt) {
-            const serde = baseMeta.fields[createdAt].serde;
-            data[createdAt] = serde.mapFromNow(now);
-        }
-        if (updatedAt) {
-            const serde = baseMeta.fields[updatedAt].serde;
-            data[updatedAt] = serde.mapFromNow(now);
-        }
-    }
-    /** Registers a newly-instantiated entity with our EntityManager; only called by #doCreate and hydrate. */
-    #doRegister(entity, id, meta, skipDuplicateCheck = false) {
-        // Keep our indexes up to date...
-        const maybeId = id ?? entity.idTaggedMaybe;
-        if (maybeId) {
-            if (!skipDuplicateCheck && this.findExistingInstance(maybeId) !== undefined) {
-                throw new Error(`Entity ${entity} has a duplicate instance already loaded`);
-            }
-            this.#entitiesById.set(maybeId, entity);
-        }
-        else {
-            // Also register by the `a#1` style tagged string for new entities
-            this.#entitiesById.set(entity.toTaggedString(), entity);
-        }
-        (0, BaseEntity_1.getInstanceData)(entity).entityIndex = this.#entitiesArray.length;
-        this.#entitiesArray.push(entity);
-        meta ??= (0, index_1.getMetadata)(entity);
-        const set = this.#entitiesByTag.get(meta.tagName) ?? [];
-        if (set.length === 0)
-            this.#entitiesByTag.set(meta.tagName, set);
-        set.push(entity);
-        if (this.#entitiesArray.length >= this.entityLimit) {
-            const topTypes = [...this.#entitiesByTag.entries()]
-                .map(([tag, entities]) => ({ tag, count: entities.length }))
-                .sort((a, b) => b.count - a.count)
-                .slice(0, 3)
-                .map(({ tag, count }) => `${tag}=${count}`)
-                .join(", ");
-            throw new Error(`More than ${this.entityLimit} entities have been instantiated (top entities: ${topTypes})`);
-        }
-    }
-}
-exports.EntityManager = EntityManager;
+* The EntityManager is the primary way nearly all code, i.e. anything that finds/creates/updates/deletes entities,
+* will interact with the database.
+*
+* It acts both an Identity Cache (preventing loading the same row twice into memory as separate entities, and then
+* having drift between the two instances) and as a Unit of Work (tracking all changes to entities and then batch
+* flushing only the entities that have changed).
+*
+* Note that the type parameters (C, I, and Entity) will be filled in by codegen with the values specific to your
+* application, so you can import your app-specific EntityManager like:
+*
+* ```ts
+* import { EntityManager } from "src/entities";
+* ```
+*
+* @param C The type of your application-specific app-wide/request-wide Context object that will be passed to hooks
+* @typeParam C - the application-specific context (typically the request-level context)
+* @typeParam Entity - the application's based entity type (i.e. with number ids or string ids)
+* @typeParamTX - the application's Transaction type, i.e. `Knex`
+*/
+var EntityManager = class EntityManager {
+	ctx;
+	driver;
+	/** When we're flushing, the connection/transaction. */
+	txn;
+	entityLimit = defaultEntityLimit;
+	#entitiesArray = [];
+	#maybePendingFlushEntities = /* @__PURE__ */ new Set();
+	#entitiesById = /* @__PURE__ */ new Map();
+	#entitiesByTag = /* @__PURE__ */ new Map();
+	#indexManager = new IndexManager();
+	#isValidating = false;
+	#findRestricted = false;
+	#pendingPercolate = /* @__PURE__ */ new Map();
+	#preloadedRelations = /* @__PURE__ */ new Map();
+	/**
+	* Tracks cascade deletes.
+	*
+	* We originally used a beforeDelete lifecycle hook to implement this, but tracking this
+	* individually allows us to a) recursively cascade deletes even during the 1st iteration
+	* of our `flush` loop, and b) cascade deletions before we recalc fields & run user hooks,
+	* so that both see the most accurate state.
+	*/
+	#pendingDeletes = [];
+	#hasAnyDeletes = false;
+	#dataloaders = {};
+	#batchLoaders = {};
+	#joinRows = {};
+	/** Stores any `source -> downstream` reactions to recalc during `em.flush`. */
+	#rm = new ReactionsManager(this);
+	/** Ensures our `em.flush` method is not interrupted. */
+	#fl = new FlushLock();
+	#hooks = {
+		beforeBegin: [],
+		afterBegin: [],
+		beforeCommit: [],
+		afterCommit: []
+	};
+	#preloader;
+	#fieldLogger = noopFieldLogger;
+	#isLoadedCache = new IsLoadedCache();
+	#merging;
+	/** Track `a#1`, `a#2`, etc indexes for `em.create`-d entities. */
+	#createCounter = void 0;
+	__api;
+	#isRefreshing = false;
+	mode = "writes";
+	constructor(ctx, driverOrOpts) {
+		const opts = driverOrOpts.constructor === Object ? driverOrOpts : { driver: driverOrOpts };
+		this.ctx = ctx;
+		this.driver = opts.driver ?? opts.em.driver;
+		this.#preloader = opts.preloadPlugin ?? (opts.em ? opts.em.#preloader : this.driver.defaultPlugins.preloadPlugin);
+		const pluginManager = new PluginManager(this);
+		if (opts.em) {
+			this.#hooks = {
+				beforeBegin: [...opts.em.#hooks.beforeBegin],
+				afterBegin: [...opts.em.#hooks.afterBegin],
+				beforeCommit: [...opts.em.#hooks.beforeCommit],
+				afterCommit: [...opts.em.#hooks.afterCommit]
+			};
+			opts.em.__api.pluginManager.cloneTo(pluginManager);
+		}
+		const em = this;
+		this.__api = {
+			preloader: this.#preloader,
+			pendingPercolate: this.#pendingPercolate,
+			mutatedCollections: /* @__PURE__ */ new Set(),
+			pendingLoads: /* @__PURE__ */ new Set(),
+			hooks: this.#hooks,
+			rm: this.#rm,
+			indexManager: this.#indexManager,
+			isLoadedCache: this.#isLoadedCache,
+			pluginManager,
+			markMaybePending(entity) {
+				em.#maybePendingFlushEntities.add(entity);
+			},
+			unmarkMaybePending(entity) {
+				em.#maybePendingFlushEntities.delete(entity);
+			},
+			hasAnyDeletes() {
+				return em.#hasAnyDeletes;
+			},
+			pendingDeleteIds(type) {
+				return em.#pendingDeletes.filter((entity) => entity instanceof type && entity.idMaybe !== void 0).map((entity) => keyToNumber(getMetadata(entity), entity.id));
+			},
+			isMerging(entity) {
+				return em.#merging?.has(entity) ?? false;
+			},
+			joinRows(m2m) {
+				return getOrSet(em.#joinRows, m2m.joinTableName, () => new JoinRows(m2m, em.#rm));
+			},
+			/** Returns `a:1.books` if it's in our preload cache. */
+			getPreloadedRelation(taggedId, fieldName) {
+				return em.#preloadedRelations.get(taggedId)?.get(fieldName);
+			},
+			/** Stores `a:1.books` in our preload cache. */
+			setPreloadedRelation(taggedId, fieldName, children) {
+				let map = em.#preloadedRelations.get(taggedId);
+				if (!map) {
+					map = /* @__PURE__ */ new Map();
+					em.#preloadedRelations.set(taggedId, map);
+				}
+				map.set(fieldName, children);
+			},
+			get isValidating() {
+				return em.#isValidating;
+			},
+			checkWritesAllowed() {
+				if (em.mode === "read-only") throw new ReadOnlyError();
+				return em.#fl.checkWritesAllowed();
+			},
+			get fieldLogger() {
+				return em.#fieldLogger;
+			},
+			clearDataloaders() {
+				em.#dataloaders = {};
+				em.#batchLoaders = {};
+			},
+			clearPreloadedRelations() {
+				em.#preloadedRelations = /* @__PURE__ */ new Map();
+			},
+			setIsRefreshing(isRefreshing) {
+				em.#isRefreshing = isRefreshing;
+			}
+		};
+	}
+	/** Returns a read-only shallow copy of the currently-loaded entities. */
+	get entities() {
+		return [...this.#entitiesArray];
+	}
+	/** Returns a list of all pending creates, updates, deletes, and m2m changes that would be flushed. */
+	get pendingChanges() {
+		const changes = [];
+		for (const entity of this.#entitiesArray) switch (getInstanceData(entity).pendingOperation) {
+			case "insert":
+				changes.push({
+					kind: "create",
+					entity
+				});
+				break;
+			case "update":
+				changes.push({
+					kind: "update",
+					entity
+				});
+				break;
+			case "delete": changes.push({
+				kind: "delete",
+				entity
+			});
+		}
+		for (const joinRows of Object.values(this.#joinRows)) {
+			const todo = joinRows.toTodo();
+			if (todo && !todo.m2m.otherEnum) {
+				for (const row of todo.newRows) {
+					const entities = Object.values(row.columns);
+					changes.push({
+						kind: "m2m",
+						op: "add",
+						joinTableName: todo.m2m.joinTableName,
+						entities
+					});
+				}
+				for (const row of todo.deletedRows) {
+					const entities = Object.values(row.columns);
+					changes.push({
+						kind: "m2m",
+						op: "remove",
+						joinTableName: todo.m2m.joinTableName,
+						entities
+					});
+				}
+			}
+		}
+		return changes;
+	}
+	/** Returns a read-only list of the currently-loaded entities of `type`. */
+	getEntities(type) {
+		const meta = getMetadata(type);
+		const entities = this.#entitiesByTag.get(meta.tagName) ?? [];
+		return meta.baseType ? entities.filter((e) => e instanceof type) : entities;
+	}
+	getEntity(id) {
+		return this.#entitiesById.get(id);
+	}
+	async find(type, where, options) {
+		this.#assertFindAllowed("find");
+		const { populate, ...rest } = options || {};
+		const normalized = mergeFindOptions(where, rest);
+		const settings = {
+			where: normalized.where,
+			...normalized.options
+		};
+		const result = await (hasPaginationSettings(normalized.options) ? findPaginatedDataLoader(this, type, settings, populate) : findDataLoader(this, type, settings, populate)).catch(function find(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		if (populate) await this.populate(result, populate);
+		return result;
+	}
+	query(q, options) {
+		this.#assertFindAllowed("query");
+		const em = this;
+		return (async function query() {
+			const plan = parseRootQuery(q);
+			if (options?.populate && plan.output.kind !== "entity") 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);
+			if (options?.populate) await em.populate(result, options.populate);
+			return result;
+		})().catch(function query(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+	}
+	execute(statement) {
+		const em = this;
+		return (async function execute() {
+			if (isMutation(statement)) {
+				if (em.mode === "read-only") throw new ReadOnlyError();
+				if (em.mode === "in-memory-writes") fail("SQL mutations do not support in-memory-writes mode");
+			} else em.#assertFindAllowed("execute");
+			const plan = parseStatement(statement);
+			if (!plan) return {
+				rowCount: 0,
+				rows: []
+			};
+			const result = await em.driver.executeQuery(em, plan.sql, plan.bindings);
+			return decodeStatementResult(em, plan, result);
+		})().catch(function execute(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+	}
+	/** Fails fast if `em.${method}` is called from a regular validation rule, i.e. steers to `config.addCommitRule`. */
+	#assertFindAllowed(method) {
+		if (this.#findRestricted) throw new Error(`em.${method} cannot be called from a validation rule (added via config.addRule), because rules run before the flush and would query stale, pre-flush data. Use config.addCommitRule instead, which runs after the INSERT/UPDATE/DELETEs are flushed (within the same transaction) and so sees the changed state.`);
+	}
+	/** Runs the post-parse find pipeline: plugins mutate the logical AST, then Joist optimizes/prunes before SQL. */
+	async executeFind(meta, operation, parsed, settings) {
+		const { checkLimit, findSettings } = this.prepareFind(meta, operation, parsed, settings);
+		return this.executePreparedFind(meta, operation, parsed, findSettings, checkLimit);
+	}
+	/** Like {@link executeFind}, but returns a {@link RowData}; see {@link executePreparedFindRowData}. */
+	async executeFindRowData(meta, operation, parsed, settings) {
+		const { checkLimit, findSettings } = this.prepareFind(meta, operation, parsed, settings);
+		return this.executePreparedFindRowData(meta, operation, parsed, findSettings, checkLimit);
+	}
+	/** Executes a query that has already had find hooks and optimizations applied. */
+	async executePreparedFind(meta, operation, parsed, findSettings, checkLimit) {
+		const { pluginManager } = getEmInternalApi(this);
+		const rows = await this.driver.executeFind(this, parsed, findSettings);
+		if ((checkLimit ?? !("limit" in findSettings && findSettings.limit === void 0)) && rows.length >= this.entityLimit) throw new Error(`Query returned more than ${this.entityLimit} entityLimit rows`);
+		if (pluginManager.hasHook("afterFind")) pluginManager.afterFind(meta, operation, new PojoRowData(rows));
+		return rows;
+	}
+	/**
+	* Like {@link executePreparedFind}, but returns a {@link RowData}: lazy wire rows when the
+	* driver has `lazyRows` enabled, else classic POJO rows wrapped in a `PojoRowData` — so
+	* loaders can hydrate from one shape without caring which the driver provides.
+	*/
+	async executePreparedFindRowData(meta, operation, parsed, findSettings, checkLimit) {
+		const { executeFindRowData } = this.driver;
+		if (executeFindRowData === void 0) return new PojoRowData(await this.executePreparedFind(meta, operation, parsed, findSettings, checkLimit));
+		const { pluginManager } = getEmInternalApi(this);
+		const rowData = await executeFindRowData.call(this.driver, this, parsed, findSettings);
+		if ((checkLimit ?? !("limit" in findSettings && findSettings.limit === void 0)) && rowData.rowCount >= this.entityLimit) throw new Error(`Query returned more than ${this.entityLimit} entityLimit rows`);
+		pluginManager.afterFind(meta, operation, rowData);
+		return rowData;
+	}
+	/**
+	* Runs pre-SQL find hooks and optimizations against a parsed query.
+	*
+	* This allows plugins to see "pre-batched" / "logical" query ASTs, instead of our
+	* more complicated `_find` batched queries. The flow would be:
+	*
+	* - A loader calls `prepareFind(originalQuery)`
+	* - Plugins inspect/modify the query as/if needed
+	* - The loader crafts a new, more complicated query that embeds the originalQuery
+	* - The loader calls `executePreparedFind` with the 2nd query
+	*/
+	prepareFind(meta, operation, parsed, settings) {
+		const { checkLimit, ...findSettings } = settings;
+		const { pluginManager } = getEmInternalApi(this);
+		pluginManager.beforeFind(meta, operation, parsed, findSettings);
+		optimizeCollectionJoins(parsed, settings);
+		return {
+			checkLimit,
+			findSettings
+		};
+	}
+	async findGql(type, where, options) {
+		if (!options) return this.find(type, where);
+		const normalized = { ...options };
+		if ("limit" in normalized) normalized.limit = normalized.limit ?? void 0;
+		if ("offset" in normalized) normalized.offset = normalized.offset ?? void 0;
+		return this.find(type, where, normalized);
+	}
+	async findOne(type, where, options) {
+		const list = await this.find(type, where, options);
+		if (list.length === 0) return;
+		else if (list.length === 1) return list[0];
+		else throw new TooManyError(`Found more than one: ${list.map((e) => e.toString()).join(", ")}`);
+	}
+	async findOneOrFail(type, where, options) {
+		const list = await this.find(type, where, options);
+		if (list.length === 0) throw new NotFoundError(`Did not find ${type.name} for given query`);
+		else if (list.length > 1) throw new TooManyError(`Found more than one: ${list.map((e) => e.toString()).join(", ")}`);
+		return list[0];
+	}
+	async findByUnique(type, where, options = {}) {
+		this.#assertFindAllowed("findByUnique");
+		const { populate, softDeletes = "exclude" } = options;
+		const entries = Object.entries(where);
+		if (entries.length !== 1) throw new Error("findByUnique only accepts a single field");
+		const [fieldName, value] = entries[0];
+		const field = getMetadata(type).allFields[fieldName];
+		const row = await findByUniqueDataLoader(this, type, field, softDeletes).load(value).catch(function findByUnique(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		if (!row) return;
+		else {
+			const [entity] = this.hydrate(type, [row]);
+			if (this.#hasAnyDeletes && entity.isDeletedEntity) return;
+			if (populate) await this.populate(entity, populate);
+			return entity;
+		}
+	}
+	/**
+	* Returns the count of entities that match the `where` clause.
+	*
+	* The `where` clause, and any options.conditions, matches the same syntax
+	* as `em.find`.
+	*
+	* Note: this method is not currently auto-batched, so it will cause N+1s if called in a loop.
+	*/
+	async findCount(type, where, options = {}) {
+		this.#assertFindAllowed("findCount");
+		const normalized = mergeCountOptions(where, options);
+		const settings = {
+			where: normalized.where,
+			...normalized.options
+		};
+		let count = await findCountDataLoader(this, type, settings).catch(function findCount(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		if (isSelectAllFilter(where, options.conditions)) {
+			const tagged = this.#entitiesByTag.get(getMetadata(type).tagName) ?? [];
+			for (const entity of tagged) if (entity instanceof type) {
+				if (entity.isNewEntity) count++;
+				else if (entity.isDeletedEntity) count--;
+			}
+		}
+		return count;
+	}
+	/**
+	* Returns the IDs of entities that match the `where` clause.
+	*
+	* The `where` clause, and any options.conditions, matches the same syntax
+	* as `em.find`.
+	*/
+	async findIds(type, where, options = {}) {
+		this.#assertFindAllowed("findIds");
+		const normalized = mergeCountOptions(where, options);
+		const settings = {
+			where: normalized.where,
+			...normalized.options
+		};
+		return findIdsDataLoader(this, type, settings).catch(function findIds(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+	}
+	async findWithNewOrChanged(type, where, options) {
+		const { softDeletes = "exclude", populate } = options ?? {};
+		const copy = Object.fromEntries(Object.entries(where).filter(([, v]) => v !== void 0));
+		const unchanged = (await this.find(type, copy, { softDeletes })).filter((e) => !e.isNewEntity && !e.isDirtyEntity && !e.isDeletedEntity);
+		const maybeNew = this.filterEntities(type, where).filter((e) => (e.isNewEntity || e.isDirtyEntity) && !e.isDeletedEntity);
+		const found = [...unchanged, ...maybeNew];
+		if (populate) await this.populate(found, populate);
+		return found;
+	}
+	async findOrCreate(type, where, ifNew, upsert, options) {
+		const { softDeletes = "exclude", populate } = options ?? {};
+		const entity = await findOrCreateDataLoader(this, type, where, softDeletes).load({
+			ifNew,
+			upsert
+		}).catch(function findOrCreate(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		if (populate) await this.populate(entity, populate);
+		return entity;
+	}
+	/** Creates a new `type` and marks it as loaded, i.e. we know its collections are all safe to access in memory. */
+	create(type, opts) {
+		return this.#doCreate(type, opts, false);
+	}
+	/**
+	* Creates a new `type` but with `opts` that are nullable, to accept partial-update-style input.
+	*
+	* Note that `createPartial` doesn't support the full upsert behavior, i.e. this method:
+	*
+	* - always creates,
+	* - does not support relation markers like `op`, `delete`, and `remove`,
+	* - does not accept deep input, but
+	* - fields set to `undefined` will be skipped instead of unset
+	*
+	* See `upsert` for the upsert/deep upsert behavior.
+	*/
+	createPartial(type, opts) {
+		return this.#doCreate(type, opts, true);
+	}
+	/**
+	* Create or updates `type` based on partial-update-style `input`.
+	*
+	* This supports upsert behavior, i.e.:
+	*
+	* - findOrCreate the primary entity being updated (based on the `id` key being provided),
+	* - upsert relation markers like `op`, `delete`, and `remove` are supported,
+	* - deep input is supported, i.e. `{ firstName: "Bob", books: [{ title: "b1" } ] }`, and
+	* - fields set to `undefined` will be skipped instead of unset
+	*/
+	upsert(type, input) {
+		return upsert(this, type, input);
+	}
+	async clone(entityOrArray, opts) {
+		const { deep = {}, skipIf, skip = {}, postClone } = opts ?? {};
+		const todo = /* @__PURE__ */ new Set();
+		const skipMap = /* @__PURE__ */ new WeakMap();
+		await crawl(todo, skipMap, Array.isArray(entityOrArray) ? entityOrArray : [entityOrArray], deep, {
+			skipIf,
+			skip
+		});
+		const deferredRelations = [];
+		const clones = [...todo].map((entity) => {
+			const skip = skipMap.get(entity) ?? [];
+			const meta = getMetadata(entity);
+			const copy = Object.fromEntries(Object.values(meta.allFields).map((f) => {
+				if (skip.includes(f.fieldName)) return void 0;
+				switch (f.kind) {
+					case "primitive": if (!f.derived && !f.protected) return [f.fieldName, getField(entity, f.fieldName)];
+					else return;
+					case "enum": if (f.derived) return;
+					else return [f.fieldName, getField(entity, f.fieldName)];
+					case "m2o":
+					case "poly": {
+						if (f.kind === "m2o" && f.derived) return void 0;
+						const existingIdOrEntity = getField(entity, f.fieldName);
+						const target = isEntity(existingIdOrEntity) ? existingIdOrEntity : this.getEntity(existingIdOrEntity);
+						if (target && todo.has(target)) {
+							deferredRelations.push([
+								entity,
+								f.fieldName,
+								target
+							]);
+							return [f.fieldName, void 0];
+						} else return [f.fieldName, existingIdOrEntity];
+					}
+					case "primaryKey":
+					case "o2m":
+					case "m2m":
+					case "m2mEnum":
+					case "o2o":
+					case "lo2m": return;
+					default: assertNever(f);
+				}
+			}).filter(isDefined));
+			return [entity, this.create(asConcreteCstr(meta.cstr), copy)];
+		});
+		const entityToClone = new Map(clones);
+		clones.forEach(([, clone]) => {
+			getRelationEntries(clone).forEach(([fieldName, value]) => {
+				if (value instanceof ManyToOneReferenceImpl || value instanceof PolymorphicReferenceImpl || value instanceof ReactiveReferenceImpl) {
+					const existingIdOrEntity = getField(clone, fieldName);
+					const existing = isEntity(existingIdOrEntity) ? existingIdOrEntity : this.getEntity(existingIdOrEntity);
+					if (existing) clone[fieldName].set(entityToClone.get(existing) ?? existing);
+				}
+			});
+		});
+		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)));
+		return Array.isArray(entityOrArray) ? entityOrArray.filter((original) => entityToClone.has(original)).map((original) => entityToClone.get(original)) : clones[0] ? clones[0][1] : fail("no entities were cloned given the provided options");
+	}
+	/**
+	* Merges multiple source entities into a target entity by updating all references that point
+	* to the source entities to instead point to the target entity.
+	*
+	* This method loads all relations from the source entities, updates any entity that
+	* references a source entity to reference the target entity instead, and then automatically
+	* deletes the source entities.
+	*
+	* @param target - The entity that will become the target of all merged references
+	* @param sources - Array of entities whose references will be redirected to the target
+	* @param opts - Options to control merge behavior
+	*   @param autoDelete - Whether to automatically delete source entities (default: true)
+	* @returns Promise that resolves when all references have been updated and sources deleted
+	*
+	* @example
+	* // Merge duplicate authors - all books pointing to author2 will now point to author1
+	* // author2 will be automatically deleted
+	* await em.merge(author1, [author2]);
+	*
+	* @example
+	* // Merge multiple duplicate publishers into one
+	* // publisher2 and publisher3 will be automatically deleted
+	* await em.merge(publisher1, [publisher2, publisher3]);
+	*
+	* @example
+	* // Merge without auto-deleting sources (for custom cleanup logic)
+	* await em.merge(author1, [author2], { autoDelete: false });
+	* // Custom logic here...
+	* em.delete(author2);
+	*/
+	async merge(target, sources, opts) {
+		const autoDelete = opts?.autoDelete ?? true;
+		if (sources.length === 0) return [];
+		this.#merging ??= /* @__PURE__ */ new Set();
+		this.#merging.add(target);
+		const targetMeta = getMetadata(target);
+		for (const source of sources) {
+			const sourceMeta = getMetadata(source);
+			if (sourceMeta.type !== targetMeta.type) throw new Error(`Cannot merge entities of different types: ${targetMeta.type} and ${sourceMeta.type}`);
+		}
+		const fields = Object.values(targetMeta.allFields).filter((field) => [
+			"o2m",
+			"m2o",
+			"m2m",
+			"o2o"
+		].includes(field.kind)).map((field) => field.fieldName);
+		await this.populate(sources, fields);
+		const changedEntities = [];
+		for (const source of sources) for (const field of Object.values(targetMeta.allFields)) {
+			const { kind } = field;
+			if (kind === "o2m") for (const other of source[field.fieldName].get) {
+				this.#merging.add(other);
+				other[field.otherFieldName].set(target);
+				changedEntities.push(other);
+			}
+			else if (kind === "o2o") {
+				const otherField = field.otherMetadata().allFields[field.otherFieldName];
+				if (otherField.kind === "m2o" && otherField.derived) continue;
+				const other = source[field.fieldName].get;
+				if (other) {
+					this.#merging.add(other);
+					other[field.otherFieldName].set(target);
+					changedEntities.push(other);
+				}
+			} else if (kind === "m2m") for (const other of source[field.fieldName].get) {
+				this.#merging.add(other);
+				const collection = other[field.otherFieldName];
+				collection.remove(source);
+				collection.add(target);
+				changedEntities.push(other);
+			}
+			else if (kind === "primitive" || kind === "primaryKey" || kind === "enum" || kind === "m2mEnum" || kind === "poly" || kind === "m2o" || kind === "lo2m") {} else assertNever(kind);
+		}
+		if (autoDelete) for (const source of sources) this.delete(source);
+		return changedEntities;
+	}
+	async load(typeOrId, id, hint) {
+		let type;
+		if (typeof typeOrId === "string") {
+			type = getConstructorFromTaggedId(typeOrId);
+			id = typeOrId;
+		} else {
+			type = typeOrId;
+			id = id || fail(`Invalid ${typeOrId.name} id: ${id}`);
+		}
+		const meta = getMetadata(type);
+		const taggedId = toTaggedId(meta, id);
+		let entity = this.findExistingInstance(taggedId);
+		if (!entity) {
+			await loadBatchLoader(this, meta).load({
+				taggedId,
+				hint
+			}).catch(function load(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			});
+			entity = this.findExistingInstance(taggedId);
+		}
+		if (!entity) throw new NotFoundError(`${taggedId} was not found`);
+		if (hint) await this.populate(entity, hint);
+		if (meta.inheritanceType === "sti" && !(entity instanceof type)) throw new Error(`${entity} is ${entity.constructor.name} but should be ${type.name}`);
+		return entity;
+	}
+	async loadAll(type, _ids, hint) {
+		const meta = getMetadata(type);
+		const entities = new Array(_ids.length);
+		let idsToLoad;
+		let positionsToLoad;
+		for (let i = 0; i < _ids.length; i++) {
+			const id = tagId(meta, _ids[i]);
+			const entity = this.findExistingInstance(id);
+			if (entity) entities[i] = entity;
+			else {
+				(idsToLoad ??= []).push(id);
+				(positionsToLoad ??= []).push(i);
+			}
+		}
+		if (idsToLoad) {
+			await loadBatchLoader(this, meta).loadAll(idsToLoad.map((id) => ({
+				taggedId: id,
+				hint
+			}))).catch(function loadAll(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			});
+			let idsNotFound;
+			for (let j = 0; j < positionsToLoad.length; j++) {
+				const entity = this.findExistingInstance(idsToLoad[j]);
+				entities[positionsToLoad[j]] = entity;
+				if (entity === void 0) (idsNotFound ??= []).push(idsToLoad[j]);
+			}
+			if (idsNotFound) throw new NotFoundError(`${idsNotFound.join(",")} were not found`);
+		}
+		const loadedEntities = entities;
+		if (hint) await this.populate(loadedEntities, hint);
+		if (meta.inheritanceType === "sti" && meta.baseType) {
+			const wrongType = loadedEntities.filter((e) => !(e instanceof meta.cstr));
+			if (wrongType.length > 0) throw new Error(`${wrongType.join(", ")} were not of type ${meta.cstr.name}`);
+		}
+		return loadedEntities;
+	}
+	async loadAllIfExists(type, _ids, hint) {
+		const meta = getMetadata(type);
+		const maybeEntities = new Array(_ids.length);
+		let idsToLoad;
+		let positionsToLoad;
+		for (let i = 0; i < _ids.length; i++) {
+			const id = tagId(meta, _ids[i]);
+			const entity = this.findExistingInstance(id);
+			if (entity) maybeEntities[i] = entity;
+			else {
+				(idsToLoad ??= []).push(id);
+				(positionsToLoad ??= []).push(i);
+			}
+		}
+		let entities;
+		if (idsToLoad) {
+			await loadBatchLoader(this, meta).loadAll(idsToLoad.map((id) => ({
+				taggedId: id,
+				hint
+			}))).catch(function loadAllIfExists(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			});
+			for (let j = 0; j < positionsToLoad.length; j++) maybeEntities[positionsToLoad[j]] = this.findExistingInstance(idsToLoad[j]);
+			entities = [];
+			for (const entity of maybeEntities) if (entity !== void 0) entities.push(entity);
+		} else entities = maybeEntities;
+		if (hint) await this.populate(entities, hint);
+		return entities;
+	}
+	async loadLens(entities, fn, populate) {
+		const result = await loadLens(entities, fn);
+		if (populate) await this.populate(result, populate);
+		return result;
+	}
+	loadFromQuery(type, rows, populate) {
+		if (Array.isArray(rows)) {
+			const entities = this.hydrate(type, rows);
+			if (populate) return this.populate(entities, populate);
+			return entities;
+		} else return rows.then((rows) => {
+			const entities = this.hydrate(type, rows);
+			if (populate) return this.populate(entities, populate);
+			return entities;
+		});
+	}
+	async loadFromRows(type, rows, populate) {
+		const entities = this.hydrate(type, rows);
+		if (populate) await this.populate(entities, populate);
+		return entities;
+	}
+	async populate(entityOrList, hintOrOpts, fn) {
+		const { hint: hintOpt, ...opts } = typeof hintOrOpts === "object" && "hint" in hintOrOpts ? hintOrOpts : { hint: hintOrOpts };
+		opts[AsyncMethodPopulateSecret] = true;
+		const list = toArray(entityOrList).filter((e) => {
+			return e !== void 0 && !getInstanceData(e).isDeletedAndFlushed;
+		});
+		if (list.length === 0) return !fn ? entityOrList : fn(entityOrList);
+		if (!opts.forceReload && list.every((entity) => !entity.isNewEntity && isLoadedForPopulate(entity, hintOpt))) return fn ? fn(entityOrList) : entityOrList;
+		const meta = getMetadata(list[0]);
+		if (this.#preloader) {
+			const [preload, non] = this.#preloader.partitionHint(meta, hintOpt);
+			if (preload) await populateBatchLoader(this, meta, preload, "preload", opts).loadAll(list.map((entity) => ({
+				entity,
+				hint: preload
+			}))).catch(function populate(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			});
+			if (non) await populateBatchLoader(this, meta, non, "intermixed", opts).loadAll(list.map((entity) => ({
+				entity,
+				hint: non
+			}))).catch(function populate(err) {
+				throw appendStack(err, /* @__PURE__ */ new Error());
+			});
+		} else await populateBatchLoader(this, meta, hintOpt, "intermixed", opts).loadAll(list.map((entity) => ({
+			entity,
+			hint: hintOpt
+		}))).catch(function populate(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+		return fn ? fn(entityOrList) : entityOrList;
+	}
+	/**
+	* Executes `fn` with a transaction, and automatically calls `flush`/`commit` at the end.
+	*
+	* This ensures both any `.find` and `.flush` operations happen within the same
+	* transaction, which is useful for enforcing cross-table/application-level invariants that
+	* cannot be enforced with database-level constraints.
+	*/
+	async transaction(fn) {
+		return this.driver.transaction(this, async (txn) => {
+			const result = await fn(txn);
+			await this.flush();
+			return result;
+		});
+	}
+	delete(entityOrArray) {
+		for (const entity of toArray(entityOrArray)) {
+			if (!getInstanceData(entity).markDeleted()) continue;
+			this.#hasAnyDeletes = true;
+			this.#rm.queueAllDownstreamFields(entity, "deleted");
+			getCascadeDeleteRelations(entity).forEach((r) => r.maybeCascadeDelete());
+			this.#pendingDeletes.push(entity);
+		}
+	}
+	async assignNewIds() {
+		let pendingEntities = this.entities.filter((e) => e.isNewEntity && !e.isDeletedEntity && !e.idTaggedMaybe);
+		await this.getLoader("assign-new-ids", "global", async (entities) => {
+			let todos = createTodos(entities);
+			await this.driver.assignNewIds(this, todos);
+			for (const e of entities) this.#entitiesById.set(e.idTagged, e);
+			return entities;
+		}).loadMany(pendingEntities).catch(function assignNewIds(err) {
+			throw appendStack(err, /* @__PURE__ */ new Error());
+		});
+	}
+	/**
+	* Immediately assigns async defaults to `entities`.
+	*
+	* Normally async defaults wait until `em.flush` to run, because their async nature requires
+	* an `await` / `Promise` to be evaluated, and `em.create` is synchronous.
+	*
+	* This `assignDefaults` methods like you move that up, and immediately invoke
+	* any default logic against the `entities`.
+	*/
+	async setDefaults(entities) {
+		return runInTrustedContext(async () => {
+			const suppressedTypeErrors = [];
+			const entitiesByType = groupBy(entities.filter((e) => e.isNewEntity), (e) => getMetadata(e));
+			await setAsyncDefaults(suppressedTypeErrors, this.ctx, entitiesByType);
+		});
+	}
+	/**
+	* Flushes the SQL for any changed entities to the database.
+	*
+	* If this is run outside of an existing transaction, it will `BEGIN` and `COMMIT`
+	* a new transaction on every `.flush()` call so that all of the `INSERT`s/etc.
+	* happen atomically.
+	*
+	* If this is run within an existing transaction, i.e. `EntityManager.transaction`,
+	* then it will only issue `INSERT`s/etc. and defer to the caller to `COMMIT`
+	* the transaction.
+	*
+	* It returns entities that have changed (an entity is considered changed if it has been deleted, inserted, or updated)
+	*/
+	async flush(flushOptions = {}) {
+		return runInTrustedContext(() => this.#flush(flushOptions));
+	}
+	async #flush(flushOptions = {}) {
+		if (this.mode === "read-only") throw new ReadOnlyError();
+		const { skipValidation = false } = flushOptions;
+		this.#fl.startLock();
+		const allFlushedEntities = /* @__PURE__ */ new Set();
+		try {
+			await this.#fl.allowWrites(async () => {
+				await this.flushDeletes();
+				await this.#rm.recalcPendingReactables("reactables");
+			});
+			const createdThenDeleted = /* @__PURE__ */ new Set();
+			const hooksInvoked = /* @__PURE__ */ new Set();
+			let hookLoops = 0;
+			let now = getNow();
+			const suppressedDefaultTypeErrors = [];
+			const runHooksOnPendingEntities = async () => {
+				if (hookLoops++ >= 10) throw new Error("runHooksOnPendingEntities has ran 10 iterations, aborting");
+				const pendingLoads = [...getEmInternalApi(this).pendingLoads];
+				if (pendingLoads.length > 0) {
+					getEmInternalApi(this).pendingLoads.clear();
+					await Promise.all(pendingLoads.map((collection) => collection.load()));
+				}
+				const pendingFlush = /* @__PURE__ */ new Set();
+				const pendingHooks = /* @__PURE__ */ new Set();
+				const alreadyRanHooks = /* @__PURE__ */ new Set();
+				findPendingFlushEntities(this.#maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
+				if (alreadyRanHooks.size > 0) maybeBumpUpdatedAt(this.#rm, createTodos(alreadyRanHooks), now);
+				while (pendingHooks.size > 0) await this.#fl.allowWrites(async () => {
+					let todos = createTodos(pendingHooks);
+					await setAsyncDefaults(suppressedDefaultTypeErrors, this.ctx, Todo.groupInsertsByTypeAndSubType(todos));
+					maybeBumpUpdatedAt(this.#rm, todos, now);
+					for (const group of maybeSetupHookOrdering(todos)) {
+						await beforeCreate(this.ctx, group);
+						await beforeUpdate(this.ctx, group);
+						await beforeFlush(this.ctx, group);
+					}
+					recalcSynchronousDerivedFields(todos);
+					do {
+						await this.flushDeletes();
+						await this.#rm.recalcPendingReactables("reactables");
+					} while (this.#pendingDeletes.length > 0);
+					if (this.#rm.hasPendingTypeErrors) {
+						await this.#rm.recalcPendingTypeErrors();
+						if (this.#rm.needsRecalc("reactables")) await this.#rm.recalcPendingReactables("reactables");
+					}
+					for (const e of pendingHooks) hooksInvoked.add(e);
+					pendingHooks.clear();
+					findPendingFlushEntities(this.#maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks);
+					if (pendingHooks.size === 0 && this.#rm.hasPendingTypeErrors) await this.#rm.recalcPendingTypeErrors();
+				});
+				return [...pendingFlush].filter((e) => {
+					const createThenDelete = e.isDeletedEntity && e.isNewEntity;
+					if (createThenDelete) createdThenDeleted.add(e);
+					return !createThenDelete;
+				});
+			};
+			const { pluginManager } = getEmInternalApi(this);
+			const runValidation = async (entityTodos, joinRowTodos, validate) => {
+				const changedEntities = entitiesFromTodos(entityTodos, joinRowTodos);
+				try {
+					this.#isValidating = true;
+					await pluginManager.beforeValidate(changedEntities);
+					if (validate) {
+						this.#findRestricted = true;
+						try {
+							await validateSimpleRules(entityTodos);
+							if (suppressedDefaultTypeErrors.length > 0) throw suppressedDefaultTypeErrors[0];
+							await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos);
+						} finally {
+							this.#findRestricted = false;
+						}
+						await afterValidation(this.ctx, entityTodos);
+					}
+					await pluginManager.afterValidate(changedEntities);
+				} finally {
+					this.#isValidating = false;
+				}
+			};
+			const runCommitValidation = async (entityTodos, joinRowTodos) => {
+				this.#dataloaders = {};
+				this.#batchLoaders = {};
+				this.#preloadedRelations = /* @__PURE__ */ new Map();
+				try {
+					this.#isValidating = true;
+					await validateSimpleRules(entityTodos, (config) => config.commitRules);
+					await validateReactiveRules(this, this.#rm.logger, entityTodos, joinRowTodos, (meta) => meta.reactiveCommitRules);
+				} finally {
+					this.#isValidating = false;
+				}
+			};
+			const commitRuleTodos = {};
+			const commitRuleJoinRowTodos = {};
+			const commitRuleSeen = /* @__PURE__ */ new Set();
+			function collectCommitRuleTodos(entityTodos, joinRowTodos) {
+				if (skipValidation) return;
+				for (const todo of Object.values(entityTodos)) {
+					if (!todo.metadata.hasCommitRules) continue;
+					for (const key of [
+						"inserts",
+						"updates",
+						"deletes"
+					]) for (const e of todo[key]) if (!commitRuleSeen.has(e)) {
+						commitRuleSeen.add(e);
+						getTodo(commitRuleTodos, e)[key].push(e);
+					}
+				}
+				for (const [table, todo] of Object.entries(joinRowTodos)) {
+					if (!todo.m2m.meta.hasCommitRules && !todo.m2m.otherMeta?.hasCommitRules) continue;
+					const into = commitRuleJoinRowTodos[table] ??= {
+						...todo,
+						newRows: [],
+						deletedRows: []
+					};
+					for (const key of ["newRows", "deletedRows"]) for (const r of todo[key]) if (!commitRuleSeen.has(r)) {
+						commitRuleSeen.add(r);
+						into[key].push(r);
+					}
+				}
+			}
+			let entitiesToFlush = await runHooksOnPendingEntities();
+			for (const e of entitiesToFlush) allFlushedEntities.add(e);
+			let entityTodos = createTodos(entitiesToFlush);
+			let joinRowTodos = combineJoinRows(this.#joinRows);
+			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) {
+				await this.driver.transaction(this, async () => {
+					do {
+						if (Object.keys(entityTodos).length > 0 || Object.keys(joinRowTodos).length > 0) {
+							await this.driver.flush(this, entityTodos, joinRowTodos);
+							collectCommitRuleTodos(entityTodos, joinRowTodos);
+						}
+						pluginManager.afterWrite(entityTodos, joinRowTodos);
+						if (this.#rm.hasPendingReactiveQueries()) {
+							for (const e of entitiesToFlush) {
+								if (e.isNewEntity && !e.isDeletedEntity) this.#entitiesById.set(e.idTagged, e);
+								getInstanceData(e).resetForRqfLoop();
+							}
+							await this.#fl.allowWrites(async () => {
+								await this.#rm.recalcPendingReactables("reactiveQueries");
+								await this.#rm.recalcPendingReactables("reactables");
+							});
+							now = getNow();
+							entitiesToFlush = await runHooksOnPendingEntities();
+							for (const e of entitiesToFlush) allFlushedEntities.add(e);
+							entityTodos = createTodos(entitiesToFlush);
+							joinRowTodos = combineJoinRows(this.#joinRows);
+							await runValidation(entityTodos, joinRowTodos, true);
+							this.#rm.throwIfAnySuppressedTypeErrors();
+						} else entityTodos = {};
+					} while (Object.keys(entityTodos).length > 0);
+					if (Object.keys(commitRuleTodos).length > 0 || Object.keys(commitRuleJoinRowTodos).length > 0) {
+						for (const e of allFlushedEntities) if (e.isNewEntity && !e.isDeletedEntity) this.#entitiesById.set(e.idTagged, e);
+						await runCommitValidation(commitRuleTodos, commitRuleJoinRowTodos);
+					}
+					await beforeCommit(this.ctx, allFlushedEntities);
+					if (this.mode === "in-memory-writes") throw new InMemoryRollbackError();
+				});
+				await afterCommit(this.ctx, allFlushedEntities);
+				for (const e of allFlushedEntities) {
+					const instanceData = getInstanceData(e);
+					if (e.isNewEntity && !e.isDeletedEntity) this.#entitiesById.set(e.idTagged, e);
+					instanceData.resetAfterFlushed();
+					const { relations } = instanceData;
+					if (relations) {
+						for (const rel of Object.values(relations)) if (rel instanceof AsyncPropertyImpl || rel instanceof LazyFieldImpl) rel.resetAfterFlush();
+					}
+				}
+				for (const joinRow of Object.values(joinRowTodos)) joinRow.resetAfterFlushed();
+				const { mutatedCollections } = getEmInternalApi(this);
+				for (const o2m of mutatedCollections.values()) o2m.resetAddedRemoved();
+				mutatedCollections.clear();
+				this.#dataloaders = {};
+				this.#batchLoaders = {};
+				this.#preloadedRelations = /* @__PURE__ */ new Map();
+				this.#rm.clear();
+			}
+			for (const e of createdThenDeleted) getInstanceData(e).fixupCreatedThenDeleted();
+			this.#merging?.clear();
+			return [...allFlushedEntities].sort((a, b) => getInstanceData(a).entityIndex - getInstanceData(b).entityIndex);
+		} catch (e) {
+			if (e instanceof RecursiveCycleError) {
+				const entity = e.entities[0];
+				for (const meta of getBaseAndSelfMetas(getMetadata(entity))) {
+					const messageFn = meta.config.__data.cycleMessages[e.fieldName] ?? meta.config.__data.cycleMessages[entity[e.fieldName]?.otherFieldName];
+					if (messageFn) throw new ValidationErrors([{
+						entity,
+						message: messageFn(entity, e.entities)
+					}]);
+				}
+			}
+			const detail = e && typeof e === "object" && "detail" in e && typeof e.detail === "string" ? e.detail : void 0;
+			if (e && typeof e === "object" && "constraint" in e && typeof e.constraint === "string") {
+				const message = constraintNameToValidationError[e.constraint];
+				if (message) {
+					const errors = new ValidationErrors(message);
+					if (detail) errors.message = `${message} — ${detail}`;
+					throw errors;
+				}
+			}
+			if (e instanceof InMemoryRollbackError) return [...allFlushedEntities].sort((a, b) => getInstanceData(a).entityIndex - getInstanceData(b).entityIndex);
+			if (detail && e instanceof Error) e.message = `${e.message} — ${detail}`;
+			throw e;
+		} finally {
+			this.#rm.clearSuppressedTypeErrors();
+			this.#fl.releaseLock();
+			resetFactoryCreated();
+		}
+	}
+	/**
+	* A very simple toJSON.
+	*
+	* This is not really meant to be useful, it's to prevent huge/circular output if
+	* an EntityManager accidentally ends up getting logged to something like pino that
+	* over-zealous toJSONs anything it touches.
+	*/
+	toJSON() {
+		return `<EntityManager ${this.entities.length}>`;
+	}
+	async refresh(param) {
+		this.#isRefreshing = true;
+		this.#dataloaders = {};
+		this.#batchLoaders = {};
+		this.#preloadedRelations = /* @__PURE__ */ new Map();
+		const deepLoad = param && "deepLoad" in param && param.deepLoad;
+		let todo = param === void 0 ? this.#entitiesArray : Array.isArray(param) ? param : isEntity(param) ? [param] : this.#entitiesArray;
+		const done = /* @__PURE__ */ new Set();
+		while (todo.length > 0) {
+			const copy = [...todo];
+			copy.forEach((e) => done.add(e));
+			todo = [];
+			const entitiesToRefresh = copy.filter((e) => e.idTaggedMaybe && !e.isDeletedEntity);
+			await Promise.all(entitiesToRefresh.map((entity) => {
+				const hint = getRelationEntries(entity).filter(([_, r]) => deepLoad || r.isLoaded).map(([k]) => k);
+				return loadBatchLoader(this, getMetadata(entity), true).load({
+					taggedId: entity.idTagged,
+					hint
+				}).catch(function refresh(err) {
+					throw appendStack(err, /* @__PURE__ */ new Error());
+				});
+			}));
+			const [custom, builtin] = partition(entitiesToRefresh.filter((e) => !getInstanceData(e).isDeletedEntity).flatMap((entity) => getRelations(entity).filter((r) => deepLoad || r.isLoaded)), isCustomRelation);
+			await Promise.all(builtin.map((r) => {
+				if (r.isPreloaded && !r.isLoaded) {
+					r.preload();
+					return;
+				} else return r.load({ forceReload: true });
+			}));
+			await Promise.all(custom.map((r) => r.load({ forceReload: true })));
+			if (deepLoad) todo.push(...builtin.filter((r) => "get" in r).map((r) => r.get).flatMap((value) => Array.isArray(value) ? value : [value]).filter((value) => isEntity(value) && !done.has(value)));
+		}
+		this.#isRefreshing = false;
+	}
+	get numberOfEntities() {
+		return this.entities.length;
+	}
+	findExistingInstance(id) {
+		return this.#entitiesById.get(id);
+	}
+	/**
+	* Takes a result `row` from a custom query and maps the db values into a new-or-existing domain object for that row.
+	*
+	* The `overwriteExisting` controls whether `row`'s values should overwrite the existing fields on
+	* an entity. By default this is true, as we assume the user calling this means they know the DB has
+	* updated values that should be put into the entities. A few internal callers set this to false,
+	* i.e. when we're loading collections and have db results that are potentially stale compared to
+	* the WIP entity state.
+	*/
+	hydrate(type, rows, options) {
+		return this.hydrateFromRowData(type, new PojoRowData(rows), options);
+	}
+	/**
+	* Hydrates a query's `RowData`, running any sidecar reads, and always `finalize`s the result.
+	*
+	* This is the internal API for Joist's find/load loaders: `sidecars` is where reads of
+	* non-entity columns (preload aggregates, `_tags`, found-id checks) belong — they must run
+	* before `finalize`, because compaction drops unretained rows — and the `try/finally`
+	* guarantees a failed hydration or sidecar read still releases the result's unretained
+	* buffers instead of pinning them.
+	*/
+	hydrateAndFinalize(type, rowData, opts) {
+		try {
+			const entities = this.hydrateFromRowData(type, rowData, opts);
+			opts?.sidecars?.(entities);
+			return entities;
+		} finally {
+			rowData.finalize?.();
+		}
+	}
+	/**
+	* Like {@link hydrate}, but reads rows from a {@link RowData}, i.e. a driver-produced
+	* lazy query result, instead of an array of POJO rows.
+	*
+	* This is an internal API used by Joist's own find loaders (usually via
+	* {@link hydrateAndFinalize}); rows whose entities are kept (newly created or
+	* overwrite-refreshed) are `retain`-ed on the `RowData` so the caller can later `finalize`
+	* (trim/compact) the result.
+	*/
+	hydrateFromRowData(type, rowData, options) {
+		const maybeBaseMeta = getMetadata(type);
+		const overwriteExisting = options?.overwriteExisting === true;
+		const count = rowData.rowCount;
+		const entities = new Array(count);
+		for (let i = 0; i < count; i++) {
+			const id = rowData.get(i, "id");
+			const taggedId = id === void 0 || id === null ? fail("No id column was available") : keyToTaggedId(maybeBaseMeta, id);
+			let entity = this.findExistingInstance(taggedId);
+			if (!entity) {
+				const meta = findConcreteMeta(maybeBaseMeta, rowData, i);
+				entity = newEntity(this, asConcreteCstr(meta.cstr), false);
+				const instanceData = getInstanceData(entity);
+				instanceData.rowData = rowData;
+				instanceData.rowIndex = i;
+				rowData.retain?.(i);
+				instanceData.data["id"] = taggedId;
+				this.#doRegister(entity, taggedId, meta, true);
+			} else if (overwriteExisting) {
+				const instanceData = getInstanceData(entity);
+				instanceData.rowData = rowData;
+				instanceData.rowIndex = i;
+				rowData.retain?.(i);
+				const { data } = instanceData;
+				const dataKeys = Object.keys(data);
+				if (dataKeys.length > ("id" in data ? 1 : 0)) {
+					const allFields = getMetadata(entity).allFields;
+					const changedFields = instanceData.isNewEntity ? entity.changes.fieldsWithoutRelations : Object.keys(instanceData.originalData);
+					for (const fieldName of dataKeys) {
+						if (fieldName === "id") continue;
+						data[fieldName] = (allFields[fieldName].serde ?? fail(`Missing serde for ${fieldName}`)).fromRow(rowData, i);
+						if (changedFields.includes(fieldName)) instanceData.markFieldClean(fieldName);
+					}
+				}
+			}
+			entities[i] = entity;
+		}
+		return entities;
+	}
+	touch(entityOrEntities) {
+		for (const entity of toArray(entityOrEntities)) getInstanceData(entity).markTouched();
+	}
+	async recalc(entityOrEntities, reactionName) {
+		const entities = toArray(entityOrEntities).filter((entity) => !entity.isDeletedEntity);
+		if (reactionName !== void 0) {
+			const reactions = entities.map((entity) => {
+				return getBaseAndSelfMetas(getMetadata(entity)).flatMap((meta) => meta.config.__data.reactions).find((reaction) => reaction.name === reactionName) ?? fail(`Reaction '${reactionName}' not found on ${getMetadata(entity).type}`);
+			});
+			await runInTrustedContext(() => Promise.allSettled(reactions.map((reaction, i) => reaction.fn(entities[i], this.ctx))).then(failIfAnyRejected));
+			await this.#rm.recalcPendingReactables("reactables");
+			return;
+		}
+		const relations = entities.flatMap((entity) => Object.values(getMetadata(entity).allFields).filter((f) => "derived" in f && f.derived === "async").map((field) => entity[field.fieldName]));
+		const results = await Promise.allSettled(relations.map((r) => r.load({ forceReload: true })));
+		const relationsPendingAssignedIds = [];
+		const failures = [];
+		results.forEach((result, i) => {
+			if (result.status === "rejected") {
+				if (result.reason instanceof NoIdError) relationsPendingAssignedIds.push(relations[i]);
+				else failures.push(result.reason);
+			}
+		});
+		if (relationsPendingAssignedIds.length > 0) {
+			await this.assignNewIds();
+			(await Promise.allSettled(relationsPendingAssignedIds.map((r) => r.load({ forceReload: true })))).forEach((result) => {
+				if (result.status === "rejected") failures.push(result.reason);
+			});
+		}
+		if (failures.length > 0) throw failures[0];
+		entities.flatMap((entity) => Object.values(getMetadata(entity).allFields).filter((f) => "derived" in f && f.derived === "sync").forEach((field) => {
+			setField(entity, field.fieldName, entity[field.fieldName]);
+		}));
+		await this.#rm.recalcPendingReactables("reactables");
+	}
+	beforeBegin(fn) {
+		this.#hooks.beforeBegin.push(fn);
+	}
+	afterBegin(fn) {
+		this.#hooks.afterBegin.push(fn);
+	}
+	beforeCommit(fn) {
+		this.#hooks.beforeCommit.push(fn);
+	}
+	afterCommit(fn) {
+		this.#hooks.afterCommit.push(fn);
+	}
+	/**
+	* Returns an EntityManager-scoped (i.e. request scoped) data loader.
+	*
+	* @param operation the operation being batched, i.e. `load` or `o2m-load`, to avoid clashing batch keys
+	*   across fundamentally different operations
+	* @param batchKey for a given operation, i.e. `load`, a batch key `Author` to batch all Author loads together
+	* @param fn the batch load function, i.e. that will accept all `.load(...)`-d Author ids to load as a single db call
+	* @param opts optional DataLoader options
+	* @returns a DataLoader scoped to the `operation` + `batchKey` combination
+	*/
+	getLoader(operation, batchKey, fn, opts) {
+		const loadersForKind = this.#dataloaders[operation] ??= {};
+		return getOrSet(loadersForKind, batchKey, () => new DataLoader(fn, opts));
+	}
+	/**
+	* Like `getLoader`, but returns a `BatchLoader` where all callers in the same tick
+	* share a single `Promise<void>` instead of getting per-key promises.
+	*
+	* The batch function should write results via side channels (e.g. `setPreloadedRelation`).
+	*/
+	getBatchLoader(operation, batchKey, fn) {
+		const loadersForKind = this.#batchLoaders[operation] ??= {};
+		return getOrSet(loadersForKind, batchKey, () => new BatchLoader(fn));
+	}
+	toString() {
+		return "EntityManager";
+	}
+	/** Recursively cascades any pending deletions. */
+	async flushDeletes() {
+		let entities = this.#pendingDeletes;
+		if (entities.length === 0) return;
+		this.#pendingDeletes = [];
+		let relationsToCleanup = [];
+		while (entities.length > 0) {
+			const p = entities.flatMap(getCascadeDeleteRelations).map((r) => r.load().then(() => r.maybeCascadeDelete()));
+			await Promise.all(p);
+			const todos = createTodos(entities);
+			await beforeDelete(this.ctx, todos);
+			for (const entity of entities) {
+				const relations = getRelations(entity);
+				const start = relationsToCleanup.length;
+				relationsToCleanup.length += relations.length;
+				for (let i = 0; i < relations.length; i++) relationsToCleanup[start + i] = relations[i];
+			}
+			entities = this.#pendingDeletes;
+			this.#pendingDeletes = [];
+		}
+		await Promise.all(relationsToCleanup.map((r) => r.cleanupOnEntityDeleted()));
+	}
+	setReactionLogging(arg) {
+		this.#rm.setLogger(typeof arg === "boolean" ? arg ? new ReactionLogger() : void 0 : arg);
+	}
+	setFieldLogging(arg) {
+		if (arg instanceof FieldLogger) {
+			this.#fieldLogger = arg;
+			return;
+		}
+		const writeFn = getDefaultWriteFn(this.ctx);
+		if (typeof arg === "boolean") this.#fieldLogger = arg ? new FieldLogger([], writeFn) : noopFieldLogger;
+		else if (typeof arg === "string" || Array.isArray(arg)) {
+			const watching = (Array.isArray(arg) ? arg : [arg]).map((spec) => {
+				const [_, entity, fields, breakpoint] = spec.match(/^([^.!]+)(?:\.([^!]*))?(!)?$/) ?? fail(`Unsupported spec ${spec}`);
+				const fieldNames = fields?.split(",");
+				const meta = getMetadataForType(entity);
+				fieldNames?.forEach((field) => {
+					if (!meta.allFields[field]) throw new Error(`Field ${field} not found on ${entity}`);
+				});
+				return {
+					entity,
+					fieldNames,
+					breakpoint: !!breakpoint
+				};
+			});
+			this.#fieldLogger = new FieldLogger(watching, writeFn);
+		} else throw new Error("Unsupported override for setFieldLogging");
+	}
+	async [Symbol.asyncDispose]() {
+		await this.flush();
+	}
+	/** Returns entities matching the filter using indexed search when available. */
+	filterEntities(cstr, where) {
+		const meta = getMetadata(cstr);
+		const entities = this.#entitiesByTag.get(meta.tagName) ?? [];
+		if (!hasAnyKey(where)) return entities.filter((e) => e instanceof cstr && !e.isDeletedEntity);
+		if (this.#indexManager.shouldIndexType(entities.length)) {
+			this.#indexManager.enableIndexingForType(meta, entities, where);
+			const result = [];
+			for (const e of this.#indexManager.findMatching(meta, entities, where)) if (e instanceof cstr && !e.isDeletedEntity) result.push(e);
+			return result;
+		} else return entities.filter((e) => e instanceof cstr && !e.isDeletedEntity && entityMatches(e, where));
+	}
+	/**
+	* Creates a new EntityManager that shares the same entities as the current one but allows independent changes.
+	*
+	* This is useful for scenarios where you want to:
+	*
+	* - Preload data for use as a cache
+	* - Make speculative changes that may or may not be committed
+	* - Escape a transaction scope
+	*
+	* The fork will:
+	*
+	* - Copy all currently loaded entities to the new EntityManager
+	* - Copy any loaded relation data to keep `.isLoaded` / `.get` state consistent
+	* - Copy and update references to the EntityManager and its entities in the context, which is itself shallowly copied
+	*
+	* The fork will NOT:
+	*
+	* - Copy any pending changes (must call .flush() first)
+	* - Share any changes made in either EntityManager with the other
+	*
+	* @param opts options to control the fork behavior
+	*  - allowPendingChanges - allows the em being forked to have pending changes and forces the resulting em to have
+	*  `mode` set to "in-memory-writes".  Changes to entities in the original em will be copied to the resulting em.
+	*  Optional. default: false
+	*
+	* @throws {Error} If called on an EntityManager with pending changes
+	* @returns A new EntityManager with copied entity state
+	*/
+	fork(opts = {}) {
+		const { allowPendingChanges = false } = opts;
+		const oldEm = this;
+		const ctx = { ...oldEm.ctx };
+		const newEm = new EntityManager(ctx, { em: oldEm });
+		if (allowPendingChanges) newEm.mode = "in-memory-writes";
+		for (const [tag, entities] of oldEm.#entitiesByTag.entries()) {
+			const baseCstr = getConstructorFromTag(tag);
+			let rows = new Array(entities.length);
+			let i = 0;
+			for (const entity of entities) {
+				const instanceData = entity.__data;
+				if (!allowPendingChanges && instanceData.pendingOperation !== "none") fail("Cannot fork an EntityManager with pending changes");
+				else if (instanceData.isNewEntity) newEm.create(entity.constructor, {});
+				else {
+					rows[i] = createRowFromEntityData(entity);
+					i++;
+				}
+			}
+			if (rows.length !== i) rows = rows.slice(0, i);
+			newEm.hydrate(baseCstr, rows);
+		}
+		function mapEntity(oldEntity) {
+			if (oldEntity.isNewEntity) return newEm.#entitiesById.get(oldEntity.toTaggedString());
+			else return newEm.#entitiesById.get(oldEntity.idTagged);
+		}
+		function mapEntities(v) {
+			if (v === void 0) return void 0;
+			const result = new Array(v.length);
+			for (let i = 0; i < v.length; i++) result[i] = mapEntity(v[i]);
+			return result;
+		}
+		if (allowPendingChanges) for (const oldEntity of oldEm.entities) {
+			const oldInstanceData = oldEntity.__data;
+			if (!(oldInstanceData.isNewEntity || oldInstanceData.isDirtyEntity)) continue;
+			const { originalData: oldOriginalData, data: oldData } = oldInstanceData;
+			const newInstanceData = mapEntity(oldEntity).__data;
+			const { data: newData } = newInstanceData;
+			const maybeEntity = (value) => isEntity(value) ? mapEntity(value) : value;
+			const fields = Object.keys(oldEntity.isNewEntity ? oldData : oldOriginalData);
+			for (const field of fields) {
+				if (field in oldOriginalData) newInstanceData.markFieldDirty(field, maybeEntity(oldOriginalData[field]));
+				newData[field] = maybeEntity(oldData[field]);
+			}
+		}
+		for (const oldEntity of oldEm.entities) {
+			const newEntity = mapEntity(oldEntity);
+			if (oldEntity.isDeletedEntity) {
+				newEntity.__data.markDeleted();
+				continue;
+			}
+			const { relations } = oldEntity.__data;
+			if (!relations) continue;
+			for (const [field, relation] of Object.entries(relations)) {
+				if (!("import" in relation)) continue;
+				if (oldEntity.isNewEntity) {
+					const oldValue = relation.get;
+					if (oldValue === void 0) continue;
+					if (Array.isArray(oldValue) && oldValue.length === 0) continue;
+					const newValue = Array.isArray(oldValue) ? mapEntities(oldValue) : mapEntity(oldValue);
+					delete newEntity.__data.data[field];
+					newEntity[field].setFromOpts(newValue);
+				} else if ("_isLoaded" in relation ? relation._isLoaded : relation.isLoaded) newEntity[field].import(relation, mapEntity, mapEntities);
+			}
+		}
+		for (const [key, value] of Object.entries(ctx)) if (isEntity(value) && value.em === oldEm) ctx[key] = mapEntity(value);
+		else if (value === oldEm) ctx[key] = newEm;
+		return newEm;
+	}
+	importEntity(source, hint, normalizedHint) {
+		if (source.isNewEntity) fail("cannot import new entities");
+		if (source.isDeletedEntity) fail("cannot import deleted entities");
+		if (source.isDirtyEntity) fail("cannot import dirty entities");
+		hint ??= {};
+		if (!normalizedHint) {
+			assertLoaded(source, hint);
+			normalizedHint = deepNormalizeHint(hint);
+		}
+		if (source.em === this) return source;
+		const meta = getMetadata(source);
+		let result = this.#entitiesById.get(source.idTagged);
+		if (!result) {
+			const meta = getMetadata(source);
+			const row = createRowFromEntityData(source);
+			result = this.hydrate(getBaseMeta(meta).cstr, [row])[0];
+		}
+		for (const [fieldName, subHint] of Object.entries(normalizedHint)) {
+			const field = meta.allFields[fieldName];
+			const relationOrProp = result[fieldName];
+			if (!field) {
+				let loadHint = relationOrProp.loadHint ?? fail(`${source}.${fieldName} cannot be imported as it has no loadHint`);
+				this.importEntity(source, loadHint);
+			} else if ("import" in relationOrProp) relationOrProp.import(source[fieldName], (e) => this.importEntity(e, subHint, subHint), (entities) => {
+				if (entities === void 0) return void 0;
+				const result = new Array(entities.length);
+				for (let i = 0; i < entities.length; i++) result[i] = this.importEntity(entities[i], subHint, subHint);
+				return result;
+			});
+		}
+		return result;
+	}
+	addPlugin(plugin) {
+		getEmInternalApi(this).pluginManager.addPlugin(plugin);
+	}
+	getPlugins() {
+		return getEmInternalApi(this).pluginManager.plugins;
+	}
+	get isRefreshing() {
+		return this.#isRefreshing;
+	}
+	get isFlushing() {
+		return this.#fl.isFlushing;
+	}
+	/** Creates a new `type` and marks it as loaded, i.e. we know its collections are all safe to access in memory. */
+	#doCreate(type, opts, partial) {
+		const entity = newEntity(this, type, true);
+		const meta = getMetadata(type);
+		const counter = this.#createCounter ??= /* @__PURE__ */ new Map();
+		const i = (counter.get(meta.tagName) ?? 0) + 1;
+		counter.set(meta.tagName, i);
+		getInstanceData(entity).createId = String(i);
+		this.#doRegister(entity, opts.id);
+		const baseMeta = getBaseMeta(getMetadata(entity));
+		if (baseMeta.timestampFields) this.#assignTimestamps(entity, baseMeta);
+		if (baseMeta.inheritanceType === "sti") setStiDiscriminatorValue(baseMeta, entity);
+		getEmInternalApi(this)?.fieldLogger.logCreate(entity);
+		setOpts(entity, opts, {
+			partial,
+			calledFromConstructor: true
+		});
+		if (!this.fakeInstance) setSyncDefaults(entity);
+		this.#rm.queueAllDownstreamFields(entity, "created");
+		return entity;
+	}
+	#assignTimestamps(entity, baseMeta) {
+		const { createdAt, updatedAt } = baseMeta.timestampFields ?? {};
+		const { data } = getInstanceData(entity);
+		const now = /* @__PURE__ */ new Date();
+		if (createdAt) data[createdAt] = baseMeta.fields[createdAt].serde.mapFromNow(now);
+		if (updatedAt) data[updatedAt] = baseMeta.fields[updatedAt].serde.mapFromNow(now);
+	}
+	/** Registers a newly-instantiated entity with our EntityManager; only called by #doCreate and hydrate. */
+	#doRegister(entity, id, meta, skipDuplicateCheck = false) {
+		const maybeId = id ?? entity.idTaggedMaybe;
+		if (maybeId) {
+			if (!skipDuplicateCheck && this.findExistingInstance(maybeId) !== void 0) throw new Error(`Entity ${entity} has a duplicate instance already loaded`);
+			this.#entitiesById.set(maybeId, entity);
+		} else this.#entitiesById.set(entity.toTaggedString(), entity);
+		getInstanceData(entity).entityIndex = this.#entitiesArray.length;
+		this.#entitiesArray.push(entity);
+		meta ??= getMetadata(entity);
+		const set = this.#entitiesByTag.get(meta.tagName) ?? [];
+		if (set.length === 0) this.#entitiesByTag.set(meta.tagName, set);
+		set.push(entity);
+		if (this.#entitiesArray.length >= this.entityLimit) {
+			const topTypes = [...this.#entitiesByTag.entries()].map(([tag, entities]) => ({
+				tag,
+				count: entities.length
+			})).sort((a, b) => b.count - a.count).slice(0, 3).map(({ tag, count }) => `${tag}=${count}`).join(", ");
+			throw new Error(`More than ${this.entityLimit} entities have been instantiated (top entities: ${topTypes})`);
+		}
+	}
+};
 function getEmInternalApi(em) {
-    return em["__api"];
+	return em["__api"];
 }
-let defaultEntityLimit = 50_000;
+let defaultEntityLimit = 5e4;
 function getDefaultEntityLimit() {
-    return defaultEntityLimit;
+	return defaultEntityLimit;
 }
 function setDefaultEntityLimit(limit) {
-    defaultEntityLimit = limit;
+	defaultEntityLimit = limit;
 }
 function resetDefaultEntityLimit() {
-    defaultEntityLimit = 50_000;
+	defaultEntityLimit = 5e4;
 }
 function isKey(k) {
-    return typeof k === "string";
+	return typeof k === "string";
 }
 /** Compares `a` to `b`, where `b` might be an id. */
 function sameEntity(a, b) {
-    if (a === b) {
-        return true;
-    }
-    // Throw in null handling for findWithNewOrChanged ambivalence
-    if (a === undefined || b === undefined || a === null || b === null) {
-        return (a === undefined || a === null) && (b === undefined || b === null);
-    }
-    // If both are entities, return if they are the same reference
-    if ((0, Entity_1.isEntity)(a) && (0, Entity_1.isEntity)(b)) {
-        return a === b;
-    }
-    // Otherwise check by ID
-    const aId = (0, Entity_1.isEntity)(a) ? a.idTaggedMaybe : a;
-    const bId = (0, Entity_1.isEntity)(b) ? b.idTaggedMaybe : b;
-    return aId === bId;
+	if (a === b) return true;
+	if (a === void 0 || b === void 0 || a === null || b === null) return (a === void 0 || a === null) && (b === void 0 || b === null);
+	if (isEntity(a) && isEntity(b)) return a === b;
+	return (isEntity(a) ? a.idTaggedMaybe : a) === (isEntity(b) ? b.idTaggedMaybe : b);
 }
 /** Compares the value `a` to `b`, with handling of new entities w/o ids assigned yet. */
 function sameReference(a, b) {
-    return sameEntity((0, index_1.isLoadedReference)(a) ? a.get : a.idTaggedMaybe, (0, index_1.isLoadedReference)(b) ? b.get : b.idTaggedMaybe);
+	return sameEntity(isLoadedReference(a) ? a.get : a.idTaggedMaybe, isLoadedReference(b) ? b.get : b.idTaggedMaybe);
 }
 /** Thrown by `findOneOrFail`, 'load' & 'loadAll' if an entity is not found. */
-class NotFoundError extends Error {
-}
-exports.NotFoundError = NotFoundError;
+var NotFoundError = class extends Error {};
 /** Thrown by `findOne` and `findOneOrFail` if more than one entity is found. */
-class TooManyError extends Error {
-    constructor(message) {
-        super(message);
-    }
-}
-exports.TooManyError = TooManyError;
+var TooManyError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
 /**
- * For the entities currently in `todos`, find any reactive validation rules that point
- * from the currently-changed entities back to each rule's originally-defined-in entity,
- * and ensure those entities are added to `todos`.
- */
-async function validateReactiveRules(em, logger, todos, joinRowTodos) {
-    logger?.logStartingValidate(em, todos);
-    // Use a map of rule -> Set<Entity> so that we only invoke a rule once per entity,
-    // even if it was triggered by multiple changed fields.
-    const fns = new Map();
-    // From the given triggered entities, follow the entity's ReactiveRule back
-    // to the reactive rules that need ran, and queue them in the `fn` map
-    async function followAndQueue(triggered, rule) {
-        if (triggered.length === 0)
-            return;
-        const found = (await (0, reactiveHints_1.followReverseHint)(rule.name, triggered, rule.path))
-            .filter((entity) => !entity.isDeletedEntity)
-            .filter((e) => e instanceof rule.cstr);
-        let entities = fns.get(rule.fn);
-        if (!entities) {
-            entities = new Set();
-            fns.set(rule.fn, entities);
-        }
-        logger?.logWalked(triggered, rule, found, "validate");
-        found.forEach((entity) => {
-            entities.add(entity);
-        });
-    }
-    const p1 = Object.values(todos).flatMap((todo) => {
-        const entities = [...todo.inserts, ...todo.updates, ...todo.deletes];
-        // Find each statically-declared reactive rule for the given entity type
-        const rules = todo.metadata.reactiveRules;
-        return rules.map((rule) => {
-            // Of all changed entities of this type, how many specifically trigger this rule?
-            const triggered = entities.filter((e) => {
-                // If the rule is for a different subtype, skip it
-                if (!(e instanceof rule.source))
-                    return false;
-                // Any new-or-deleted entity fires every rule (reactiveRules has already filtered out read-only)
-                if (e.isNewEntity || e.isDeletedEntity)
-                    return true;
-                // Otherwise see if the changed fields overlaps with the rule's fields
-                const changedFields = e.changes.fieldsWithoutRelations;
-                for (const field of changedFields) {
-                    if (rule.fields.includes(field))
-                        return true;
-                }
-                return false;
-            });
-            // From these "triggered" entities, queue the "found"/owner entity to rerun this rule
-            return followAndQueue(triggered, rule);
-        });
-    });
-    const p2 = Object.values(joinRowTodos).flatMap((todo) => {
-        // For enum m2ms the columns include the enum's numeric id, so keep only the entity values.
-        const entities = [...todo.newRows, ...todo.deletedRows].flatMap((jr) => Object.values(jr.columns)).filter(Entity_1.isEntity);
-        // The owning-entity side (applies to both entity-to-entity and entity-to-enum m2ms).
-        const a = todo.m2m.meta
-            .reactiveRules.filter((rule) => rule.fields.includes(todo.m2m.fieldName))
-            .map((rule) => {
-            const triggered = entities.filter((e) => e instanceof todo.m2m.meta.cstr);
-            return followAndQueue(triggered, rule);
-        });
-        // The "other" side only exists for entity-to-entity m2ms; enums have no reverse field.
-        const { otherMeta, otherFieldName } = todo.m2m;
-        const b = otherMeta
-            ? otherMeta
-                .reactiveRules.filter((rule) => rule.fields.includes(otherFieldName))
-                .map((rule) => {
-                const triggered = entities.filter((e) => e instanceof otherMeta.cstr);
-                return followAndQueue(triggered, rule);
-            })
-            : [];
-        return [...a, ...b];
-    });
-    (0, utils_1.failIfAnyRejected)(await Promise.allSettled([...p1, ...p2]));
-    // Now that we've found the fn+entities to run, run them and collect any errors
-    const p3 = [...fns.entries()].flatMap(([fn, entities]) => [...entities].map(async (entity) => coerceError(entity, await fn(entity))));
-    const errors = (0, utils_1.failIfAnyRejected)(await Promise.allSettled(p3)).flat();
-    if (errors.length > 0) {
-        throw new index_1.ValidationErrors(errors);
-    }
+* For the entities currently in `todos`, find any reactive validation rules that point
+* from the currently-changed entities back to each rule's originally-defined-in entity,
+* and ensure those entities are added to `todos`.
+*/
+async function validateReactiveRules(em, logger, todos, joinRowTodos, getRules = (meta) => meta.reactiveRules) {
+	logger.logStartingValidate(em, todos);
+	const fns = /* @__PURE__ */ new Map();
+	const walks = [];
+	async function followAndQueue(triggered, rule) {
+		if (triggered.length === 0) return;
+		const found = (await followReverseHint(rule.name, triggered, rule.path)).filter((entity) => !entity.isDeletedEntity).filter((e) => e instanceof rule.cstr);
+		let entities = fns.get(rule.fn);
+		if (!entities) {
+			entities = /* @__PURE__ */ new Set();
+			fns.set(rule.fn, entities);
+		}
+		walks.push({
+			todo: triggered,
+			r: rule,
+			entities: found
+		});
+		found.forEach((entity) => {
+			entities.add(entity);
+		});
+	}
+	const p1 = Object.values(todos).flatMap((todo) => {
+		const rules = getRules(todo.metadata);
+		if (rules.length === 0) return [];
+		const entities = [
+			...todo.inserts,
+			...todo.updates,
+			...todo.deletes
+		];
+		return rules.map((rule) => {
+			return followAndQueue(entities.filter((e) => {
+				if (!(e instanceof rule.source)) return false;
+				if (e.isNewEntity || e.isDeletedEntity) return true;
+				const { originalData } = getInstanceData(e);
+				for (const field of rule.fields) if (field in originalData) return true;
+				return false;
+			}), rule);
+		});
+	});
+	const p2 = Object.values(joinRowTodos).flatMap((todo) => {
+		const entities = [...todo.newRows, ...todo.deletedRows].flatMap((jr) => Object.values(jr.columns)).filter(isEntity);
+		const a = getRules(todo.m2m.meta).filter((rule) => rule.fields.includes(todo.m2m.fieldName)).map((rule) => {
+			return followAndQueue(entities.filter((e) => e instanceof todo.m2m.meta.cstr), rule);
+		});
+		const { otherMeta, otherFieldName } = todo.m2m;
+		const b = otherMeta ? getRules(otherMeta).filter((rule) => rule.fields.includes(otherFieldName)).map((rule) => {
+			return followAndQueue(entities.filter((e) => e instanceof otherMeta.cstr), rule);
+		}) : [];
+		return [...a, ...b];
+	});
+	failIfAnyRejected(await Promise.allSettled([...p1, ...p2]));
+	logger.logWalks(walks, "validate");
+	const p3 = [...fns.entries()].flatMap(([fn, entities]) => [...entities].map(async (entity) => coerceError(entity, await fn(entity))));
+	const errors = failIfAnyRejected(await Promise.allSettled(p3)).flat();
+	if (errors.length > 0) throw new ValidationErrors(errors);
 }
-// Run *non-reactive* (those with `fields: undefined`) rules of explicitly mutated entities,
-// because even for reactive validations on mutated entities, we defer to addReactiveValidations
-// to mark only the rules that need to run.
-async function validateSimpleRules(todos) {
-    const p = Object.values(todos).flatMap(({ inserts, updates }) => {
-        return [...inserts, ...updates]
-            .filter((e) => !e.isDeletedEntity)
-            .flatMap((entity) => {
-            const rules = (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((m) => m.config.__data.rules);
-            return rules
-                .filter((rule) => rule.hint === undefined)
-                .flatMap(async ({ fn }) => coerceError(entity, await fn(entity)));
-        });
-    });
-    const errors = (0, utils_1.failIfAnyRejected)(await Promise.allSettled(p)).flat();
-    if (errors.length > 0) {
-        throw new index_1.ValidationErrors(errors);
-    }
+async function validateSimpleRules(todos, getRules = (config) => config.rules) {
+	let p = void 0;
+	for (const todoKey in todos) {
+		const { inserts, updates } = todos[todoKey];
+		for (const entities of [inserts, updates]) for (const entity of entities) {
+			if (entity.isDeletedEntity) continue;
+			for (const m of getBaseAndSelfMetas(getMetadata(entity))) for (const rule of getRules(m.config.__data)) {
+				if (rule.hint !== void 0) continue;
+				(p ??= []).push(invokeRule(entity, rule.fn));
+			}
+		}
+	}
+	if (!p) return;
+	const errors = failIfAnyRejected(await Promise.allSettled(p)).flat();
+	if (errors.length > 0) throw new ValidationErrors(errors);
+}
+/** Invokes a single validation rule, coercing its result/sync throws into a promise. */
+async function invokeRule(entity, fn) {
+	return coerceError(entity, await fn(entity));
 }
 function driverBeforeBegin(em, txn) {
-    return Promise.all(getEmInternalApi(em).hooks.beforeBegin.map((fn) => fn(em, txn)));
+	return Promise.all(getEmInternalApi(em).hooks.beforeBegin.map((fn) => fn(em, txn)));
 }
 function driverAfterBegin(em, txn) {
-    return Promise.all(getEmInternalApi(em).hooks.afterBegin.map((fn) => fn(em, txn)));
+	return Promise.all(getEmInternalApi(em).hooks.afterBegin.map((fn) => fn(em, txn)));
 }
 function driverBeforeCommit(em, txn) {
-    return Promise.all(getEmInternalApi(em).hooks.beforeCommit.map((fn) => fn(em, txn)));
+	return Promise.all(getEmInternalApi(em).hooks.beforeCommit.map((fn) => fn(em, txn)));
 }
 function driverAfterCommit(em, txn) {
-    return Promise.all(getEmInternalApi(em).hooks.afterCommit.map((fn) => fn(em, txn)));
+	return Promise.all(getEmInternalApi(em).hooks.afterCommit.map((fn) => fn(em, txn)));
 }
 async function runHookOnTodos(ctx, hook, todos, keys) {
-    const entities = Object.values(todos).flatMap((todo) => {
-        return keys.flatMap((k) => todo[k].filter((e) => k === "deletes" || !e.isDeletedEntity));
-    });
-    return runHook(ctx, hook, entities);
+	let entities = void 0;
+	for (const todoKey in todos) {
+		const todo = todos[todoKey];
+		if (!metaHasHook(todo.metadata, hook)) continue;
+		for (const k of keys) for (const e of todo[k]) {
+			if (k !== "deletes" && e.isDeletedEntity) continue;
+			(entities ??= []).push(e);
+		}
+	}
+	if (entities) return runHook(ctx, hook, entities);
+}
+/** Returns whether `meta`'s base/self/sub hierarchy has any `hook` functions registered. */
+function metaHasHook(meta, hook) {
+	for (const m of getBaseSelfAndSubMetas(meta)) if (m.config.__data.hooks[hook].length > 0) return true;
+	return false;
 }
 async function runHook(ctx, hook, entities) {
-    const p = entities.flatMap((entity) => {
-        const hookFns = (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((m) => m.config.__data.hooks[hook]);
-        // Use an explicit `async` here to ensure all hooks are promises, i.e. so that a non-promise
-        // hook blowing up doesn't orphan the others .
-        return hookFns.map(async (fn) => fn(entity, ctx));
-    });
-    // Use `allSettled` so that even if 1 hook blows up, we don't orphan other hooks mid-flush
-    // (causes weird errors when/if they try to access the EntityManager that has "moved on")
-    const results = await Promise.allSettled(p);
-    (0, utils_1.failIfAnyRejected)(results);
+	let p = void 0;
+	for (const entity of entities) for (const m of getBaseAndSelfMetas(getMetadata(entity))) for (const fn of m.config.__data.hooks[hook]) (p ??= []).push(invokeHook(fn, entity, ctx));
+	if (!p) return;
+	const results = await Promise.allSettled(p);
+	failIfAnyRejected(results);
+}
+/** Invokes a single hook fn, coercing sync throws into rejections. */
+async function invokeHook(fn, entity, ctx) {
+	return fn(entity, ctx);
 }
 function beforeDelete(ctx, todos) {
-    return runHookOnTodos(ctx, "beforeDelete", todos, ["deletes"]);
+	return runHookOnTodos(ctx, "beforeDelete", todos, ["deletes"]);
 }
 function beforeFlush(ctx, todos) {
-    return runHookOnTodos(ctx, "beforeFlush", todos, ["inserts", "updates"]);
+	return runHookOnTodos(ctx, "beforeFlush", todos, ["inserts", "updates"]);
 }
 function beforeCreate(ctx, todos) {
-    return runHookOnTodos(ctx, "beforeCreate", todos, ["inserts"]);
+	return runHookOnTodos(ctx, "beforeCreate", todos, ["inserts"]);
 }
 function beforeUpdate(ctx, todos) {
-    return runHookOnTodos(ctx, "beforeUpdate", todos, ["updates"]);
+	return runHookOnTodos(ctx, "beforeUpdate", todos, ["updates"]);
 }
 function afterValidation(ctx, todos) {
-    return runHookOnTodos(ctx, "afterValidation", todos, ["inserts", "updates"]);
+	return runHookOnTodos(ctx, "afterValidation", todos, ["inserts", "updates"]);
 }
 /** Collects changed entities from flush todos, i.e. m2m endpoint entities. */
 function entitiesFromTodos(entityTodos, joinRowTodos) {
-    const entities = new Set();
-    for (const todo of Object.values(entityTodos)) {
-        [...todo.inserts, ...todo.updates, ...todo.deletes].forEach((entity) => entities.add(entity));
-    }
-    for (const todo of Object.values(joinRowTodos)) {
-        [...todo.newRows, ...todo.deletedRows].forEach((row) => {
-            // For enum m2ms, a column value is the enum's numeric id rather than an entity.
-            Object.values(row.columns).forEach((value) => {
-                if ((0, Entity_1.isEntity)(value))
-                    entities.add(value);
-            });
-        });
-    }
-    return [...entities];
+	const entities = /* @__PURE__ */ new Set();
+	for (const todo of Object.values(entityTodos)) for (const list of [
+		todo.inserts,
+		todo.updates,
+		todo.deletes
+	]) for (const entity of list) entities.add(entity);
+	for (const todo of Object.values(joinRowTodos)) for (const rows of [todo.newRows, todo.deletedRows]) for (const row of rows) for (const value of Object.values(row.columns)) if (isEntity(value)) entities.add(value);
+	return [...entities];
 }
 function beforeCommit(ctx, entities) {
-    return runHook(ctx, "beforeCommit", [...entities]);
+	return runHook(ctx, "beforeCommit", [...entities]);
 }
 function afterCommit(ctx, entities) {
-    return runHook(ctx, "afterCommit", [...entities]);
+	return runHook(ctx, "afterCommit", [...entities]);
 }
 /** Given a validation rule result `maybeError`, returns a canonical `ValidationError[]`. */
 function coerceError(entity, maybeError) {
-    if (maybeError === undefined) {
-        return [];
-    }
-    else if (typeof maybeError === "string") {
-        return [{ entity, message: maybeError }];
-    }
-    else if (Array.isArray(maybeError)) {
-        return maybeError.map((e) => {
-            if (typeof e === "string") {
-                return { entity, message: e };
-            }
-            else {
-                return { entity, ...e };
-            }
-        });
-    }
-    else {
-        return [{ entity, ...maybeError }];
-    }
+	if (maybeError === void 0) return [];
+	else if (typeof maybeError === "string") return [{
+		entity,
+		message: maybeError
+	}];
+	else if (Array.isArray(maybeError)) return maybeError.map((e) => {
+		if (typeof e === "string") return {
+			entity,
+			message: e
+		};
+		else return {
+			entity,
+			...e
+		};
+	});
+	else return [{
+		entity,
+		...maybeError
+	}];
 }
 /** Evaluates each (non-async) derived field to see if it's value has changed. */
 function recalcSynchronousDerivedFields(todos) {
-    const entities = Object.values(todos)
-        .flatMap((todo) => [...todo.inserts, ...todo.updates])
-        .filter((e) => !e.isDeletedEntity);
-    const derivedFieldsByMeta = new Map([...new Set(entities.map(index_1.getMetadata))].map((m) => {
-        return [
-            m,
-            Object.values(m.allFields)
-                .filter((f) => (f.kind === "primitive" || f.kind === "enum") && f.derived === "sync")
-                .map((f) => f.fieldName),
-        ];
-    }));
-    for (const entity of entities) {
-        const derivedFields = derivedFieldsByMeta.get((0, index_1.getMetadata)(entity)) || [];
-        derivedFields.forEach((fieldName) => {
-            // setField will intelligently mark/not mark the field as dirty.
-            (0, fields_1.setField)(entity, fieldName, entity[fieldName]);
-        });
-    }
+	for (const todoKey in todos) {
+		const todo = todos[todoKey];
+		for (const entities of [todo.inserts, todo.updates]) for (const entity of entities) {
+			if (entity.isDeletedEntity) continue;
+			for (const fieldName of getMetadata(entity).syncDerivedFields) setField(entity, fieldName, entity[fieldName]);
+		}
+	}
 }
 /** Recursively crawls through `entity`, with the given populate `deep` hint, and adds anything found to `found`. */
-async function crawl(found, 
-// We keep skipMap separated out, instead of tuple-izing `found`, so that `found`
-// can be a set that is cheap to insert & check for duplicates.
-skipMap, entities, deep, opts = {}) {
-    const { skipIf = () => false } = opts ?? {};
-    const skip = (0, index_1.deepNormalizeHint)(opts.skip ?? {});
-    // If we're passed `skip = { author: "publisher" }`, which is asking to "don't set `author.publisher`", then
-    // `author` will technically be a key in the "skip hint", but it's only there for us to hop down into.
-    // So we actually _don't_ skip any fields that have sub-hints, b/c it's the sub-hints themselves we want to skip.
-    const skipFields = Object.keys(skip).filter((key) => Object.keys(skip[key]).length === 0);
-    // It's tempting to check `!found.has(entity)` here, but that would short-circuit later crawling the
-    // entity at a potentially different point in the graph, i.e. a deep hint like:
-    //
-    // `{ comment: parent, books: { author: "publisher" } }`
-    //
-    // If the `comment.parent` was the same `Author` as a `books.author`, but we "crawled it first", we'd miss
-    // crawling through the author a 2nd time and cloning the publisher.
-    const entitiesToClone = entities.filter((e) => !skipIf(e));
-    for (const entity of entitiesToClone) {
-        found.add(entity);
-        skipMap.set(entity, skipFields);
-    }
-    await Promise.all(entitiesToClone.flatMap((entity) => Object.entries(adaptHint(deep)).map(async ([relationName, nested]) => {
-        const relation = entity[relationName];
-        // If we're using a deep `skip` hint, drill in to it
-        const _opts = { ...opts, skip: skip[relationName] };
-        if (relation instanceof index_1.OneToManyCollection) {
-            const relatedEntities = await relation.load();
-            await crawl(found, skipMap, relatedEntities, nested, _opts);
-        }
-        else if (relation instanceof relations_1.OneToOneReferenceImpl) {
-            const related = await relation.load();
-            if (related) {
-                await crawl(found, skipMap, [related], nested, _opts);
-            }
-        }
-        else if (relation instanceof relations_1.ManyToOneReferenceImpl) {
-            const related = await relation.load();
-            if (related) {
-                await crawl(found, skipMap, [related], nested, _opts);
-            }
-        }
-        else if (relation instanceof relations_1.ReactiveReferenceImpl) {
-            const relatedEntities = await relation.load();
-            await crawl(found, skipMap, relatedEntities, nested, _opts);
-        }
-        else {
-            (0, utils_1.fail)(`Uncloneable relation: ${relationName}`);
-        }
-    })));
+async function crawl(found, skipMap, entities, deep, opts = {}) {
+	const { skipIf = () => false } = opts ?? {};
+	const skip = deepNormalizeHint(opts.skip ?? {});
+	const skipFields = Object.keys(skip).filter((key) => Object.keys(skip[key]).length === 0);
+	const entitiesToClone = entities.filter((e) => !skipIf(e));
+	for (const entity of entitiesToClone) {
+		found.add(entity);
+		skipMap.set(entity, skipFields);
+	}
+	await Promise.all(entitiesToClone.flatMap((entity) => Object.entries(adaptHint(deep)).map(async ([relationName, nested]) => {
+		const relation = entity[relationName];
+		const _opts = {
+			...opts,
+			skip: skip[relationName]
+		};
+		if (relation instanceof OneToManyCollection) await crawl(found, skipMap, await relation.load(), nested, _opts);
+		else if (relation instanceof OneToOneReferenceImpl) {
+			const related = await relation.load();
+			if (related) await crawl(found, skipMap, [related], nested, _opts);
+		} else if (relation instanceof ManyToOneReferenceImpl) {
+			const related = await relation.load();
+			if (related) await crawl(found, skipMap, [related], nested, _opts);
+		} else if (relation instanceof ReactiveReferenceImpl) await crawl(found, skipMap, await relation.load(), nested, _opts);
+		else fail(`Uncloneable relation: ${relationName}`);
+	})));
 }
 /** Takes our flexible string or array or hash load hint and makes it always a hash. */
 function adaptHint(hint) {
-    if (typeof hint === "string") {
-        return { [hint]: {} };
-    }
-    else if (Array.isArray(hint)) {
-        return Object.fromEntries(hint.map((relation) => [relation, {}]));
-    }
-    else if (hint) {
-        return hint;
-    }
-    else {
-        return {};
-    }
+	if (typeof hint === "string") return { [hint]: {} };
+	else if (Array.isArray(hint)) return Object.fromEntries(hint.map((relation) => [relation, {}]));
+	else if (hint) return hint;
+	else return {};
 }
 function isDefined(param) {
-    return param !== null && param !== undefined;
+	return param !== null && param !== void 0;
 }
 function getCascadeDeleteRelations(entity) {
-    return (0, index_1.getBaseAndSelfMetas)((0, index_1.getMetadata)(entity)).flatMap((meta) => {
-        return meta.config.__data.cascadeDeleteFields.map((fieldName) => entity[fieldName]);
-    });
+	return getBaseAndSelfMetas(getMetadata(entity)).flatMap((meta) => {
+		return meta.config.__data.cascadeDeleteFields.map((fieldName) => entity[fieldName]);
+	});
 }
 function isCustomRelation(r) {
-    return r instanceof index_1.CustomCollection || r instanceof index_1.CustomReference || r instanceof relations_1.ReactiveReferenceImpl;
+	return r instanceof CustomCollection || r instanceof CustomReference || r instanceof ReactiveReferenceImpl;
 }
 function maybeBumpUpdatedAt(rm, todos, now) {
-    for (const todo of Object.values(todos)) {
-        const { updatedAt } = todo.metadata.timestampFields ?? {};
-        if (updatedAt) {
-            for (const e of todo.updates) {
-                // We avoid going through `setField` because in unit tests, it might detect that our
-                // bump's timestamp isn't actually different from the current value, and skip treating
-                // it has changed. This is technically true, but this will break the oplock SQL generation,
-                // so force the field to be dirty.
-                const orm = (0, BaseEntity_1.getInstanceData)(e);
-                orm.markFieldDirty(updatedAt, (0, fields_1.getField)(e, updatedAt));
-                const serde = todo.metadata.fields[updatedAt].serde;
-                orm.data[updatedAt] = serde.mapFromNow(now);
-                rm.queueDownstreamReactables(e, updatedAt);
-            }
-        }
-    }
+	for (const todo of Object.values(todos)) {
+		const { updatedAt } = todo.metadata.timestampFields ?? {};
+		if (updatedAt) for (const e of todo.updates) {
+			const orm = getInstanceData(e);
+			orm.markFieldDirty(updatedAt, getField(e, updatedAt));
+			const serde = todo.metadata.fields[updatedAt].serde;
+			orm.data[updatedAt] = serde.mapFromNow(now);
+			rm.queueDownstreamReactables(e, updatedAt);
+		}
+	}
 }
-let lastNow = undefined;
-// exposed so tests that do their own time management can override lastNow to get correct updatedAt values
+let lastNow = void 0;
 function setLastNow(now) {
-    lastNow = now;
+	lastNow = now;
 }
 function getNow() {
-    let now = new Date();
-    // If we detect time has not progressed (or went backwards), we're probably in test that
-    // has frozen time, which can throw off our oplocks b/c if Joist issues multiple `UPDATE`s
-    // with exactly the same `updated_at`, the `updated_at` SQL trigger fallback will think "the caller
-    // didn't self-manage `updated_at`" and so bump it for them. Which is fine, but now
-    // Joist doesn't know about the bumped time, and the 2nd `UPDATE` will fail.
-    if (lastNow && (lastNow.getTime() === now.getTime() || now.getTime() < lastNow.getTime())) {
-        now = new Date(lastNow.getTime() + 1);
-    }
-    lastNow = now;
-    return now;
+	let now = /* @__PURE__ */ new Date();
+	if (lastNow && (lastNow.getTime() === now.getTime() || now.getTime() < lastNow.getTime())) now = new Date(lastNow.getTime() + 1);
+	lastNow = now;
+	return now;
 }
 /** Given a `row` from the db, resolves the CTI/STI subtype, if applicable. */
-function findConcreteMeta(maybeBaseMeta, row) {
-    // Common case of no CTI or STI inheritance
-    if (!row.__class && maybeBaseMeta.inheritanceType !== "sti") {
-        return maybeBaseMeta;
-    }
-    if (row.__class) {
-        if (row.__class === "_" && maybeBaseMeta.ctiAbstract) {
-            throw new Error(`${maybeBaseMeta.type} ${(0, index_1.tagId)(maybeBaseMeta, row.id)} must be instantiated via a subtype`);
-        }
-        // Look for the CTI __class from the driver telling us which subtype to instantiate
-        return maybeBaseMeta.subTypesByType.get(row.__class) ?? maybeBaseMeta;
-    }
-    else if (maybeBaseMeta.inheritanceType === "sti") {
-        // Look for the STI discriminator value
-        const baseMeta = (0, index_1.getBaseMeta)(maybeBaseMeta);
-        const value = row[baseMeta.stiDiscriminatorColumnName];
-        return baseMeta.subTypesByStiValue.get(value) ?? baseMeta;
-    }
-    else {
-        throw new Error("Unknown inheritance type");
-    }
+function findConcreteMeta(maybeBaseMeta, rowData, rowIndex) {
+	if (maybeBaseMeta.inheritanceType === void 0) return maybeBaseMeta;
+	const __class = rowData.get(rowIndex, "__class");
+	if (!__class && maybeBaseMeta.inheritanceType !== "sti") return maybeBaseMeta;
+	if (__class) {
+		if (__class === "_" && maybeBaseMeta.ctiAbstract) {
+			const id = rowData.get(rowIndex, "id");
+			throw new Error(`${maybeBaseMeta.type} ${tagId(maybeBaseMeta, id)} must be instantiated via a subtype`);
+		}
+		return maybeBaseMeta.subTypesByType.get(__class) ?? maybeBaseMeta;
+	} else if (maybeBaseMeta.inheritanceType === "sti") {
+		const baseMeta = getBaseMeta(maybeBaseMeta);
+		const value = rowData.get(rowIndex, baseMeta.stiDiscriminatorColumnName);
+		return baseMeta.subTypesByStiValue.get(value) ?? baseMeta;
+	} else throw new Error("Unknown inheritance type");
 }
 /** Sets the `Animal.type` enum to the right subtype value. */
 function setStiDiscriminatorValue(baseMeta, entity) {
-    const typeName = entity.constructor.name;
-    const st = baseMeta.subTypesByType.get(typeName);
-    if (st) {
-        const field = baseMeta.fields[baseMeta.stiDiscriminatorField];
-        const code = field.enumDetailType.findById(st.stiDiscriminatorValue).code;
-        entity[baseMeta.stiDiscriminatorField] = code;
-    }
-    else {
-        entity[baseMeta.stiDiscriminatorField] = undefined;
-    }
+	const typeName = entity.constructor.name;
+	const st = baseMeta.subTypesByType.get(typeName);
+	if (st) {
+		const code = baseMeta.fields[baseMeta.stiDiscriminatorField].enumDetailType.findById(st.stiDiscriminatorValue).code;
+		entity[baseMeta.stiDiscriminatorField] = code;
+	} else entity[baseMeta.stiDiscriminatorField] = void 0;
 }
 function findPendingFlushEntities(maybePendingFlushEntities, hooksInvoked, pendingFlush, pendingHooks, alreadyRanHooks) {
-    for (const e of maybePendingFlushEntities) {
-        if ((0, BaseEntity_1.getInstanceData)(e).pendingOperation === "none") {
-            maybePendingFlushEntities.delete(e);
-            continue;
-        }
-        if (!hooksInvoked.has(e)) {
-            pendingHooks.add(e);
-        }
-        else {
-            alreadyRanHooks.add(e);
-        }
-        pendingFlush.add(e);
-    }
+	for (const e of maybePendingFlushEntities) {
+		if (getInstanceData(e).pendingOperation === "none") {
+			maybePendingFlushEntities.delete(e);
+			continue;
+		}
+		if (!hooksInvoked.has(e)) pendingHooks.add(e);
+		else alreadyRanHooks.add(e);
+		pendingFlush.add(e);
+	}
 }
 /** Returns true if the caller explicitly asked `find` to use SQL pagination. */
 function hasPaginationSettings(options) {
-    return "limit" in options || "offset" in options;
+	return "limit" in options || "offset" in options;
 }
 /** An error we throw to get knex to `ROLLBACK`, but then catch. */
-class InMemoryRollbackError extends Error {
-}
+var InMemoryRollbackError = class extends Error {};
 /** An error thrown when `em.mode === "read-only"` but entities are mutated/flushed. */
-class ReadOnlyError extends Error {
-    constructor() {
-        super("EntityManager is read-only");
-    }
-}
-exports.ReadOnlyError = ReadOnlyError;
+var ReadOnlyError = class extends Error {
+	constructor() {
+		super("EntityManager is read-only");
+	}
+};
 function maybeSetupHookOrdering(todos) {
-    // I'm too rushed to use a topo sort
-    const group1 = {};
-    const group2 = {};
-    for (const todo of Object.values(todos)) {
-        // If I should run before `cstr`, I go in group1
-        const shouldRunBeforeAnotherGroup = todo.metadata.config.__data.runHooksBefore.some((cstr) => (0, index_1.getBaseMeta)((0, index_1.getMetadata)(cstr)).type in todos);
-        const group = shouldRunBeforeAnotherGroup ? group1 : group2;
-        group[todo.metadata.type] = todo;
-    }
-    return Object.keys(group1).length ? [group1, group2] : [group2];
+	const group1 = {};
+	const group2 = {};
+	for (const todo of Object.values(todos)) {
+		const group = todo.metadata.config.__data.runHooksBefore.some((cstr) => getBaseMeta(getMetadata(cstr)).type in todos) ? group1 : group2;
+		group[todo.metadata.type] = todo;
+	}
+	return Object.keys(group1).length ? [group1, group2] : [group2];
 }
 /**
- * Given an `err` thrown in "a different context", i.e. a database error or dataloader error
- * that doesn't include our stack trace, append our stack for better debugging.
- *
- * See https://github.com/brianc/node-postgres/pull/2983
- */
+* Given an `err` thrown in "a different context", i.e. a database error or dataloader error
+* that doesn't include our stack trace, append our stack for better debugging.
+*
+* See https://github.com/brianc/node-postgres/pull/2983
+*/
 function appendStack(err, dummy) {
-    if (err && typeof err === "object" && "stack" in err) {
-        err.stack += dummy.stack.replace(/.*\n/, "\n");
-    }
-    return err;
+	if (err && typeof err === "object" && "stack" in err) err.stack += dummy.stack.replace(/.*\n/, "\n");
+	return err;
 }
 /** Probe for `ctx.logger.debug` if it exists, otherwise fallback on `console.log`. */
 function getDefaultWriteFn(ctx) {
-    return ctx &&
-        typeof ctx === "object" &&
-        "logger" in ctx &&
-        ctx.logger &&
-        typeof ctx.logger === "object" &&
-        "debug" in ctx.logger &&
-        ctx.logger.debug instanceof Function
-        ? ctx.logger.debug.bind(ctx.logger)
-        : console.log;
+	return ctx && typeof ctx === "object" && "logger" in ctx && ctx.logger && typeof ctx.logger === "object" && "debug" in ctx.logger && ctx.logger.debug instanceof Function ? ctx.logger.debug.bind(ctx.logger) : console.log;
 }
 const fieldMap = {};
-// Generates what a row from the db would look like for a given entity
 function createRowFromEntityData(e, opts = {}) {
-    const { preferOriginalData = true } = opts;
-    const { row: oldRow, data, originalData } = e.__data;
-    const __class = e.constructor.name;
-    const { metadata: meta } = e.__data;
-    if (!fieldMap[__class]) {
-        fieldMap[__class] = [];
-        for (const field of Object.values(meta.allFields)) {
-            if (!field.serde)
-                continue;
-            for (const column of field.serde.columns) {
-                fieldMap[__class].push([field, column]);
-            }
-        }
-    }
-    const row = meta.inheritanceType === "cti" ? { __class } : {};
-    for (const [field, column] of fieldMap[__class]) {
-        const value = 
-        // Ideally, we could only go through the serde for data that has actually changed since the last time it was
-        // fetched from the db and just use the row value for everything else.  Unfortunately, we lose track of which
-        // fields are modified on flush. So we have to assume that anything present in `data` is a change and push it
-        // through the serde.
-        field.fieldName in originalData || field.fieldName in data
-            ? // If our field is in originalData, then the field has been changed since flush. Our `row` should
-                // reflect what would come from the db if we queried it right now, so use originalData when present
-                column.rowValue(preferOriginalData && field.fieldName in originalData ? originalData : data)
-            : // `data` is lazy and isn't set until it's accessed, so if the field isn't present there, then we should
-                // be safe to pull the raw data out of `row`
-                oldRow[column.columnName];
-        row[column.columnName] = value ?? null;
-    }
-    return row;
+	const { preferOriginalData = true } = opts;
+	const { rowData, rowIndex, data, originalData } = e.__data;
+	const __class = e.constructor.name;
+	const { metadata: meta } = e.__data;
+	if (!fieldMap[__class]) {
+		fieldMap[__class] = [];
+		for (const field of Object.values(meta.allFields)) {
+			if (!field.serde) continue;
+			for (const column of field.serde.columns) fieldMap[__class].push([field, column]);
+		}
+	}
+	const row = meta.inheritanceType === "cti" ? { __class } : {};
+	for (const [field, column] of fieldMap[__class]) {
+		const value = field.fieldName in originalData || field.fieldName in data ? column.rowValue(preferOriginalData && field.fieldName in originalData ? originalData : data) : rowData.get(rowIndex, column.columnName);
+		row[column.columnName] = value ?? null;
+	}
+	return row;
 }
+//#endregion
+export { EntityManager, NotFoundError, ReadOnlyError, TooManyError, appendStack, createRowFromEntityData, driverAfterBegin, driverAfterCommit, driverBeforeBegin, driverBeforeCommit, getDefaultEntityLimit, getEmInternalApi, isDefined, isId, isKey, resetDefaultEntityLimit, sameEntity, sameReference, setDefaultEntityLimit, setLastNow };
+
 //# sourceMappingURL=EntityManager.js.map