joist-core 2.3.0 → 2.4.0

package/build/newTestInstance.js

@@ -1,784 +1,522 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryInitialValue = exports.testIndex = exports.testZonedDateTime = exports.testPlainDateTime = exports.testPlainDate = exports.testDate = exports.factories = void 0;
-exports.newTestInstance = newTestInstance;
-exports.defaultValue = defaultValue;
-exports.noValue = noValue;
-exports.maybeBranchValue = maybeBranchValue;
-exports.maybeNew = maybeNew;
-exports.maybeNewPoly = maybeNewPoly;
-exports.getTestIndex = getTestIndex;
-exports.setFactoryLogging = setFactoryLogging;
-exports.isFactoryCreation = isFactoryCreation;
-exports.resetFactoryCreated = resetFactoryCreated;
-const joist_utils_1 = require("joist-utils");
-const BaseEntity_1 = require("./BaseEntity");
-const Entity_1 = require("./Entity");
-const EntityManager_1 = require("./EntityManager");
-const EntityMetadata_1 = require("./EntityMetadata");
-const defaults_1 = require("./defaults");
-const FactoryLogger_1 = require("./logging/FactoryLogger");
-const temporal_1 = require("./temporal");
-const utils_1 = require("./utils");
-let logger = undefined;
-// Maybe we should scope this per-em, but assuming tests are single-threaded for now
-let factoryCreated = new WeakSet();
-// The last EntityManager used in a factory call, for the `factories` proxy to resolve entities
+import { maybeRequireTemporal } from "./serde/temporal.js";
+import { assertNever } from "./utils.js";
+import "./typeMap.js";
+import { getBaseAndSelfMetas, getBaseSelfAndSubMetas, getMetadata, isManyToOneField, isOneToOneField } from "./EntityMetadata.js";
+import { hasDefaultValue, setAsyncDefaultsSynchronously } from "./defaults.js";
+import { FactoryLogger } from "./logging/FactoryLogger.js";
+import "./index.js";
+import { isId } from "./EntityManager.js";
+import { isEntity } from "./Entity.js";
+import { getInstanceData } from "./BaseEntity.js";
+import { isPlainObject } from "joist-utils";
+//#region src/newTestInstance.ts
+let logger = void 0;
+let factoryCreated = /* @__PURE__ */ new WeakSet();
 let lastFactoryEm;
 const factoryKeyRegex = /^([a-zA-Z]+)(\d+)$/;
 /**
- * A proxy that allows accessing factory-created entities by their factory id.
- *
- * For example, after creating entities with `as` keys:
- *
- * ```ts
- * newAuthor(em, { books: [{ is: "b#1" }, { is: "b#2", prequel: "b#1" }] });
- * const { b1, b2 } = factories;
- * ```
- *
- * The proxy parses property names like `b1` into `b#1` and looks up the entity
- * in the most recently used EntityManager.
- */
-exports.factories = new Proxy(Object.create(null), {
-    get(_target, prop) {
-        if (typeof prop !== "string")
-            return undefined;
-        const match = prop.match(factoryKeyRegex);
-        if (!match)
-            throw new Error(`Invalid id '${prop}', expected 'b1' or 'a2'`);
-        const [, tag, id] = match;
-        if (!lastFactoryEm)
-            throw new Error("No EntityManager available; call a factory like newAuthor(em) first");
-        const testId = `${tag}#${id}`;
-        const entity = lastFactoryEm.entities.find((e) => getTestId(lastFactoryEm, e) === testId);
-        if (!entity)
-            throw new Error(`No factory entity found for '${testId}'`);
-        return entity;
-    },
-});
-// Chosen b/c it's a monday https://www.timeanddate.com/calendar/monthly.html?year=2018&month=1&country=1
-const jan1 = new Date(2018, 0, 1);
-exports.testDate = jan1;
-const Temporal = (0, temporal_1.maybeRequireTemporal)()?.Temporal;
-exports.testPlainDate = Temporal?.PlainDate.from("2018-01-01");
-exports.testPlainDateTime = exports.testPlainDate?.toPlainDateTime("00:00:00");
-exports.testZonedDateTime = exports.testPlainDate?.toZonedDateTime("UTC");
-const knownUseKeys = ["is", "use", "useLogging", "useExistingCheck", "useFactoryDefaults"];
+* A proxy that allows accessing factory-created entities by their factory id.
+*
+* For example, after creating entities with `as` keys:
+*
+* ```ts
+* newAuthor(em, { books: [{ is: "b#1" }, { is: "b#2", prequel: "b#1" }] });
+* const { b1, b2 } = factories;
+* ```
+*
+* The proxy parses property names like `b1` into `b#1` and looks up the entity
+* in the most recently used EntityManager.
+*/
+const factories = new Proxy(Object.create(null), { get(_target, prop) {
+	if (typeof prop !== "string") return void 0;
+	const match = prop.match(factoryKeyRegex);
+	if (!match) throw new Error(`Invalid id '${prop}', expected 'b1' or 'a2'`);
+	const [, tag, id] = match;
+	if (!lastFactoryEm) throw new Error("No EntityManager available; call a factory like newAuthor(em) first");
+	const testId = `${tag}#${id}`;
+	const entity = lastFactoryEm.entities.find((e) => getTestId(lastFactoryEm, e) === testId);
+	if (!entity) throw new Error(`No factory entity found for '${testId}'`);
+	return entity;
+} });
+const testDate = new Date(2018, 0, 1);
+const Temporal = maybeRequireTemporal()?.Temporal;
+const testPlainDate = Temporal?.PlainDate.from("2018-01-01");
+const testPlainDateTime = testPlainDate?.toPlainDateTime("00:00:00");
+const testZonedDateTime = testPlainDate?.toZonedDateTime("UTC");
+const knownUseKeys = [
+	"is",
+	"use",
+	"useLogging",
+	"useExistingCheck",
+	"useFactoryDefaults"
+];
 /**
- * Creates a test instance of `T`.
- *
- * If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
- * to try and resolve "already created" / singleton instances. The `useExisting` callback is
- * useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
- * literal, maybe object instance" opts that tests pass into the factory.
- */
-function newTestInstance(em, cstr, 
-/** The test's test-specific override opts. */
-testOpts = {}, 
-/** The factory file's default opts. */
-factoryOpts = {}) {
-    // Remember the em so the `factories` proxy can look up entities
-    lastFactoryEm = em;
-    // The first factory that is asked to debug, without one in place, will create+unset the logger.
-    let ownsTheLogger = !logger && testOpts.useLogging;
-    if (ownsTheLogger)
-        logger = new FactoryLogger_1.FactoryLogger();
-    logger?.logCreating(cstr);
-    logger?.indent();
-    const meta = (0, EntityMetadata_1.getMetadata)(cstr);
-    const opts = mergeOpts(meta, testOpts, factoryOpts);
-    const use = getOrCreateUseMap(opts);
-    const selfFields = [];
-    // Create just the primitive and m2o fields 1st, so we can create a minimal/valid
-    // instance of the entity. We'll do the o2m/other fields as a second pass.
-    const initialOpts = Object.values(meta.allFields)
-        .map((field) => {
-        const { fieldName } = field;
-        // Don't fill in required fields if told not to
-        const ignoreAllDefaults = "useFactoryDefaults" in opts && opts.useFactoryDefaults === "none";
-        // If the field has a default value, don't force fill it, even if passed `author: undefined`
-        const required = field.required && !ignoreAllDefaults && !(0, defaults_1.hasDefaultValue)(meta, fieldName);
-        // Use the opts value if they passed one in
-        if (fieldName in opts && opts[fieldName] !== defaultValueMarker) {
-            const optValue = opts[fieldName];
-            // We don't explicitly support null (callers should pass undefined), but we accept it
-            // because the factory might have done `const { author, ... } = opts` and is accidentally
-            // passing an `author: undefined` without meaning too.
-            const shouldRespectUndefined = !required;
-            if (optValue === null || (optValue === undefined && shouldRespectUndefined)) {
-                return [];
-            }
-            switch (field.kind) {
-                case "m2o":
-                case "poly":
-                    return [fieldName, resolveFactoryOpt(em, opts, field, optValue, undefined, undefined)];
-                case "o2o":
-                case "o2m":
-                case "m2m":
-                    // We do these in the 2nd pass after `entity` exists (see additionalOpts)
-                    return [];
-                case "m2mEnum":
-                    // Enum codes have no entity identity, so pass them straight through.
-                    return [fieldName, optValue];
-                case "lo2m":
-                    // If a child is passing themselves into a parent that is a large collection, just ignore it
-                    return [];
-                case "primitive":
-                case "enum":
-                case "primaryKey":
-                    // Look for strings that want to use the test index
-                    if (typeof optValue === "string" && optValue.includes(testIndexString)) {
-                        const actualIndex = getTestIndex(em, meta.cstr);
-                        const value = optValue.replace(testIndexString, String(actualIndex));
-                        return [fieldName, value];
-                    }
-                    else if (typeof optValue === "number" && optValue === exports.testIndex) {
-                        const actualIndex = getTestIndex(em, meta.cstr);
-                        return [fieldName, actualIndex];
-                    }
-                    // Otherwise just use the user's opt value as-is
-                    return [fieldName, optValue];
-                default:
-                    return (0, utils_1.assertNever)(field);
-            }
-        }
-        if (field.kind === "primitive" &&
-            (required || opts[fieldName] === defaultValueMarker) &&
-            !field.derived &&
-            !field.protected) {
-            return [fieldName, defaultValueForField(em, cstr, field)];
-        }
-        else if (field.kind === "m2o" && !field.derived) {
-            // If neither the user nor the factory (i.e. for an explicit "fan out" case) set this field,
-            // then look in `use` and for an "obvious" there-is-only-one default (even for optional fields)
-            const [existing, loggerKey] = getObviousDefault(em, field.otherMetadata(), use);
-            // If this is a m2o pointing to an o2o, i.e. that as a unique constraint, make sure the
-            // existing entity we found isn't already claimed
-            const isUniqueAndAlreadyUsed = existing &&
-                (0, EntityMetadata_1.isOneToOneField)(field.otherMetadata().allFields[field.otherFieldName]) &&
-                existing[field.otherFieldName].isLoaded &&
-                existing[field.otherFieldName].isSet;
-            if (existing && !isUniqueAndAlreadyUsed && !ignoreAllDefaults) {
-                logger?.[loggerKey](fieldName, existing);
-                return [fieldName, existing];
-            }
-            // Otherwise, only make a new entity only if the field is required
-            if (required) {
-                // ...unless this is a self-referential key, in which case avoid infinite looping.
-                if (field.otherMetadata() === meta) {
-                    selfFields.push(fieldName);
-                    return [];
-                }
-                else {
-                    return [fieldName, resolveFactoryOpt(em, opts, field, undefined, undefined, undefined)];
-                }
-            }
-        }
-        else if (field.kind === "enum" && required && !field.derived) {
-            return [fieldName, field.enumDetailType.getValues()[0]];
-        }
-        else if (field.kind === "poly" && required) {
-            return [fieldName, resolveFactoryOpt(em, opts, field, undefined, undefined, undefined)];
-        }
-        return [];
-    })
-        .filter((t) => t.length > 0);
-    const createOpts = Object.fromEntries(initialOpts);
-    if (factoryOpts.useExisting && testOpts.useExistingCheck !== false) {
-        const existing = em.entities
-            .filter((e) => e instanceof meta.cstr)
-            .find((e) => factoryOpts.useExisting(createOpts, e));
-        if (existing) {
-            logger?.logFoundExisting(existing);
-            logger?.dedent();
-            if (ownsTheLogger)
-                logger = undefined;
-            return existing;
-        }
-    }
-    const entity = em.create(cstr, createOpts);
-    // Verify the `as` assertion if provided
-    if (opts.is) {
-        const expected = opts.is;
-        const actual = getTestId(em, entity);
-        if (actual !== expected) {
-            throw new Error(`Test used 'is: ${expected}' but the entity is actually ${actual}`);
-        }
-    }
-    // Report this as factory-created until the next em.flush
-    factoryCreated.add(entity);
-    // If the type we just made doesn't exist in `use` yet, remember it. This works better than
-    // looking at the values in `fullOpts`, because instead of waiting until the end of the
-    // `build fullOpts` loop, we're also invoking `newTestInstance` as we go through the loop itself,
-    // creating each test instance within nested/recursive `newTestInstance` calls.
-    if (!use.has(entity.constructor) || use.get(entity.constructor)[1] === "diffBranch") {
-        addToUseMap(use, entity, "sameBranch");
-    }
-    else {
-        // The `addToUseMap` does its own 'created & added to scope'
-        logger?.logCreated(entity);
-    }
-    // Now that we've got the entity, do a 2nd pass for o2m/m2m where we pass
-    // `{ parent: entity }` down to children (i.e. to replace our original
-    // null marker approach).
-    const additionalOpts = Object.entries(opts).map(([fieldName, optValue]) => {
-        const field = meta.allFields[fieldName];
-        // Look for `use` / etc
-        if (knownUseKeys.includes(fieldName))
-            return [];
-        if (!field) {
-            // Look for extra/derived fields
-            if (fieldName.startsWith("with")) {
-                const realName = fieldName[4].toLowerCase() + fieldName.substring(5);
-                const realField = meta.allFields[realName];
-                if (realField && "derived" in realField && realField.derived === "async") {
-                    return [realName, new FactoryInitialValue(optValue)];
-                }
-            }
-            throw new Error(`Unknown field ${fieldName}`);
-        }
-        if (optValue === null || optValue === undefined)
-            return [];
-        if (field.kind === "o2m") {
-            // If this is a list of children, i.e. book.authors, handle partials to newTestInstance'd
-            return [
-                fieldName,
-                optValue.map((opt, i) => {
-                    // console.log(`${field.fieldName}`, i);
-                    return resolveFactoryOpt(em, withBranchMap(opts), field, opt, entity, i);
-                }),
-            ];
-        }
-        else if (field.kind == "m2m") {
-            return [
-                fieldName,
-                optValue.map((opt, i) => resolveFactoryOpt(em, withBranchMap(opts), field, opt, [entity], i)),
-            ];
-        }
-        else if (field.kind === "o2o") {
-            const otherField = field.otherMetadata().allFields[field.otherFieldName];
-            const isReactiveReference = "derived" in otherField && otherField.derived === "async";
-            if (isReactiveReference)
-                return [];
-            // If this is an o2o, i.e. author.image, just pass the optValue (i.e. it won't be a list)
-            return [fieldName, resolveFactoryOpt(em, opts, field, optValue, entity, undefined)];
-        }
-        else {
-            return []; // Assume createOpts handled this
-        }
-    });
-    for (const fieldName of selfFields) {
-        additionalOpts.push([fieldName, entity]);
-    }
-    entity.set(Object.fromEntries(additionalOpts.filter((t) => t.length > 0)));
-    // em.create applied synchronous defaults automatically; since we're a factory with likely
-    // deeply-loaded instances, go ahead and synchronously invoke the async defaults, at least
-    // the ones that just use load hints + a synchronous lambda.
-    // (...would be nice to log these in the setFactoryLogging output)
-    (0, defaults_1.setAsyncDefaultsSynchronously)(em.ctx, entity);
-    // Set it back to undefined
-    logger?.dedent();
-    if (ownsTheLogger)
-        logger = undefined;
-    return entity;
+* Creates a test instance of `T`.
+*
+* If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
+* to try and resolve "already created" / singleton instances. The `useExisting` callback is
+* useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
+* literal, maybe object instance" opts that tests pass into the factory.
+*/
+function newTestInstance(em, cstr, testOpts = {}, factoryOpts = {}) {
+	lastFactoryEm = em;
+	let ownsTheLogger = !logger && testOpts.useLogging;
+	if (ownsTheLogger) logger = new FactoryLogger();
+	logger?.logCreating(cstr);
+	logger?.indent();
+	const meta = getMetadata(cstr);
+	const opts = mergeOpts(meta, testOpts, factoryOpts);
+	const use = getOrCreateUseMap(opts);
+	const selfFields = [];
+	const initialOpts = Object.values(meta.allFields).map((field) => {
+		const { fieldName } = field;
+		const ignoreAllDefaults = "useFactoryDefaults" in opts && opts.useFactoryDefaults === "none";
+		const required = field.required && !ignoreAllDefaults && !hasDefaultValue(meta, fieldName);
+		if (fieldName in opts && opts[fieldName] !== defaultValueMarker) {
+			const optValue = opts[fieldName];
+			if (optValue === null || optValue === void 0 && !required) return [];
+			switch (field.kind) {
+				case "m2o":
+				case "poly": return [fieldName, resolveFactoryOpt(em, opts, field, optValue, void 0, void 0)];
+				case "o2o":
+				case "o2m":
+				case "m2m": return [];
+				case "m2mEnum": return [fieldName, optValue];
+				case "lo2m": return [];
+				case "primitive":
+				case "enum":
+				case "primaryKey":
+					if (typeof optValue === "string" && optValue.includes(testIndexString)) {
+						const actualIndex = getTestIndex(em, meta.cstr);
+						return [fieldName, optValue.replace(testIndexString, String(actualIndex))];
+					} else if (typeof optValue === "number" && optValue === -1111111222) return [fieldName, getTestIndex(em, meta.cstr)];
+					return [fieldName, optValue];
+				default: return assertNever(field);
+			}
+		}
+		if (field.kind === "primitive" && (required || opts[fieldName] === defaultValueMarker) && !field.derived && !field.protected) return [fieldName, defaultValueForField(em, cstr, field)];
+		else if (field.kind === "m2o" && !field.derived) {
+			const [existing, loggerKey] = getObviousDefault(em, field.otherMetadata(), use);
+			const isUniqueAndAlreadyUsed = existing && isOneToOneField(field.otherMetadata().allFields[field.otherFieldName]) && existing[field.otherFieldName].isLoaded && existing[field.otherFieldName].isSet;
+			if (existing && !isUniqueAndAlreadyUsed && !ignoreAllDefaults) {
+				logger?.[loggerKey](fieldName, existing);
+				return [fieldName, existing];
+			}
+			if (required) {
+				if (field.otherMetadata() === meta) {
+					selfFields.push(fieldName);
+					return [];
+				} else return [fieldName, resolveFactoryOpt(em, opts, field, void 0, void 0, void 0)];
+			}
+		} else if (field.kind === "enum" && required && !field.derived) return [fieldName, field.enumDetailType.getValues()[0]];
+		else if (field.kind === "poly" && required) return [fieldName, resolveFactoryOpt(em, opts, field, void 0, void 0, void 0)];
+		return [];
+	}).filter((t) => t.length > 0);
+	const createOpts = Object.fromEntries(initialOpts);
+	if (factoryOpts.useExisting && testOpts.useExistingCheck !== false) {
+		const existing = em.entities.filter((e) => e instanceof meta.cstr).find((e) => factoryOpts.useExisting(createOpts, e));
+		if (existing) {
+			logger?.logFoundExisting(existing);
+			logger?.dedent();
+			if (ownsTheLogger) logger = void 0;
+			return existing;
+		}
+	}
+	const entity = em.create(cstr, createOpts);
+	if (opts.is) {
+		const expected = opts.is;
+		const actual = getTestId(em, entity);
+		if (actual !== expected) throw new Error(`Test used 'is: ${expected}' but the entity is actually ${actual}`);
+	}
+	factoryCreated.add(entity);
+	if (!use.has(entity.constructor) || use.get(entity.constructor)[1] === "diffBranch") addToUseMap(use, entity, "sameBranch");
+	else logger?.logCreated(entity);
+	const additionalOpts = Object.entries(opts).map(([fieldName, optValue]) => {
+		const field = meta.allFields[fieldName];
+		if (knownUseKeys.includes(fieldName)) return [];
+		if (!field) {
+			if (fieldName.startsWith("with")) {
+				const realName = fieldName[4].toLowerCase() + fieldName.substring(5);
+				const realField = meta.allFields[realName];
+				if (realField && "derived" in realField && realField.derived === "async") return [realName, new FactoryInitialValue(optValue)];
+			}
+			throw new Error(`Unknown field ${fieldName}`);
+		}
+		if (optValue === null || optValue === void 0) return [];
+		if (field.kind === "o2m") return [fieldName, optValue.map((opt, i) => {
+			return resolveFactoryOpt(em, withBranchMap(opts), field, opt, entity, i);
+		})];
+		else if (field.kind == "m2m") return [fieldName, optValue.map((opt, i) => resolveFactoryOpt(em, withBranchMap(opts), field, opt, [entity], i))];
+		else if (field.kind === "o2o") {
+			const otherField = field.otherMetadata().allFields[field.otherFieldName];
+			if ("derived" in otherField && otherField.derived === "async") return [];
+			return [fieldName, resolveFactoryOpt(em, opts, field, optValue, entity, void 0)];
+		} else return [];
+	});
+	for (const fieldName of selfFields) additionalOpts.push([fieldName, entity]);
+	entity.set(Object.fromEntries(additionalOpts.filter((t) => t.length > 0)));
+	setAsyncDefaultsSynchronously(em.ctx, entity);
+	logger?.dedent();
+	if (ownsTheLogger) logger = void 0;
+	return entity;
 }
 /**
- * Resolves a `FactoryEntityOpt` (i.e. maybe an existing entity, maybe an id, maybe a hash of opts) to an entity.
- *
- * If `opt` is `undefined`, then the usual factory semantics of "check use", "look for only one instance" are
- * checked before finally creating a brand new entity.
- *
- * We also accept an optional `otherFieldName` so that, if we do create a new entity, we pass along the null
- * marker for them to know not to create their own version of us.
- *
- * (This was originally intended to be a public API, but the use case ended up being handled
- * by the more-ergonomic `maybeNew` feature; we could explore making this public if another
- * similar use case comes up in the future.)
- */
+* Resolves a `FactoryEntityOpt` (i.e. maybe an existing entity, maybe an id, maybe a hash of opts) to an entity.
+*
+* If `opt` is `undefined`, then the usual factory semantics of "check use", "look for only one instance" are
+* checked before finally creating a brand new entity.
+*
+* We also accept an optional `otherFieldName` so that, if we do create a new entity, we pass along the null
+* marker for them to know not to create their own version of us.
+*
+* (This was originally intended to be a public API, but the use case ended up being handled
+* by the more-ergonomic `maybeNew` feature; we could explore making this public if another
+* similar use case comes up in the future.)
+*/
 function resolveFactoryOpt(em, opts, field, opt, maybeEntity, fieldIndex) {
-    const use = getOrCreateUseMap(opts);
-    const { meta, otherFieldName } = metaFromFieldAndOpt(field, opt);
-    // const meta = field.kind === "poly" ? field.components[0].otherMetadata() : field.otherMetadata();
-    // const otherFieldName = field.kind === "poly" ? field.components[0].otherFieldName : field.otherFieldName;
-    const fieldWithIndex = `${field.fieldName}${fieldIndex !== undefined ? `[${fieldIndex}]` : ""}`;
-    if ((0, Entity_1.isEntity)(opt)) {
-        logger?.logFoundOpt(fieldWithIndex, opt);
-        return opt;
-    }
-    else if ((0, EntityManager_1.isId)(opt)) {
-        // Try finding the entity in the UoW, otherwise fallback on just setting it as the id (which we support that now)
-        const found = em.entities.find((e) => e.idTaggedMaybe === opt || getTestId(em, e) === opt) || opt;
-        logger?.logFoundOpt(fieldWithIndex, found);
-        return found;
-    }
-    else if (opt && !(0, joist_utils_1.isPlainObject)(opt) && !(opt instanceof MaybeNew)) {
-        // If opt isn't a POJO, assume this is a completely-custom factory
-        logger?.logNotFoundAndCreating(fieldWithIndex, meta);
-        return meta.factory(em, opt);
-    }
-    else {
-        // Look for an obvious default
-        if (opt === undefined || opt instanceof MaybeNew) {
-            if (field.kind === "poly" ||
-                (field.otherMetadata().subTypes.length > 0 && opt instanceof MaybeNew && opt.polyRefPreferredOrder.length > 0)) {
-                // We have a polymorphic maybeNew to sort through
-                const [existing, loggerKey] = (opt instanceof MaybeNew
-                    ? opt.polyRefPreferredOrder.map((cstr) => (0, EntityMetadata_1.getMetadata)(cstr))
-                    : field.kind === "poly"
-                        ? field.components.map((c) => c.otherMetadata())
-                        : [meta])
-                    .map((meta) => getObviousDefault(em, meta, use))
-                    .find((existing) => !!existing[0]) || [undefined, undefined];
-                if (existing) {
-                    logger?.[loggerKey](fieldWithIndex, existing);
-                    return existing;
-                }
-            }
-            else {
-                // Otherwise fall though to making a new entity via the factory
-                const [existing, loggerKey] = getObviousDefault(em, meta, use);
-                if (existing) {
-                    logger?.[loggerKey](fieldWithIndex, existing);
-                    return existing;
-                }
-            }
-        }
-        // If this is image.author (m2o) but the other-side is an o2o, pass null instead of []
-        maybeEntity ??= (meta.allFields[otherFieldName].kind === "o2o" ? null : []);
-        logger?.logNotFoundAndCreating(fieldWithIndex, meta);
-        return meta.factory(em, {
-            // Because of the `!isPlainObject` above, opt will either be undefined or an object here
-            ...applyUse(opt || {}, use, meta),
-            ...(opt instanceof MaybeNew && opt.opts),
-            [otherFieldName]: maybeEntity,
-        });
-    }
+	const use = getOrCreateUseMap(opts);
+	const { meta, otherFieldName } = metaFromFieldAndOpt(field, opt);
+	const fieldWithIndex = `${field.fieldName}${fieldIndex !== void 0 ? `[${fieldIndex}]` : ""}`;
+	if (isEntity(opt)) {
+		logger?.logFoundOpt(fieldWithIndex, opt);
+		return opt;
+	} else if (isId(opt)) {
+		const found = em.entities.find((e) => e.idTaggedMaybe === opt || getTestId(em, e) === opt) || opt;
+		logger?.logFoundOpt(fieldWithIndex, found);
+		return found;
+	} else if (opt && !isPlainObject(opt) && !(opt instanceof MaybeNew)) {
+		logger?.logNotFoundAndCreating(fieldWithIndex, meta);
+		return meta.factory(em, opt);
+	} else {
+		if (opt === void 0 || opt instanceof MaybeNew) {
+			if (field.kind === "poly" || field.otherMetadata().subTypes.length > 0 && opt instanceof MaybeNew && opt.polyRefPreferredOrder.length > 0) {
+				const [existing, loggerKey] = (opt instanceof MaybeNew ? opt.polyRefPreferredOrder.map((cstr) => getMetadata(cstr)) : field.kind === "poly" ? field.components.map((c) => c.otherMetadata()) : [meta]).map((meta) => getObviousDefault(em, meta, use)).find((existing) => !!existing[0]) || [void 0, void 0];
+				if (existing) {
+					logger?.[loggerKey](fieldWithIndex, existing);
+					return existing;
+				}
+			} else {
+				const [existing, loggerKey] = getObviousDefault(em, meta, use);
+				if (existing) {
+					logger?.[loggerKey](fieldWithIndex, existing);
+					return existing;
+				}
+			}
+		}
+		maybeEntity ??= meta.allFields[otherFieldName].kind === "o2o" ? null : [];
+		logger?.logNotFoundAndCreating(fieldWithIndex, meta);
+		return meta.factory(em, {
+			...applyUse(opt || {}, use, meta),
+			...opt instanceof MaybeNew && opt.opts,
+			[otherFieldName]: maybeEntity
+		});
+	}
 }
 /** Determines the metadata and otherFieldName to use in resolveFactoryOpt to account for polymorphic fields */
 function metaFromFieldAndOpt(field, opt) {
-    if (field.kind === "poly") {
-        let componentToUse = 
-        // Otherwise, we check if the `opt` specifies a particular component to use, and if not fall back to the first one
-        field.components.find((component) => opt instanceof MaybeNew &&
-            (0, EntityMetadata_1.getBaseSelfAndSubMetas)(component.otherMetadata())
-                .map((m) => m.cstr)
-                .includes(opt.polyRefPreferredOrder[0])) ?? field.components[0];
-        return { meta: componentToUse.otherMetadata(), otherFieldName: componentToUse.otherFieldName };
-    }
-    else if (field.otherMetadata().subTypes.length > 0 &&
-        opt instanceof MaybeNew &&
-        opt.polyRefPreferredOrder.length > 0) {
-        const otherMeta = field.otherMetadata();
-        const types = (0, EntityMetadata_1.getBaseSelfAndSubMetas)(otherMeta);
-        const typeToUse = types.find((subType) => subType.cstr === opt.polyRefPreferredOrder[0]) ?? otherMeta;
-        return { meta: typeToUse, otherFieldName: field.otherFieldName };
-    }
-    else {
-        // If it isn't a poly field, then the field itself can tell us everything we need to know
-        return { meta: field.otherMetadata(), otherFieldName: field.otherFieldName };
-    }
+	if (field.kind === "poly") {
+		let componentToUse = field.components.find((component) => opt instanceof MaybeNew && getBaseSelfAndSubMetas(component.otherMetadata()).map((m) => m.cstr).includes(opt.polyRefPreferredOrder[0])) ?? field.components[0];
+		return {
+			meta: componentToUse.otherMetadata(),
+			otherFieldName: componentToUse.otherFieldName
+		};
+	} else if (field.otherMetadata().subTypes.length > 0 && opt instanceof MaybeNew && opt.polyRefPreferredOrder.length > 0) {
+		const otherMeta = field.otherMetadata();
+		return {
+			meta: getBaseSelfAndSubMetas(otherMeta).find((subType) => subType.cstr === opt.polyRefPreferredOrder[0]) ?? otherMeta,
+			otherFieldName: field.otherFieldName
+		};
+	} else return {
+		meta: field.otherMetadata(),
+		otherFieldName: field.otherFieldName
+	};
 }
 /** We look for `use`-cached entities, which are either those we created, or had "if-only-one" defaults. */
 function getObviousDefault(em, metadata, use) {
-    if (use.has(metadata.cstr)) {
-        return [use.get(metadata.cstr)[0], "logFoundInUseMap"];
-    }
-    // If there is a single existing instance of this type, assume the caller is fine with that.
-    // ...in theory seeding our `use` map with the only-one entities was supposed to prevent the
-    // need for doing this (the entities would already be in the use map that we just checked),
-    // but that approach doesn't catch created-as-side-effect entities.
-    const existing = em.getEntities(metadata.cstr);
-    if (existing.length === 1) {
-        return [existing[0], "logFoundSingleEntity"];
-    }
-    return [undefined, undefined];
+	if (use.has(metadata.cstr)) return [use.get(metadata.cstr)[0], "logFoundInUseMap"];
+	const existing = em.getEntities(metadata.cstr);
+	if (existing.length === 1) return [existing[0], "logFoundSingleEntity"];
+	return [void 0, void 0];
 }
-// When a factory is called, i.e. `newAuthor`, opts will:
-//
-// - Have values explicitly passed by the user/other factories
-// - Have values from the user's explicit `use` parameter
-// - NOT have guessed (i.e. "only existing entity") or an implicitly-created `use` parameter
-//
-// This allows the factory to "fan out" by default, i.e. newInternalUser creating its own User
-// and Market creating its own ProductAttribute, which originally we couldn't do when
-// guessed/implicit opts were passed directly to `newAuthor`.
-//
-// Now, if the `newAuthor` factory doesn't explicitly "fan out" (by passing `user: {}` to
-// `newTestInstance`), we still "fan in" by having `newTestInstance` sneak in the guessed/implicit
-// opts of only-one-existing or factory-created instances.
 /** Given we're going to call a factory, make sure any `use`s are put into `opts`. */
 function applyUse(optsMaybeNew, use, metadata) {
-    const opts = optsMaybeNew instanceof MaybeNew ? optsMaybeNew.opts : optsMaybeNew;
-    // Find any unset fields
-    Object.values(metadata.fields)
-        .filter((f) => !(f.fieldName in opts))
-        .forEach((f) => {
-        // And set them to the current `use` entity for their type, if it exists
-        if ((((0, EntityMetadata_1.isManyToOneField)(f) && !f.derived) || (0, EntityMetadata_1.isOneToOneField)(f)) && use.has(f.otherMetadata().cstr)) {
-            const def = use.get(f.otherMetadata().cstr);
-            // Only pass explicit/user-defined `use` entities, so that factories can "fan out" if they want,
-            // and not see other factory-created entities look like user-specific values.
-            if (def[1] === "useOpt") {
-                opts[f.fieldName] = def[0];
-            }
-        }
-    });
-    // Make a copy so that we don't leak `use` onto opts that tests might later use in assertions.
-    return { ...opts, use };
+	const opts = optsMaybeNew instanceof MaybeNew ? optsMaybeNew.opts : optsMaybeNew;
+	Object.values(metadata.fields).filter((f) => !(f.fieldName in opts)).forEach((f) => {
+		if ((isManyToOneField(f) && !f.derived || isOneToOneField(f)) && use.has(f.otherMetadata().cstr)) {
+			const def = use.get(f.otherMetadata().cstr);
+			if (def[1] === "useOpt") opts[f.fieldName] = def[0];
+		}
+	});
+	return {
+		...opts,
+		use
+	};
 }
 /**
- * A marker value for later replacement with the test instance's "unique-ish" index.
- *
- * This is meant to just be a helpful identifier in fields like entity names/descriptions for
- * debugging purposes.
- */
-exports.testIndex = -1_111_111_222;
-const testIndexString = String(exports.testIndex);
+* A marker value for later replacement with the test instance's "unique-ish" index.
+*
+* This is meant to just be a helpful identifier in fields like entity names/descriptions for
+* debugging purposes.
+*/
+const testIndex = -1111111222;
+const testIndexString = String(testIndex);
 const defaultValueMarker = {};
 const branchValueSym = Symbol("branchValue");
 /**
- * A marker value for the default `newTestInstance` behavior.
- *
- * Useful for passing arguments to `newTestInstance` where you sometimes want to
- * provide a specific value, and other times ask for the "pick a default" behavior
- * (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
- * key unset").
- *
- * Note that this is a function so that we can infer the return type as basically
- * `any` without really using `any` (which would disable type-checking in the rest
- * of the expression).
- */
+* A marker value for the default `newTestInstance` behavior.
+*
+* Useful for passing arguments to `newTestInstance` where you sometimes want to
+* provide a specific value, and other times ask for the "pick a default" behavior
+* (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
+* key unset").
+*
+* Note that this is a function so that we can infer the return type as basically
+* `any` without really using `any` (which would disable type-checking in the rest
+* of the expression).
+*/
 function defaultValue() {
-    return defaultValueMarker;
+	return defaultValueMarker;
 }
 /**
- * A marker value to never set a field, even if it's required.
- *
- * The factories treat `{ author: undefined }` as "still set the author", because of how easy
- * it is for destructuring/restructuring opts to implicitly set `undefined` values.
- *
- * If you want to force a field to not be set, you can use `{ author: noValue() }`.
- */
+* A marker value to never set a field, even if it's required.
+*
+* The factories treat `{ author: undefined }` as "still set the author", because of how easy
+* it is for destructuring/restructuring opts to implicitly set `undefined` values.
+*
+* If you want to force a field to not be set, you can use `{ author: noValue() }`.
+*/
 function noValue() {
-    return null;
+	return null;
 }
 /**
- * A marker value to accept values only if explicitly created-or-passed within the current,
- * unique "branch" of a factory call.
- *
- * This is useful for "diamond-shape" entity models like:
- *
- * ```
- *  ParentGroup <-- ParentItem
- *      |              |
- *   ChildGroup  <-- ChildItem
- * ```
- *
- * Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
- * the `ChildItem -> ChildGroup -> ParentGroup` path.
- *
- * This can be hard to achieve in normal factory behavior, i.e. for a call like:
- *
- * ```ts
- * const c = newChild(em, {
- *   groups: [
- *     { childItems: [{}, {}] },
- *     { childItems: [{}, {}] },
- *   ],
- * });
- * ```
- *
- * The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
- * is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
- * `ParentGroup`.
- *
- * An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
- * existing instances", but for this problem the `{}` approach is "too good" at creating new
- * instances, b/c the above diamond pattern will be disconnected.
- *
- * So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
- * it was explicitly created within the same "branch" of a factory call.
- */
+* A marker value to accept values only if explicitly created-or-passed within the current,
+* unique "branch" of a factory call.
+*
+* This is useful for "diamond-shape" entity models like:
+*
+* ```
+*  ParentGroup <-- ParentItem
+*      |              |
+*   ChildGroup  <-- ChildItem
+* ```
+*
+* Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
+* the `ChildItem -> ChildGroup -> ParentGroup` path.
+*
+* This can be hard to achieve in normal factory behavior, i.e. for a call like:
+*
+* ```ts
+* const c = newChild(em, {
+*   groups: [
+*     { childItems: [{}, {}] },
+*     { childItems: [{}, {}] },
+*   ],
+* });
+* ```
+*
+* The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
+* is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
+* `ParentGroup`.
+*
+* An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
+* existing instances", but for this problem the `{}` approach is "too good" at creating new
+* instances, b/c the above diamond pattern will be disconnected.
+*
+* So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
+* it was explicitly created within the same "branch" of a factory call.
+*/
 function maybeBranchValue(opts) {
-    // opts get mutated, so we have to return a new value
-    return { [branchValueSym]: true, ...(opts ? opts : undefined) };
+	return {
+		[branchValueSym]: true,
+		...opts ? opts : void 0
+	};
 }
 /**
- * Allows a factory to declare that an optional relation should be filled in with an
- * "obvious default", or a new entity if one doesn't exist.
- *
- * This "obvious default or new entity" is what Joist already does for _required_ relations,
- * and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
- * field.
- *
- * I.e.:
- *
- * ```typescript
- * export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
- *   return newTestInstance(em, Author, {
- *     // this always make a new publisher, unless explicitly overridden by the test,
- *     // i.e. when each author really needs "their own" publisher.
- *     publisher: {},
- *     // this will make a new publisher but first looks for "good defaults" in the
- *     // test, i.e. an already-created publisher. This is the default behavior of
- *     // required fields ("look for a good default"), and `maybeNew` lets you tell
- *     // Joist to invoke that same "maybe new" behavior for an optional field.
- *     publisher: maybeNew<Publisher>({}),
- *     ...opts,
- *   });
- * }
- * ```
- */
+* Allows a factory to declare that an optional relation should be filled in with an
+* "obvious default", or a new entity if one doesn't exist.
+*
+* This "obvious default or new entity" is what Joist already does for _required_ relations,
+* and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
+* field.
+*
+* I.e.:
+*
+* ```typescript
+* export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
+*   return newTestInstance(em, Author, {
+*     // this always make a new publisher, unless explicitly overridden by the test,
+*     // i.e. when each author really needs "their own" publisher.
+*     publisher: {},
+*     // this will make a new publisher but first looks for "good defaults" in the
+*     // test, i.e. an already-created publisher. This is the default behavior of
+*     // required fields ("look for a good default"), and `maybeNew` lets you tell
+*     // Joist to invoke that same "maybe new" behavior for an optional field.
+*     publisher: maybeNew<Publisher>({}),
+*     ...opts,
+*   });
+* }
+* ```
+*/
 function maybeNew(opts) {
-    // Return a marker that resolveFactoryOpt will look for
-    return new MaybeNew((opts || {}));
+	return new MaybeNew(opts || {});
 }
 /**
- * Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
- * 1) Allows you to specify which entity type to create, if it is found a new one is needed
- * 2) Allows you to prioritize which existing entities to select
- *
- * For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
- * in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
- * Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
- *
- * ```typescript
- * export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
- *   return newTestInstance(em, Comment, {
- *     parent: maybeNewPoly<CommentParent, Author>(
- *       Author, {
- *         ifNewOpts: { firstName: "optional"},
- *         existingSearchOrder: [Author, Book, Publisher]
- *       }),
- *     ...opts,
- *   });
- * }
- * ```
- */
+* Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
+* 1) Allows you to specify which entity type to create, if it is found a new one is needed
+* 2) Allows you to prioritize which existing entities to select
+*
+* For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
+* in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
+* Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
+*
+* ```typescript
+* export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
+*   return newTestInstance(em, Comment, {
+*     parent: maybeNewPoly<CommentParent, Author>(
+*       Author, {
+*         ifNewOpts: { firstName: "optional"},
+*         existingSearchOrder: [Author, Book, Publisher]
+*       }),
+*     ...opts,
+*   });
+* }
+* ```
+*/
 function maybeNewPoly(ifNewCstr, opts) {
-    // Return a marker that resolveFactoryOpt will look for
-    return new MaybeNew((opts?.ifNewOpts || {}), opts?.existingSearchOrder ?? [ifNewCstr]);
-}
-class MaybeNew {
-    opts;
-    polyRefPreferredOrder;
-    constructor(opts, polyRefPreferredOrder = []) {
-        this.opts = opts;
-        this.polyRefPreferredOrder = polyRefPreferredOrder;
-    }
+	return new MaybeNew(opts?.ifNewOpts || {}, opts?.existingSearchOrder ?? [ifNewCstr]);
 }
+var MaybeNew = class {
+	opts;
+	polyRefPreferredOrder;
+	constructor(opts, polyRefPreferredOrder = []) {
+		this.opts = opts;
+		this.polyRefPreferredOrder = polyRefPreferredOrder;
+	}
+};
 /**
- * Returns a unique-ish test index for putting in `name` fields.
- *
- * Note that `testIndex` is easier to just include in a string, because it doesn't require passing
- * the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
- * call this method.
- *
- * Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
- */
+* Returns a unique-ish test index for putting in `name` fields.
+*
+* Note that `testIndex` is easier to just include in a string, because it doesn't require passing
+* the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
+* call this method.
+*
+* Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
+*/
 function getTestIndex(em, type) {
-    const existing = em.getEntities(type);
-    return existing.length + 1;
+	return em.getEntities(type).length + 1;
 }
 /** Returns the stable `a#1` factory id for em.create-d entities, using the createId assigned at creation time. */
 function getTestId(em, entity) {
-    const meta = (0, EntityMetadata_1.getMetadata)(entity);
-    const createId = (0, BaseEntity_1.getInstanceData)(entity).createId;
-    return createId ? `${meta.tagName}#${createId}` : undefined;
+	const meta = getMetadata(entity);
+	const createId = getInstanceData(entity).createId;
+	return createId ? `${meta.tagName}#${createId}` : void 0;
 }
-// We keep a local copy of `global.Date`, in case a faking library
-// like @sinonjs/fake-timers is used and rewrites `global.Date` to
-// their own `ClockDate`, which would make our `===` check below fail.
 const globalDate = global.Date;
 function defaultValueForField(em, cstr, field) {
-    if (field.serde.columns[0].isArray)
-        return [];
-    if (field.type === "string") {
-        if (field.fieldName === "name") {
-            return `${cstr.name} ${getTestIndex(em, cstr)}`;
-        }
-        return field.fieldName;
-    }
-    else if (field.type === "number") {
-        return 0;
-    }
-    else if (field.type === "bigint") {
-        return 0n;
-    }
-    else if (field.type === globalDate) {
-        return exports.testDate;
-    }
-    else if (field.type === "boolean") {
-        return false;
-    }
-    else if (Temporal) {
-        if (field.type === Temporal.PlainDate) {
-            return exports.testPlainDate;
-        }
-        else if (field.type === Temporal.PlainDateTime) {
-            return exports.testPlainDateTime;
-        }
-        else if (field.type === Temporal.ZonedDateTime) {
-            return exports.testZonedDateTime;
-        }
-    }
-    return null;
+	if (field.serde.columns[0].isArray) return [];
+	if (field.type === "string") {
+		if (field.fieldName === "name") return `${cstr.name} ${getTestIndex(em, cstr)}`;
+		return field.fieldName;
+	} else if (field.type === "number") return 0;
+	else if (field.type === "bigint") return 0n;
+	else if (field.type === globalDate) return testDate;
+	else if (field.type === "boolean") return false;
+	else if (field.type === "Object") return {};
+	else if (Temporal) {
+		if (field.type === Temporal.PlainDate) return testPlainDate;
+		else if (field.type === Temporal.PlainDateTime) return testPlainDateTime;
+		else if (field.type === Temporal.ZonedDateTime) return testZonedDateTime;
+	}
+	return null;
 }
-// Do a one-time conversion of the user's `use` array into a map for internal use, which we'll
-// then re-use across all `newTestInstance` calls within a given `new<Entity>` call.
 function getOrCreateUseMap(opts) {
-    const use = opts.use;
-    let map;
-    if (use instanceof Map) {
-        // it's already a map
-        map = use;
-    }
-    else {
-        map = new Map();
-        if (use instanceof Array) {
-            // it's a top-level `newAuthor` with a user-passed `use: array`
-            use.forEach((e) => addToUseMap(map, e, "useOpt"));
-        }
-        else if (use) {
-            // it's a top-level `newAuthor` w/o a `use: entity` param
-            addToUseMap(map, use, "useOpt");
-        }
-        // Scan opts for entities to add to the map, i.e. if the user calls `newAuthor(em, { book: b1 })`,
-        // we'll use `b1` for any other books we might happen to create.
-        const todo = [opts];
-        while (todo.length > 0) {
-            const opts = todo.pop();
-            for (const opt of Object.values(opts || {})) {
-                if ((0, Entity_1.isEntity)(opt) && !map.has(opt.constructor)) {
-                    addToUseMap(map, opt, "testOpts");
-                }
-                else if (opt instanceof Array) {
-                    // Push the array as-is, because it will be `Object.value`-d on the next iteration
-                    todo.push(opt);
-                }
-                else if ((0, joist_utils_1.isPlainObject)(opt)) {
-                    todo.push(opt);
-                }
-            }
-        }
-    }
-    // Store our potentially-massaged map back into opts i.e. in case resolveFactoryOpt needs it.
-    // Use as any b/c UseMap is our internal impl detail and not public.
-    opts.use = map;
-    return map;
+	const use = opts.use;
+	let map;
+	if (use instanceof Map) map = use;
+	else {
+		map = /* @__PURE__ */ new Map();
+		if (use instanceof Array) use.forEach((e) => addToUseMap(map, e, "useOpt"));
+		else if (use) addToUseMap(map, use, "useOpt");
+		const todo = [opts];
+		while (todo.length > 0) {
+			const opts = todo.pop();
+			for (const opt of Object.values(opts || {})) if (isEntity(opt) && !map.has(opt.constructor)) addToUseMap(map, opt, "testOpts");
+			else if (opt instanceof Array) todo.push(opt);
+			else if (isPlainObject(opt)) todo.push(opt);
+		}
+	}
+	opts.use = map;
+	return map;
 }
-// If e is a subtype like SmallPublisher, register it for the base Publisher as well
 function addToUseMap(map, e, source) {
-    logger?.logAddToUseMap(e, source);
-    const meta = (0, EntityMetadata_1.getMetadata)(e);
-    if (meta.baseType || meta.subTypes.length) {
-        (0, EntityMetadata_1.getBaseAndSelfMetas)(meta).forEach((m) => {
-            // console.log(`Putting ${e.toString()} into ${objectId(map)} as ${source}`);
-            map.set(m.cstr, [e, source]);
-        });
-    }
-    else {
-        // console.log(`Putting ${e.toString()} into ${objectId(map)} as ${source}`);
-        map.set(meta.cstr, [e, source]);
-    }
+	logger?.logAddToUseMap(e, source);
+	const meta = getMetadata(e);
+	if (meta.baseType || meta.subTypes.length) getBaseAndSelfMetas(meta).forEach((m) => {
+		map.set(m.cstr, [e, source]);
+	});
+	else map.set(meta.cstr, [e, source]);
 }
 /** Merge the factory's opts and the test's opts so that `{ age: 40 }` and `{ firstName: "b1" }` get merged. */
 function mergeOpts(meta, testOpts, factoryOpts) {
-    // Merge the factory's opts and the test's opts so that `{ age: 40 }` and `{ firstName: "b1" }` get merged
-    if (testOpts.useFactoryDefaults === false || testOpts.useFactoryDefaults === "none") {
-        return testOpts;
-    }
-    const opts = { ...testOpts };
-    Object.entries(factoryOpts).forEach(([key, factoryValue]) => {
-        // Skip special opts
-        if (key === "useExisting")
-            return;
-        const testValue = testOpts[key];
-        if (testOpts[key] === undefined) {
-            // If the test doesn't define an opt, we have nothing to merge...unless
-            // they literally passed `foo: undefined`, in which case they win.
-            if (!(key in testOpts)) {
-                opts[key] = factoryValue;
-            }
-        }
-        else if ((0, joist_utils_1.isPlainObject)(factoryValue) && (0, joist_utils_1.isPlainObject)(testValue)) {
-            // Should this deep merge? Probably?
-            opts[key] = mergeOpts(meta, testValue, factoryValue);
-        }
-        else if (factoryValue instanceof MaybeNew && (0, joist_utils_1.isPlainObject)(testValue)) {
-            opts[key] = mergeOpts(meta, testValue, factoryValue.opts);
-        }
-        else if (factoryValue instanceof MaybeNew && testValue instanceof MaybeNew) {
-            opts[key] = new MaybeNew(mergeOpts(meta, testValue.opts, factoryValue.opts), testValue.polyRefPreferredOrder ?? factoryValue.polyRefPreferredOrder);
-        }
-        // This seemed like a good idea
-        if (opts[key]?.[branchValueSym]) {
-            const field = meta.allFields[key];
-            if (field.kind === "m2o") {
-                const use = testOpts.use;
-                const inTree = use?.get(field.otherMetadata().cstr);
-                if (inTree && (inTree[1] === "sameBranch" || inTree[1] === "testOpts")) {
-                    // console.log(`Putting ${field.fieldName} to`, inTree[0]);
-                    opts[key] = inTree[0];
-                }
-            }
-            else {
-                throw new Error(`branchValue is not implemented for ${field.kind}`);
-            }
-            delete opts[key]?.[branchValueSym];
-        }
-    });
-    return opts;
+	if (testOpts.useFactoryDefaults === false || testOpts.useFactoryDefaults === "none") return testOpts;
+	const opts = { ...testOpts };
+	Object.entries(factoryOpts).forEach(([key, factoryValue]) => {
+		if (key === "useExisting") return;
+		const testValue = testOpts[key];
+		if (testOpts[key] === void 0) {
+			if (!(key in testOpts)) opts[key] = factoryValue;
+		} else if (isPlainObject(factoryValue) && isPlainObject(testValue)) opts[key] = mergeOpts(meta, testValue, factoryValue);
+		else if (factoryValue instanceof MaybeNew && isPlainObject(testValue)) opts[key] = mergeOpts(meta, testValue, factoryValue.opts);
+		else if (factoryValue instanceof MaybeNew && testValue instanceof MaybeNew) opts[key] = new MaybeNew(mergeOpts(meta, testValue.opts, factoryValue.opts), testValue.polyRefPreferredOrder ?? factoryValue.polyRefPreferredOrder);
+		if (opts[key]?.[branchValueSym]) {
+			const field = meta.allFields[key];
+			if (field.kind === "m2o") {
+				const inTree = testOpts.use?.get(field.otherMetadata().cstr);
+				if (inTree && (inTree[1] === "sameBranch" || inTree[1] === "testOpts")) opts[key] = inTree[0];
+			} else throw new Error(`branchValue is not implemented for ${field.kind}`);
+			delete opts[key]?.[branchValueSym];
+		}
+	});
+	return opts;
 }
-// As we branch out to children, going down the tree, give each branch its own playground of entities
 function withBranchMap(opts) {
-    const oldMap = opts.use;
-    const newMap = new CopyMap(oldMap);
-    return { ...opts, use: newMap };
+	const oldMap = opts.use;
+	const newMap = new CopyMap(oldMap);
+	return {
+		...opts,
+		use: newMap
+	};
 }
 /** Writes new entities into our branch's map (this map), as well as the root we came from. */
-class CopyMap extends Map {
-    root;
-    constructor(root) {
-        super(root);
-        this.root = root;
-    }
-    set(k, v) {
-        // Purposefully downgrade this to source=diffBranch so that it will not be used by `branchValue()`
-        // calls that override `{}`, but can still be used to in-fan, i.e. if making multiple books by
-        // default they get the same author.
-        // ...also use `root?` because the `super(root)` will call `set` while copying the other map
-        // but our `this.root` has not been set yet; which is fine, we want to ignore those anyway.
-        this.root?.set(k, [v[0], "diffBranch"]);
-        return super.set(k, v);
-    }
-}
-// const objectId = (() => {
-//   let currentId = 0;
-//   const map = new WeakMap();
-//   return (object: object): number => {
-//     if (!map.has(object)) {
-//       map.set(object, ++currentId);
-//     }
-//     return map.get(object)!;
-//   };
-// })();
+var CopyMap = class extends Map {
+	root;
+	constructor(root) {
+		super(root);
+		this.root = root;
+	}
+	set(k, v) {
+		this.root?.set(k, [v[0], "diffBranch"]);
+		return super.set(k, v);
+	}
+};
 /** Enables factory logging for all factories. */
 function setFactoryLogging(enabled) {
-    logger = enabled ? new FactoryLogger_1.FactoryLogger() : undefined;
+	logger = enabled ? new FactoryLogger() : void 0;
 }
 /** Marker for tests setting derived values during test setup. */
-class FactoryInitialValue {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-}
-exports.FactoryInitialValue = FactoryInitialValue;
+var FactoryInitialValue = class {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+};
 function isFactoryCreation(entity) {
-    return factoryCreated.has(entity);
+	return factoryCreated.has(entity);
 }
 function resetFactoryCreated() {
-    factoryCreated = new WeakSet();
+	factoryCreated = /* @__PURE__ */ new WeakSet();
 }
+//#endregion
+export { FactoryInitialValue, defaultValue, factories, getTestIndex, isFactoryCreation, maybeBranchValue, maybeNew, maybeNewPoly, newTestInstance, noValue, resetFactoryCreated, setFactoryLogging, testDate, testIndex, testPlainDate, testPlainDateTime, testZonedDateTime };
+
 //# sourceMappingURL=newTestInstance.js.map