joist-core 2.4.0-next.37 → 2.4.0-next.39

package/build/reactivity/reactiveHints.d.cts

@@ -16,9 +16,9 @@ import { MaybeAbstractEntityConstructor } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/reactivity/reactiveHints.d.ts
 /** The keys in `T` that rules & hooks can react to. */
-type Reactable<T extends Entity> = FieldsOf<T> & Loadable<T> & Gettable<T> & SuffixedFieldsOf<T> & SuffixedLoadable<T> & SuffixedGettable<T>;
+export type Reactable<T extends Entity> = FieldsOf<T> & Loadable<T> & Gettable<T> & SuffixedFieldsOf<T> & SuffixedLoadable<T> & SuffixedGettable<T>;
 /** Finds `hasReactiveGetters` which are not "loadable" b/c they're always loaded. */
-type Gettable<T extends Entity> = { -readonly [K in keyof T as GettableValue<T[K]> extends never ? never : K]: GettableValue<T[K]>; };
+export type Gettable<T extends Entity> = { -readonly [K in keyof T as GettableValue<T[K]> extends never ? never : K]: GettableValue<T[K]>; };
 type GettableValue<V> = V extends ReactiveGetter<any, infer P> ? P : never;
 /** The fields of `T` suffixed with `:ro` or `_ro`. */
 type SuffixedFieldsOf<T extends Entity> = { [K in keyof FieldsOf<T> & string as `${K}${SuffixSeperator}ro`]: FieldsOf<T>[K]; };
@@ -31,10 +31,10 @@ type SuffixedGettable<T extends Entity> = { [K in keyof Gettable<T> & string as
  * fields to react against, while load hints contain only relations, collections, and async
  * properties to preload.
  */
-type ReactiveHint<T extends Entity> = (keyof Reactable<T> & string) | ReadonlyArray<keyof Reactable<T> & string> | NestedReactiveHint<T>;
-type NestedReactiveHint<T extends Entity> = { [K in keyof Reactable<T>]?: Reactable<T>[K] extends (infer U extends Entity) ? ReactiveHint<U> : {}; };
+export type ReactiveHint<T extends Entity> = (keyof Reactable<T> & string) | ReadonlyArray<keyof Reactable<T> & string> | NestedReactiveHint<T>;
+export type NestedReactiveHint<T extends Entity> = { [K in keyof Reactable<T>]?: Reactable<T>[K] extends (infer U extends Entity) ? ReactiveHint<U> : {}; };
 /** Given an entity `T` that is being reacted with hint `H`, mark only the `H` attributes visible & populated. */
-type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & keyof T]: T[K] extends OneToOneReference<any, infer U> ? LoadedOneToOneReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends PolymorphicReference<any, infer U, infer N> ? PolymorphicReference<T, U, N> & LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends Reference<any, infer U, infer N> ? LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends EnumCollection<any, infer E> ? LoadedEnumCollection<T, E> : T[K] extends Collection<any, infer U> ? LoadedCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends ReadOnlyCollection<any, infer U> ? LoadedReadOnlyCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends Property<any, infer V> ? LoadedProperty<any, V> : T[K]; } & {
+export type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & keyof T]: T[K] extends OneToOneReference<any, infer U> ? LoadedOneToOneReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends PolymorphicReference<any, infer U, infer N> ? PolymorphicReference<T, U, N> & LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends Reference<any, infer U, infer N> ? LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends EnumCollection<any, infer E> ? LoadedEnumCollection<T, E> : T[K] extends Collection<any, infer U> ? LoadedCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends ReadOnlyCollection<any, infer U> ? LoadedReadOnlyCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends Property<any, infer V> ? LoadedProperty<any, V> : T[K]; } & {
   /**
    * Gives reactive rules & fields a way to get the full entity if they really need it.
    *
@@ -47,7 +47,7 @@ type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & ke
   changes: Changes<T, keyof (FieldsOf<T> & RelationsOf<T>), keyof NormalizeHint<H>>;
 } & MaybeTransientFields<T>;
 /** Allow returning reacted entities from `hasReactiveReference`. */
-type MaybeReactedEntity<V> = V extends Entity ? {
+export type MaybeReactedEntity<V> = V extends Entity ? {
   fullNonReactiveAccess: V;
 } : V;
 /**
@@ -57,16 +57,16 @@ type MaybeReactedEntity<V> = V extends Entity ? {
  * broken out as a separate generic; `hasReactiveProperty` does not, and so this type conditionally
  * pulls `undefined` out first, and then defers to `MaybeReactedEntity`.
  */
-type MaybeReactedPropertyEntity<V> = V extends (infer V1 extends Entity) | undefined ? MaybeReactedEntity<V1> | undefined : MaybeReactedEntity<V>;
+export type MaybeReactedPropertyEntity<V> = V extends (infer V1 extends Entity) | undefined ? MaybeReactedEntity<V1> | undefined : MaybeReactedEntity<V>;
 /**
  * A reactive hint that only allows fields immediately on the entity, i.e. no nested hints.
  *
  * This is used by `ReactiveGetter`s to guarantee that their lambda functions will
  * always be `.get`-able and hence not need loading.
  */
-type ShallowReactiveHint<T extends Entity> = (keyof FieldsOf<T> & string) | ReadonlyArray<keyof FieldsOf<T> & string>;
+export type ShallowReactiveHint<T extends Entity> = (keyof FieldsOf<T> & string) | ReadonlyArray<keyof FieldsOf<T> & string>;
 /** If the domain model has transient fields, allow reactive behavior to see it, i.e. don't run validation rules for special operations. */
-type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
+export type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
   transientFields: T["transientFields"];
 } : {};
 /**
@@ -79,7 +79,7 @@ type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
  * @param reactForOtherSide the name of our FK column, if the previous collection needs to react to our FK changing
  * @param isFirst
  */
-declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEntityConstructor<T>, entityType: MaybeAbstractEntityConstructor<T>, hint: ReactiveHint<T>, reactForOtherSide?: string, reactForOtherSideIsReadOnly?: "field-read-only" | "hint-read-only" | false, isFirst?: boolean): ReactiveTarget[];
+export declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEntityConstructor<T>, entityType: MaybeAbstractEntityConstructor<T>, hint: ReactiveHint<T>, reactForOtherSide?: string, reactForOtherSideIsReadOnly?: "field-read-only" | "hint-read-only" | false, isFirst?: boolean): ReactiveTarget[];
 /**
  * Walks `reverseHint` for every entity in `entities`.
  *
@@ -114,11 +114,11 @@ declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEn
  * before the final flush changes it to `a3`. `setField` remembers both original and transient reference values
  * separately from `originalData`, and we walk them in addition to the current value.
  */
-declare function followReverseHint(reactionName: string, entities: Entity[], reverseHint: string[]): Promise<Entity[]>;
+export declare function followReverseHint(reactionName: string, entities: Entity[], reverseHint: string[]): Promise<Entity[]>;
 /** Converts a normalized reactive `hint` into a load hint. */
-declare function convertToLoadHint<T extends Entity>(meta: EntityMetadata, hint: ReactiveHint<T>, allowCustomKeys?: boolean): LoadHint<T>;
+export declare function convertToLoadHint<T extends Entity>(meta: EntityMetadata, hint: ReactiveHint<T>, allowCustomKeys?: boolean): LoadHint<T>;
 /** An entity that, when `fields` change, should trigger the reactive rule/field pointed to by `path`. */
-interface ReactiveTarget {
+export interface ReactiveTarget {
   kind: "read-only" | "update";
   /** The entity that contains a field our reactive rule/field accesses. */
   entity: MaybeAbstractEntityConstructor<any>;
@@ -133,11 +133,11 @@ interface ReactiveTarget {
  * a `SmallPublisher` entity should pass an `@Publisher` filter because it is
  * a Publisher via inheritance.
  */
-declare function isTypeOrSubType(entity: Entity, typeName: string): boolean;
-declare function isPolyHint(key: string): boolean;
-declare function splitPolyHintToKeyAndType(key: string): [string, string];
+export declare function isTypeOrSubType(entity: Entity, typeName: string): boolean;
+export declare function isPolyHint(key: string): boolean;
+export declare function splitPolyHintToKeyAndType(key: string): [string, string];
 /** If this hint is a poly like `author@Book`, return the type, otherwise return undefined. */
-declare function getRelationFromMaybePolyKey(entity: Entity, key: string): any;
+export declare function getRelationFromMaybePolyKey(entity: Entity, key: string): any;
 //#endregion
-export { Gettable, MaybeReactedEntity, MaybeReactedPropertyEntity, MaybeTransientFields, NestedReactiveHint, Reactable, Reacted, ReactiveHint, ReactiveTarget, ShallowReactiveHint, convertToLoadHint, followReverseHint, getRelationFromMaybePolyKey, isPolyHint, isTypeOrSubType, reverseReactiveHint, splitPolyHintToKeyAndType };
+export {};
 //# sourceMappingURL=reactiveHints.d.cts.map

package/build/reactivity/reactiveHints.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"reactiveHints.d.cts","names":[],"sources":["../../src/reactivity/reactiveHints.ts"],"mappings":";;;;;;;;;;;;;;;;;;KA8CY,UAAU,UAAU,UAE9B,SAAS,KAGP,SAAS,KACT,SAAS,KACT,iBAAiB,KACjB,iBAAiB,KACjB,iBAAiB;;KAGT,SAAS,UAAU,uBAClB,WAAW,KAAK,cAAc,EAAE,4BAA4B,IAAI,cAAc,EAAE;KAGxF,cAAc,KAAK,UAAU,0BAA0B,KAAK;;KAG5D,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;;;;;;;;KAUnE,aAAa,UAAU,iBACxB,UAAU,eACjB,oBAAoB,UAAU,eAC9B,mBAAmB;KAEX,mBAAmB,UAAU,aACtC,WAAW,UAAU,MAAM,UAAU,GAAG,kBAAiB,UAAU,UAAS,aAAa;;KAIhF,QAAQ,UAAU,QAAQ,KAAK,YACxC,WAAW,cAAc,WAAW,IAAI,EAAE,WAAW,6BAA6B,KAC/E,wBAAwB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OAGhE,EAAE,WAAW,gCAAgC,SAAS,KACpD,qBAAqB,GAAG,GAAG,KAAK,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7F,EAAE,WAAW,qBAAqB,SAAS,KACzC,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7D,EAAE,WAAW,0BAA0B,KACrC,qBAAqB,GAAG,KACxB,EAAE,WAAW,sBAAsB,KACjC,iBAAiB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACzD,EAAE,WAAW,8BAA8B,KACzC,yBAAyB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACjE,EAAE,WAAW,oBAAoB,KAC/B,oBAAoB,KACpB,EAAE;;;;;;;;EASlB,uBAAuB,OAAO,GAAG;;EAEjC,SAAS,QAAQ,UAAU,SAAS,KAAK,YAAY,WAAW,cAAc;IAC5E,qBAAqB;;KAGb,mBAAmB,KAAK,UAAU;EAAW,uBAAuB;IAAM;;;;;;;;KAS1E,2BAA2B,KAAK,iBAAiB,WAAW,sBACpE,mBAAmB,kBACnB,mBAAmB;;;;;;;KAQX,oBAAoB,UAAU,iBAC/B,SAAS,eAChB,oBAAoB,SAAS;;KAGrB,qBAAqB,qCAAqC;EAChE,iBAAiB;;;;;;;;;;;;iBAaP,oBAAoB,UAAU,QAC5C,UAAU,+BAA+B,IACzC,YAAY,+BAA+B,IAC3C,MAAM,aAAa,IACnB,4BACA,4EACA,oBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+SmB,kBACpB,sBACA,UAAU,UACV,wBACC,QAAQ;;iBAuEK,kBAAkB,UAAU,QAC1C,MAAM,gBACN,MAAM,aAAa,IACnB,4BACC,SAAS;;UA0EK;EACf;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;iBA+Bc,gBAAgB,QAAQ,QAAQ;iBAKhC,WAAW;iBAIX,0BAA0B;;iBAM1B,4BAA4B,QAAQ,QAAQ"}
+{"version":3,"file":"reactiveHints.d.cts","names":[],"sources":["../../src/reactivity/reactiveHints.ts"],"mappings":";;;;;;;;;;;;;;;;;;YA8CY,UAAU,UAAU,UAE9B,SAAS,KAGP,SAAS,KACT,SAAS,KACT,iBAAiB,KACjB,iBAAiB,KACjB,iBAAiB;;YAGT,SAAS,UAAU,uBAClB,WAAW,KAAK,cAAc,EAAE,4BAA4B,IAAI,cAAc,EAAE;KAGxF,cAAc,KAAK,UAAU,0BAA0B,KAAK;;KAG5D,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;;;;;;;;YAUnE,aAAa,UAAU,iBACxB,UAAU,eACjB,oBAAoB,UAAU,eAC9B,mBAAmB;YAEX,mBAAmB,UAAU,aACtC,WAAW,UAAU,MAAM,UAAU,GAAG,kBAAiB,UAAU,UAAS,aAAa;;YAIhF,QAAQ,UAAU,QAAQ,KAAK,YACxC,WAAW,cAAc,WAAW,IAAI,EAAE,WAAW,6BAA6B,KAC/E,wBAAwB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OAGhE,EAAE,WAAW,gCAAgC,SAAS,KACpD,qBAAqB,GAAG,GAAG,KAAK,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7F,EAAE,WAAW,qBAAqB,SAAS,KACzC,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7D,EAAE,WAAW,0BAA0B,KACrC,qBAAqB,GAAG,KACxB,EAAE,WAAW,sBAAsB,KACjC,iBAAiB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACzD,EAAE,WAAW,8BAA8B,KACzC,yBAAyB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACjE,EAAE,WAAW,oBAAoB,KAC/B,oBAAoB,KACpB,EAAE;;;;;;;;EASlB,uBAAuB,OAAO,GAAG;;EAEjC,SAAS,QAAQ,UAAU,SAAS,KAAK,YAAY,WAAW,cAAc;IAC5E,qBAAqB;;YAGb,mBAAmB,KAAK,UAAU;EAAW,uBAAuB;IAAM;;;;;;;;YAS1E,2BAA2B,KAAK,iBAAiB,WAAW,sBACpE,mBAAmB,kBACnB,mBAAmB;;;;;;;YAQX,oBAAoB,UAAU,iBAC/B,SAAS,eAChB,oBAAoB,SAAS;;YAGrB,qBAAqB,qCAAqC;EAChE,iBAAiB;;;;;;;;;;;;wBAaP,oBAAoB,UAAU,QAC5C,UAAU,+BAA+B,IACzC,YAAY,+BAA+B,IAC3C,MAAM,aAAa,IACnB,4BACA,4EACA,oBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+SmB,kBACpB,sBACA,UAAU,UACV,wBACC,QAAQ;;wBAuEK,kBAAkB,UAAU,QAC1C,MAAM,gBACN,MAAM,aAAa,IACnB,4BACC,SAAS;;iBA0EK;EACf;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;wBA+Bc,gBAAgB,QAAQ,QAAQ;wBAKhC,WAAW;wBAIX,0BAA0B;;wBAM1B,4BAA4B,QAAQ,QAAQ"}

package/build/reactivity/reactiveHints.d.mts

@@ -16,9 +16,9 @@ import { MaybeAbstractEntityConstructor } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/reactivity/reactiveHints.d.ts
 /** The keys in `T` that rules & hooks can react to. */
-type Reactable<T extends Entity> = FieldsOf<T> & Loadable<T> & Gettable<T> & SuffixedFieldsOf<T> & SuffixedLoadable<T> & SuffixedGettable<T>;
+export type Reactable<T extends Entity> = FieldsOf<T> & Loadable<T> & Gettable<T> & SuffixedFieldsOf<T> & SuffixedLoadable<T> & SuffixedGettable<T>;
 /** Finds `hasReactiveGetters` which are not "loadable" b/c they're always loaded. */
-type Gettable<T extends Entity> = { -readonly [K in keyof T as GettableValue<T[K]> extends never ? never : K]: GettableValue<T[K]>; };
+export type Gettable<T extends Entity> = { -readonly [K in keyof T as GettableValue<T[K]> extends never ? never : K]: GettableValue<T[K]>; };
 type GettableValue<V> = V extends ReactiveGetter<any, infer P> ? P : never;
 /** The fields of `T` suffixed with `:ro` or `_ro`. */
 type SuffixedFieldsOf<T extends Entity> = { [K in keyof FieldsOf<T> & string as `${K}${SuffixSeperator}ro`]: FieldsOf<T>[K]; };
@@ -31,10 +31,10 @@ type SuffixedGettable<T extends Entity> = { [K in keyof Gettable<T> & string as
  * fields to react against, while load hints contain only relations, collections, and async
  * properties to preload.
  */
-type ReactiveHint<T extends Entity> = (keyof Reactable<T> & string) | ReadonlyArray<keyof Reactable<T> & string> | NestedReactiveHint<T>;
-type NestedReactiveHint<T extends Entity> = { [K in keyof Reactable<T>]?: Reactable<T>[K] extends (infer U extends Entity) ? ReactiveHint<U> : {}; };
+export type ReactiveHint<T extends Entity> = (keyof Reactable<T> & string) | ReadonlyArray<keyof Reactable<T> & string> | NestedReactiveHint<T>;
+export type NestedReactiveHint<T extends Entity> = { [K in keyof Reactable<T>]?: Reactable<T>[K] extends (infer U extends Entity) ? ReactiveHint<U> : {}; };
 /** Given an entity `T` that is being reacted with hint `H`, mark only the `H` attributes visible & populated. */
-type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & keyof T]: T[K] extends OneToOneReference<any, infer U> ? LoadedOneToOneReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends PolymorphicReference<any, infer U, infer N> ? PolymorphicReference<T, U, N> & LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends Reference<any, infer U, infer N> ? LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends EnumCollection<any, infer E> ? LoadedEnumCollection<T, E> : T[K] extends Collection<any, infer U> ? LoadedCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends ReadOnlyCollection<any, infer U> ? LoadedReadOnlyCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends Property<any, infer V> ? LoadedProperty<any, V> : T[K]; } & {
+export type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & keyof T]: T[K] extends OneToOneReference<any, infer U> ? LoadedOneToOneReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends PolymorphicReference<any, infer U, infer N> ? PolymorphicReference<T, U, N> & LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends Reference<any, infer U, infer N> ? LoadedReference<T, Entity & Reacted<U, NormalizeHint<H>[K]>, N> : T[K] extends EnumCollection<any, infer E> ? LoadedEnumCollection<T, E> : T[K] extends Collection<any, infer U> ? LoadedCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends ReadOnlyCollection<any, infer U> ? LoadedReadOnlyCollection<T, Entity & Reacted<U, NormalizeHint<H>[K]>> : T[K] extends Property<any, infer V> ? LoadedProperty<any, V> : T[K]; } & {
   /**
    * Gives reactive rules & fields a way to get the full entity if they really need it.
    *
@@ -47,7 +47,7 @@ type Reacted<T extends Entity, H> = Entity & { [K in keyof NormalizeHint<H> & ke
   changes: Changes<T, keyof (FieldsOf<T> & RelationsOf<T>), keyof NormalizeHint<H>>;
 } & MaybeTransientFields<T>;
 /** Allow returning reacted entities from `hasReactiveReference`. */
-type MaybeReactedEntity<V> = V extends Entity ? {
+export type MaybeReactedEntity<V> = V extends Entity ? {
   fullNonReactiveAccess: V;
 } : V;
 /**
@@ -57,16 +57,16 @@ type MaybeReactedEntity<V> = V extends Entity ? {
  * broken out as a separate generic; `hasReactiveProperty` does not, and so this type conditionally
  * pulls `undefined` out first, and then defers to `MaybeReactedEntity`.
  */
-type MaybeReactedPropertyEntity<V> = V extends (infer V1 extends Entity) | undefined ? MaybeReactedEntity<V1> | undefined : MaybeReactedEntity<V>;
+export type MaybeReactedPropertyEntity<V> = V extends (infer V1 extends Entity) | undefined ? MaybeReactedEntity<V1> | undefined : MaybeReactedEntity<V>;
 /**
  * A reactive hint that only allows fields immediately on the entity, i.e. no nested hints.
  *
  * This is used by `ReactiveGetter`s to guarantee that their lambda functions will
  * always be `.get`-able and hence not need loading.
  */
-type ShallowReactiveHint<T extends Entity> = (keyof FieldsOf<T> & string) | ReadonlyArray<keyof FieldsOf<T> & string>;
+export type ShallowReactiveHint<T extends Entity> = (keyof FieldsOf<T> & string) | ReadonlyArray<keyof FieldsOf<T> & string>;
 /** If the domain model has transient fields, allow reactive behavior to see it, i.e. don't run validation rules for special operations. */
-type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
+export type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
   transientFields: T["transientFields"];
 } : {};
 /**
@@ -79,7 +79,7 @@ type MaybeTransientFields<T> = "transientFields" extends keyof T ? {
  * @param reactForOtherSide the name of our FK column, if the previous collection needs to react to our FK changing
  * @param isFirst
  */
-declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEntityConstructor<T>, entityType: MaybeAbstractEntityConstructor<T>, hint: ReactiveHint<T>, reactForOtherSide?: string, reactForOtherSideIsReadOnly?: "field-read-only" | "hint-read-only" | false, isFirst?: boolean): ReactiveTarget[];
+export declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEntityConstructor<T>, entityType: MaybeAbstractEntityConstructor<T>, hint: ReactiveHint<T>, reactForOtherSide?: string, reactForOtherSideIsReadOnly?: "field-read-only" | "hint-read-only" | false, isFirst?: boolean): ReactiveTarget[];
 /**
  * Walks `reverseHint` for every entity in `entities`.
  *
@@ -114,11 +114,11 @@ declare function reverseReactiveHint<T extends Entity>(rootType: MaybeAbstractEn
  * before the final flush changes it to `a3`. `setField` remembers both original and transient reference values
  * separately from `originalData`, and we walk them in addition to the current value.
  */
-declare function followReverseHint(reactionName: string, entities: Entity[], reverseHint: string[]): Promise<Entity[]>;
+export declare function followReverseHint(reactionName: string, entities: Entity[], reverseHint: string[]): Promise<Entity[]>;
 /** Converts a normalized reactive `hint` into a load hint. */
-declare function convertToLoadHint<T extends Entity>(meta: EntityMetadata, hint: ReactiveHint<T>, allowCustomKeys?: boolean): LoadHint<T>;
+export declare function convertToLoadHint<T extends Entity>(meta: EntityMetadata, hint: ReactiveHint<T>, allowCustomKeys?: boolean): LoadHint<T>;
 /** An entity that, when `fields` change, should trigger the reactive rule/field pointed to by `path`. */
-interface ReactiveTarget {
+export interface ReactiveTarget {
   kind: "read-only" | "update";
   /** The entity that contains a field our reactive rule/field accesses. */
   entity: MaybeAbstractEntityConstructor<any>;
@@ -133,11 +133,11 @@ interface ReactiveTarget {
  * a `SmallPublisher` entity should pass an `@Publisher` filter because it is
  * a Publisher via inheritance.
  */
-declare function isTypeOrSubType(entity: Entity, typeName: string): boolean;
-declare function isPolyHint(key: string): boolean;
-declare function splitPolyHintToKeyAndType(key: string): [string, string];
+export declare function isTypeOrSubType(entity: Entity, typeName: string): boolean;
+export declare function isPolyHint(key: string): boolean;
+export declare function splitPolyHintToKeyAndType(key: string): [string, string];
 /** If this hint is a poly like `author@Book`, return the type, otherwise return undefined. */
-declare function getRelationFromMaybePolyKey(entity: Entity, key: string): any;
+export declare function getRelationFromMaybePolyKey(entity: Entity, key: string): any;
 //#endregion
-export { Gettable, MaybeReactedEntity, MaybeReactedPropertyEntity, MaybeTransientFields, NestedReactiveHint, Reactable, Reacted, ReactiveHint, ReactiveTarget, ShallowReactiveHint, convertToLoadHint, followReverseHint, getRelationFromMaybePolyKey, isPolyHint, isTypeOrSubType, reverseReactiveHint, splitPolyHintToKeyAndType };
+export {};
 //# sourceMappingURL=reactiveHints.d.mts.map

package/build/reactivity/reactiveHints.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"reactiveHints.d.mts","names":[],"sources":["../../src/reactivity/reactiveHints.ts"],"mappings":";;;;;;;;;;;;;;;;;;KA8CY,UAAU,UAAU,UAE9B,SAAS,KAGP,SAAS,KACT,SAAS,KACT,iBAAiB,KACjB,iBAAiB,KACjB,iBAAiB;;KAGT,SAAS,UAAU,uBAClB,WAAW,KAAK,cAAc,EAAE,4BAA4B,IAAI,cAAc,EAAE;KAGxF,cAAc,KAAK,UAAU,0BAA0B,KAAK;;KAG5D,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;;;;;;;;KAUnE,aAAa,UAAU,iBACxB,UAAU,eACjB,oBAAoB,UAAU,eAC9B,mBAAmB;KAEX,mBAAmB,UAAU,aACtC,WAAW,UAAU,MAAM,UAAU,GAAG,kBAAiB,UAAU,UAAS,aAAa;;KAIhF,QAAQ,UAAU,QAAQ,KAAK,YACxC,WAAW,cAAc,WAAW,IAAI,EAAE,WAAW,6BAA6B,KAC/E,wBAAwB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OAGhE,EAAE,WAAW,gCAAgC,SAAS,KACpD,qBAAqB,GAAG,GAAG,KAAK,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7F,EAAE,WAAW,qBAAqB,SAAS,KACzC,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7D,EAAE,WAAW,0BAA0B,KACrC,qBAAqB,GAAG,KACxB,EAAE,WAAW,sBAAsB,KACjC,iBAAiB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACzD,EAAE,WAAW,8BAA8B,KACzC,yBAAyB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACjE,EAAE,WAAW,oBAAoB,KAC/B,oBAAoB,KACpB,EAAE;;;;;;;;EASlB,uBAAuB,OAAO,GAAG;;EAEjC,SAAS,QAAQ,UAAU,SAAS,KAAK,YAAY,WAAW,cAAc;IAC5E,qBAAqB;;KAGb,mBAAmB,KAAK,UAAU;EAAW,uBAAuB;IAAM;;;;;;;;KAS1E,2BAA2B,KAAK,iBAAiB,WAAW,sBACpE,mBAAmB,kBACnB,mBAAmB;;;;;;;KAQX,oBAAoB,UAAU,iBAC/B,SAAS,eAChB,oBAAoB,SAAS;;KAGrB,qBAAqB,qCAAqC;EAChE,iBAAiB;;;;;;;;;;;;iBAaP,oBAAoB,UAAU,QAC5C,UAAU,+BAA+B,IACzC,YAAY,+BAA+B,IAC3C,MAAM,aAAa,IACnB,4BACA,4EACA,oBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+SmB,kBACpB,sBACA,UAAU,UACV,wBACC,QAAQ;;iBAuEK,kBAAkB,UAAU,QAC1C,MAAM,gBACN,MAAM,aAAa,IACnB,4BACC,SAAS;;UA0EK;EACf;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;iBA+Bc,gBAAgB,QAAQ,QAAQ;iBAKhC,WAAW;iBAIX,0BAA0B;;iBAM1B,4BAA4B,QAAQ,QAAQ"}
+{"version":3,"file":"reactiveHints.d.mts","names":[],"sources":["../../src/reactivity/reactiveHints.ts"],"mappings":";;;;;;;;;;;;;;;;;;YA8CY,UAAU,UAAU,UAE9B,SAAS,KAGP,SAAS,KACT,SAAS,KACT,iBAAiB,KACjB,iBAAiB,KACjB,iBAAiB;;YAGT,SAAS,UAAU,uBAClB,WAAW,KAAK,cAAc,EAAE,4BAA4B,IAAI,cAAc,EAAE;KAGxF,cAAc,KAAK,UAAU,0BAA0B,KAAK;;KAG5D,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;KAG1E,iBAAiB,UAAU,aAC7B,WAAW,SAAS,kBAAkB,IAAI,sBAAsB,SAAS,GAAG;;;;;;;;YAUnE,aAAa,UAAU,iBACxB,UAAU,eACjB,oBAAoB,UAAU,eAC9B,mBAAmB;YAEX,mBAAmB,UAAU,aACtC,WAAW,UAAU,MAAM,UAAU,GAAG,kBAAiB,UAAU,UAAS,aAAa;;YAIhF,QAAQ,UAAU,QAAQ,KAAK,YACxC,WAAW,cAAc,WAAW,IAAI,EAAE,WAAW,6BAA6B,KAC/E,wBAAwB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OAGhE,EAAE,WAAW,gCAAgC,SAAS,KACpD,qBAAqB,GAAG,GAAG,KAAK,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7F,EAAE,WAAW,qBAAqB,SAAS,KACzC,gBAAgB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,KAAK,KAC7D,EAAE,WAAW,0BAA0B,KACrC,qBAAqB,GAAG,KACxB,EAAE,WAAW,sBAAsB,KACjC,iBAAiB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACzD,EAAE,WAAW,8BAA8B,KACzC,yBAAyB,GAAG,SAAS,QAAQ,GAAG,cAAc,GAAG,OACjE,EAAE,WAAW,oBAAoB,KAC/B,oBAAoB,KACpB,EAAE;;;;;;;;EASlB,uBAAuB,OAAO,GAAG;;EAEjC,SAAS,QAAQ,UAAU,SAAS,KAAK,YAAY,WAAW,cAAc;IAC5E,qBAAqB;;YAGb,mBAAmB,KAAK,UAAU;EAAW,uBAAuB;IAAM;;;;;;;;YAS1E,2BAA2B,KAAK,iBAAiB,WAAW,sBACpE,mBAAmB,kBACnB,mBAAmB;;;;;;;YAQX,oBAAoB,UAAU,iBAC/B,SAAS,eAChB,oBAAoB,SAAS;;YAGrB,qBAAqB,qCAAqC;EAChE,iBAAiB;;;;;;;;;;;;wBAaP,oBAAoB,UAAU,QAC5C,UAAU,+BAA+B,IACzC,YAAY,+BAA+B,IAC3C,MAAM,aAAa,IACnB,4BACA,4EACA,oBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+SmB,kBACpB,sBACA,UAAU,UACV,wBACC,QAAQ;;wBAuEK,kBAAkB,UAAU,QAC1C,MAAM,gBACN,MAAM,aAAa,IACnB,4BACC,SAAS;;iBA0EK;EACf;;EAEA,QAAQ;;EAER;;EAEA;;;;;;;;wBA+Bc,gBAAgB,QAAQ,QAAQ;wBAKhC,WAAW;wBAIX,0BAA0B;;wBAM1B,4BAA4B,QAAQ,QAAQ"}

package/build/relations/AbstractPropertyImpl.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractPropertyImpl.cjs","names":["#entity"],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"sourcesContent":["/** A base class for relations & non-relation (i.e. `ReactiveField) properties. */\nexport abstract class AbstractPropertyImpl<T> {\n  #entity: T;\n\n  constructor(entity: T) {\n    this.#entity = entity;\n  }\n\n  get entity(): T {\n    return this.#entity;\n  }\n\n  abstract get isLoaded(): boolean;\n}\n"],"mappings":";;;AACA,IAAsB,uBAAtB,MAA8C;CAC5C;CAEA,YAAY,QAAW;EACrB,KAAKA,UAAU;CACjB;CAEA,IAAI,SAAY;EACd,OAAO,KAAKA;CACd;AAGF"}
+{"version":3,"file":"AbstractPropertyImpl.cjs","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"sourcesContent":["/** A base class for relations & non-relation (i.e. `ReactiveField) properties. */\nexport abstract class AbstractPropertyImpl<T> {\n  #entity: T;\n\n  constructor(entity: T) {\n    this.#entity = entity;\n  }\n\n  get entity(): T {\n    return this.#entity;\n  }\n\n  abstract get isLoaded(): boolean;\n}\n"],"mappings":";;;AACA,IAAsB,uBAAtB,MAA8C;CAC5C;CAEA,YAAY,QAAW;EACrB,KAAK,UAAU;CACjB;CAEA,IAAI,SAAY;EACd,OAAO,KAAK;CACd;AAGF"}

package/build/relations/AbstractPropertyImpl.d.cts

@@ -1,11 +1,10 @@
 //#region src/relations/AbstractPropertyImpl.d.ts
 /** A base class for relations & non-relation (i.e. `ReactiveField) properties. */
-declare abstract class AbstractPropertyImpl<T> {
+export declare abstract class AbstractPropertyImpl<T> {
   #private;
   constructor(entity: T);
   get entity(): T;
   abstract get isLoaded(): boolean;
 }
 //#endregion
-export { AbstractPropertyImpl };
 //# sourceMappingURL=AbstractPropertyImpl.d.cts.map

package/build/relations/AbstractPropertyImpl.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractPropertyImpl.d.cts","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"mappings":";;uBACsB,qBAAqB;;EAGzC,YAAY,QAAQ;MAIhB,UAAU;eAID"}
+{"version":3,"file":"AbstractPropertyImpl.d.cts","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"mappings":";;8BACsB,qBAAqB;;EAGzC,YAAY,QAAQ;MAIhB,UAAU;eAID"}

package/build/relations/AbstractPropertyImpl.d.mts

@@ -1,11 +1,10 @@
 //#region src/relations/AbstractPropertyImpl.d.ts
 /** A base class for relations & non-relation (i.e. `ReactiveField) properties. */
-declare abstract class AbstractPropertyImpl<T> {
+export declare abstract class AbstractPropertyImpl<T> {
   #private;
   constructor(entity: T);
   get entity(): T;
   abstract get isLoaded(): boolean;
 }
 //#endregion
-export { AbstractPropertyImpl };
 //# sourceMappingURL=AbstractPropertyImpl.d.mts.map

package/build/relations/AbstractPropertyImpl.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractPropertyImpl.d.mts","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"mappings":";;uBACsB,qBAAqB;;EAGzC,YAAY,QAAQ;MAIhB,UAAU;eAID"}
+{"version":3,"file":"AbstractPropertyImpl.d.mts","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"mappings":";;8BACsB,qBAAqB;;EAGzC,YAAY,QAAQ;MAIhB,UAAU;eAID"}

package/build/relations/AbstractPropertyImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractPropertyImpl.js","names":["#entity"],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"sourcesContent":["/** A base class for relations & non-relation (i.e. `ReactiveField) properties. */\nexport abstract class AbstractPropertyImpl<T> {\n  #entity: T;\n\n  constructor(entity: T) {\n    this.#entity = entity;\n  }\n\n  get entity(): T {\n    return this.#entity;\n  }\n\n  abstract get isLoaded(): boolean;\n}\n"],"mappings":";;AACA,IAAsB,uBAAtB,MAA8C;CAC5C;CAEA,YAAY,QAAW;EACrB,KAAKA,UAAU;CACjB;CAEA,IAAI,SAAY;EACd,OAAO,KAAKA;CACd;AAGF"}
+{"version":3,"file":"AbstractPropertyImpl.js","names":[],"sources":["../../src/relations/AbstractPropertyImpl.ts"],"sourcesContent":["/** A base class for relations & non-relation (i.e. `ReactiveField) properties. */\nexport abstract class AbstractPropertyImpl<T> {\n  #entity: T;\n\n  constructor(entity: T) {\n    this.#entity = entity;\n  }\n\n  get entity(): T {\n    return this.#entity;\n  }\n\n  abstract get isLoaded(): boolean;\n}\n"],"mappings":";;AACA,IAAsB,uBAAtB,MAA8C;CAC5C;CAEA,YAAY,QAAW;EACrB,KAAK,UAAU;CACjB;CAEA,IAAI,SAAY;EACd,OAAO,KAAK;CACd;AAGF"}

package/build/relations/AbstractRelationImpl.d.cts

@@ -3,7 +3,7 @@ import { AbstractPropertyImpl } from "./AbstractPropertyImpl.cjs";
 /**
  * Defines common hooks that relations can respond to to keep the entity graph in sync.
  */
-declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {
+export declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {
   constructor(entity: T);
   /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */
   abstract setFromOpts(value: U): void;
@@ -39,5 +39,4 @@ declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T
   abstract get fieldName(): string;
 }
 //#endregion
-export { AbstractRelationImpl };
 //# sourceMappingURL=AbstractRelationImpl.d.cts.map

package/build/relations/AbstractRelationImpl.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.d.cts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}
+{"version":3,"file":"AbstractRelationImpl.d.cts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;8BAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}

package/build/relations/AbstractRelationImpl.d.mts

@@ -3,7 +3,7 @@ import { AbstractPropertyImpl } from "./AbstractPropertyImpl.mjs";
 /**
  * Defines common hooks that relations can respond to to keep the entity graph in sync.
  */
-declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {
+export declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T> {
   constructor(entity: T);
   /** Called with the opts from a `new` or `em.create` call, i.e. on a new entity. */
   abstract setFromOpts(value: U): void;
@@ -39,5 +39,4 @@ declare abstract class AbstractRelationImpl<T, U> extends AbstractPropertyImpl<T
   abstract get fieldName(): string;
 }
 //#endregion
-export { AbstractRelationImpl };
 //# sourceMappingURL=AbstractRelationImpl.d.mts.map

package/build/relations/AbstractRelationImpl.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractRelationImpl.d.mts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;uBAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}
+{"version":3,"file":"AbstractRelationImpl.d.mts","names":[],"sources":["../../src/relations/AbstractRelationImpl.ts"],"mappings":";;;;;8BAKsB,qBAAqB,GAAG,WAAW,qBAAqB;EAC5E,YAAY,QAAQ;;WAKX,YAAY,OAAO;;WAGnB,IAAI,OAAO;;eAGP;;eAGA;;WAGJ,KAAK;IAAS;MAA0B;;WAGxC;eAEI,OAAO;;;;;;;;;;WAWX,0BAA0B;;;;;;WAO1B;eAEI"}

package/build/relations/AsyncProperty.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.cjs","names":["lazyField","AbstractPropertyImpl","#loadPromise","#loaded","#value","PropertyT"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4DC,uCAAAA,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAKC,eAAe,KAAA;GACpB,KAAKC,UAAU;EACjB;EACA,IAAI,KAAKA,SACP,OAAO,QAAQ,QAAQ,KAAKC,MAAW;EAEzC,OAAQ,KAAKF,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAKC;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAKD;CACd;;CAGA,kBAAwB;EACtB,KAAKD,eAAe,KAAA;EACpB,KAAKC,UAAU;EACf,KAAKC,SAAS,KAAA;CAChB;CAEA,CAACC,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}
+{"version":3,"file":"AsyncProperty.cjs","names":["lazyField","AbstractPropertyImpl","PropertyT"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAOA,kBAAAA,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4DC,uCAAAA,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAK,eAAe,KAAA;GACpB,KAAK,UAAU;EACjB;EACA,IAAI,KAAK,SACP,OAAO,QAAQ,QAAQ,KAAK,MAAW;EAEzC,OAAQ,KAAK,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAK,SAAS;GACd,KAAK,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAK,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAK;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAK;CACd;;CAGA,kBAAwB;EACtB,KAAK,eAAe,KAAA;EACpB,KAAK,UAAU;EACf,KAAK,SAAS,KAAA;CAChB;CAEA,CAACC,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}

package/build/relations/AsyncProperty.d.cts

@@ -3,7 +3,7 @@ import { PropertyT } from "./PropertySymbols.cjs";
 import { LoadedProperty, Property } from "./hasProperty.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/relations/AsyncProperty.d.ts
-interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
+export interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
   load(opts?: {
     forceReload?: boolean;
   }): Promise<V>;
@@ -17,8 +17,8 @@ interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
  * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
  * - The result is cached until the next `em.flush`.
  */
-declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
-declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
+export declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
+export declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
   #private;
   private fn;
   constructor(entity: T, fn: (entity: T) => Promise<V>);
@@ -32,9 +32,8 @@ declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImp
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is an AsyncProperty. */
-declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
+export declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
 /** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
-declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
+export declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
 //#endregion
-export { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
 //# sourceMappingURL=AsyncProperty.d.cts.map

package/build/relations/AsyncProperty.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.d.cts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;UAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;iBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;cAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;iBAIpB,gBAAgB,aAAa,SAAS;;iBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}
+{"version":3,"file":"AsyncProperty.d.cts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;iBAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;wBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;qBAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;wBAIpB,gBAAgB,aAAa,SAAS;;wBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}

package/build/relations/AsyncProperty.d.mts

@@ -3,7 +3,7 @@ import { PropertyT } from "./PropertySymbols.mjs";
 import { LoadedProperty, Property } from "./hasProperty.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/relations/AsyncProperty.d.ts
-interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
+export interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
   load(opts?: {
     forceReload?: boolean;
   }): Promise<V>;
@@ -17,8 +17,8 @@ interface AsyncProperty<T extends Entity, V> extends Property<T, V> {
  * - For new (un-flushed) entities, `load` throws because the entity has no id yet.
  * - The result is cached until the next `em.flush`.
  */
-declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
-declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
+export declare function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V>;
+export declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {
   #private;
   private fn;
   constructor(entity: T, fn: (entity: T) => Promise<V>);
@@ -32,9 +32,8 @@ declare class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImp
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is an AsyncProperty. */
-declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
+export declare function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any>;
 /** Type guard utility for determining if an entity field is a loaded AsyncProperty. */
-declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
+export declare function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any>;
 //#endregion
-export { AsyncProperty, AsyncPropertyImpl, hasAsyncProperty, isAsyncProperty, isLoadedAsyncProperty };
 //# sourceMappingURL=AsyncProperty.d.mts.map

package/build/relations/AsyncProperty.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.d.mts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;UAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;iBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;cAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;iBAIpB,gBAAgB,aAAa,SAAS;;iBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}
+{"version":3,"file":"AsyncProperty.d.mts","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"mappings":";;;;;iBAMiB,cAAc,UAAU,QAAQ,WAAW,SAAS,GAAG;EACtE,KAAK;IAAS;MAA0B,QAAQ;;;;;;;;;;;wBAYlC,iBAAiB,UAAU,QAAQ,GAAG,KAAK,QAAQ,MAAM,QAAQ,KAAK,SAAS,GAAG;qBAMrF,kBAAkB,UAAU,QAAQ,WAAW,qBAAqB,cAAc,cAAc,GAAG;;UAOpG;EAFV,YACE,QAAQ,GACA,KAAK,QAAQ,MAAM,QAAQ;EAKrC,KAAK;IAAS;MAA0B,QAAQ;MAkB5C,OAAO;MAQP;;EAMJ;GAMC,YAAiC;;;wBAIpB,gBAAgB,aAAa,SAAS;;wBAKtC,sBAAsB,aAAa,SAAS,0BAA0B"}

package/build/relations/AsyncProperty.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncProperty.js","names":["#loadPromise","#loaded","#value"],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4D,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAKA,eAAe,KAAA;GACpB,KAAKC,UAAU;EACjB;EACA,IAAI,KAAKA,SACP,OAAO,QAAQ,QAAQ,KAAKC,MAAW;EAEzC,OAAQ,KAAKF,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAKE,SAAS;GACd,KAAKD,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAKA,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAKC;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAKD;CACd;;CAGA,kBAAwB;EACtB,KAAKD,eAAe,KAAA;EACpB,KAAKC,UAAU;EACf,KAAKC,SAAS,KAAA;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}
+{"version":3,"file":"AsyncProperty.js","names":[],"sources":["../../src/relations/AsyncProperty.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { type LoadedProperty, type Property } from \"src/relations/hasProperty.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\n\nexport interface AsyncProperty<T extends Entity, V> extends Property<T, V> {\n  load(opts?: { forceReload?: boolean }): Promise<V>;\n}\n\n/**\n * Creates a derived value calculated from a SQL query.\n *\n * Unlike `hasProperty`, the lambda receives the entity and is expected\n * to perform its own SQL queries rather than relying on in-memory graph data.\n *\n * - For new (un-flushed) entities, `load` throws because the entity has no id yet.\n * - The result is cached until the next `em.flush`.\n */\nexport function hasAsyncProperty<T extends Entity, V>(fn: (entity: T) => Promise<V>): Property<T, V> {\n  return lazyField((entity: T) => {\n    return new AsyncPropertyImpl(entity, fn);\n  });\n}\n\nexport class AsyncPropertyImpl<T extends Entity, V> extends AbstractPropertyImpl<T> implements AsyncProperty<T, V> {\n  #loadPromise: Promise<V> | undefined;\n  #loaded = false;\n  #value: V | undefined;\n\n  constructor(\n    entity: T,\n    private fn: (entity: T) => Promise<V>,\n  ) {\n    super(entity);\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be loaded on a new entity that has not been flushed yet\");\n    }\n    if (opts?.forceReload) {\n      this.#loadPromise = undefined;\n      this.#loaded = false;\n    }\n    if (this.#loaded) {\n      return Promise.resolve(this.#value as V);\n    }\n    return (this.#loadPromise ??= this.fn(this.entity).then((value) => {\n      this.#value = value;\n      this.#loaded = true;\n      return value;\n    }));\n  }\n\n  get get(): V {\n    if (this.entity.isNewEntity) {\n      throw new Error(\"AsyncProperty cannot be accessed on a new entity that has not been flushed yet\");\n    }\n    if (!this.#loaded) throw new Error(\"AsyncProperty has not been loaded yet\");\n    return this.#value as V;\n  }\n\n  get isLoaded(): boolean {\n    if (this.entity.isNewEntity) return false;\n    return this.#loaded;\n  }\n\n  /** Called after em.flush to invalidate the cached value. */\n  resetAfterFlush(): void {\n    this.#loadPromise = undefined;\n    this.#loaded = false;\n    this.#value = undefined;\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncProperty. */\nexport function isAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> {\n  return maybe instanceof AsyncPropertyImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncProperty. */\nexport function isLoadedAsyncProperty(maybe: any): maybe is AsyncProperty<any, any> & LoadedProperty<any, any> {\n  return isAsyncProperty(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAsC,IAA+C;CACnG,OAAO,WAAW,WAAc;EAC9B,OAAO,IAAI,kBAAkB,QAAQ,EAAE;CACzC,CAAC;AACH;AAEA,IAAa,oBAAb,cAA4D,qBAAuD;CAOvG;CANV;CACA,UAAU;CACV;CAEA,YACE,QACA,IACA;EACA,MAAM,MAAM;EAFJ,KAAA,KAAA;CAGV;CAEA,KAAK,MAA8C;EACjD,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,8EAA8E;EAEhG,IAAI,MAAM,aAAa;GACrB,KAAK,eAAe,KAAA;GACpB,KAAK,UAAU;EACjB;EACA,IAAI,KAAK,SACP,OAAO,QAAQ,QAAQ,KAAK,MAAW;EAEzC,OAAQ,KAAK,iBAAiB,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC,MAAM,UAAU;GACjE,KAAK,SAAS;GACd,KAAK,UAAU;GACf,OAAO;EACT,CAAC;CACH;CAEA,IAAI,MAAS;EACX,IAAI,KAAK,OAAO,aACd,MAAM,IAAI,MAAM,gFAAgF;EAElG,IAAI,CAAC,KAAK,SAAS,MAAM,IAAI,MAAM,uCAAuC;EAC1E,OAAO,KAAK;CACd;CAEA,IAAI,WAAoB;EACtB,IAAI,KAAK,OAAO,aAAa,OAAO;EACpC,OAAO,KAAK;CACd;;CAGA,kBAAwB;EACtB,KAAK,eAAe,KAAA;EACpB,KAAK,UAAU;EACf,KAAK,SAAS,KAAA;CAChB;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,gBAAgB,OAA8C;CAC5E,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,sBAAsB,OAAyE;CAC7G,OAAO,gBAAgB,KAAK,KAAK,MAAM;AACzC"}

package/build/relations/AsyncReactiveField.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncReactiveField.cjs","names":["lazyField","AbstractPropertyImpl","#loadHint","#reactiveHint","#loaded","deepNormalizeHint","#loadPromise","#useFactoryValue","getField","isFieldSet","isLoaded","getMetadata","convertToLoadHint","PropertyT"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACUC,uCAAAA,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAKC,YAAY;EACjB,KAAKC,gBAAgB;EACrB,KAAKC,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAOC,uBAAAA,kBAAkB,KAAKH,SAAS;EAC7C,cAAA,qBAAqB,MAAMG,uBAAAA,kBAAkB,KAAKF,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAKG,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAKC,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAKD,eAAe,KAAA;GACpB,KAAKF,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAKE,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAOE,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAaC,0BAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAKN,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAOO,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeC,iCAAAA,kBAAkB,MAAM,KAAKV,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAKK,mBAAmB;EACxB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAACM,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}
+{"version":3,"file":"AsyncReactiveField.cjs","names":["lazyField","AbstractPropertyImpl","deepNormalizeHint","getField","isFieldSet","isLoaded","getMetadata","convertToLoadHint","PropertyT"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACUC,uCAAAA,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAK,YAAY;EACjB,KAAK,gBAAgB;EACrB,KAAK,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAOC,uBAAAA,kBAAkB,KAAK,SAAS;EAC7C,cAAA,qBAAqB,MAAMA,uBAAAA,kBAAkB,KAAK,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAK,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAK,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAK,eAAe,KAAA;GACpB,KAAK,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAK,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAOC,eAAAA,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAOC,eAAAA,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAaC,0BAAAA,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAK,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAOC,uBAAAA,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAeC,iCAAAA,kBAAkB,MAAM,KAAK,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAK,mBAAmB;EACxB,eAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAACC,kCAAAA,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}

package/build/relations/AsyncReactiveField.d.cts

@@ -16,8 +16,8 @@ import { Entity } from "../Entity.cjs";
  * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
  * changes, but only the `loadHint`'s data is populated.
  */
-declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
-declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+export declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+export declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
   #private;
   fieldName: keyof T & string;
   private fn;
@@ -42,9 +42,8 @@ declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is an AsyncReactiveField. */
-declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+export declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
 /** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
-declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+export declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
 //#endregion
-export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
 //# sourceMappingURL=AsyncReactiveField.d.cts.map

package/build/relations/AsyncReactiveField.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncReactiveField.d.cts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}
+{"version":3,"file":"AsyncReactiveField.d.cts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;wBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;qBAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;wBAIpB,qBAAqB,aAAa,SAAS;;wBAK3C,2BAA2B,aAAa,SAAS"}

package/build/relations/AsyncReactiveField.d.mts

@@ -16,8 +16,8 @@ import { Entity } from "../Entity.mjs";
  * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint
  * changes, but only the `loadHint`'s data is populated.
  */
-declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
-declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
+export declare function hasAsyncReactiveField<T extends Entity, const H1 extends ReactiveHint<T>, const H2 extends ReactiveHint<T>, V>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V>;
+export declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V> extends AbstractPropertyImpl<T> implements ReactiveField<T, V> {
   #private;
   fieldName: keyof T & string;
   private fn;
@@ -42,9 +42,8 @@ declare class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T
   [PropertyT]: T;
 }
 /** Type guard utility for determining if an entity field is an AsyncReactiveField. */
-declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+export declare function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
 /** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */
-declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
+export declare function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any>;
 //#endregion
-export { AsyncReactiveFieldImpl, hasAsyncReactiveField, isAsyncReactiveField, isLoadedAsyncReactiveField };
 //# sourceMappingURL=AsyncReactiveField.d.mts.map

package/build/relations/AsyncReactiveField.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncReactiveField.d.mts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;cAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;iBAIpB,qBAAqB,aAAa,SAAS;;iBAK3C,2BAA2B,aAAa,SAAS"}
+{"version":3,"file":"AsyncReactiveField.d.mts","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"mappings":";;;;;;;;;;;;;;;;;;wBAqBgB,sBACd,UAAU,cACJ,WAAW,aAAa,UACxB,WAAW,aAAa,IAC9B,GACA,UAAU,IAAI,cAAc,IAAI,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,KAAK,cAAc,GAAG;qBAMnF,uBAAuB,UAAU,QAAQ,WAAW,aAAa,IAAI,WAAW,aAAa,IAAI,WACpG,qBAAqB,cAClB,cAAc,GAAG;;EAUnB,iBAAiB;UAGhB;EALV,YACE,QAAQ,GACD,iBAAiB,YACxB,UAAU,IACV,cAAc,IACN,KAAK,QAAQ,QAAQ,GAAG,QAAQ,QAAQ;;;;;;;MAc9C,gBAAgB;EAQpB,KAAK;IAAS;MAA0B,QAAQ;;MAyB5C,OAAO;MAWP,cAAc;MAId;MAIA;MAQA;EAMJ,gBAAgB;GAKf,YAAiC;;;wBAIpB,qBAAqB,aAAa,SAAS;;wBAK3C,2BAA2B,aAAa,SAAS"}

package/build/relations/AsyncReactiveField.js.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncReactiveField.js","names":["#loadHint","#reactiveHint","#loaded","#loadPromise","#useFactoryValue"],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACU,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAKA,YAAY;EACjB,KAAKC,gBAAgB;EACrB,KAAKC,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAO,kBAAkB,KAAKF,SAAS;EAC7C,qBAAqB,MAAM,kBAAkB,KAAKC,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAKE,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAKC,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAKD,eAAe,KAAA;GACpB,KAAKD,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAKC,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAO,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAO,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAa,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAKD,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAO,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAe,kBAAkB,MAAM,KAAKF,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAKI,mBAAmB;EACxB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}
+{"version":3,"file":"AsyncReactiveField.js","names":[],"sources":["../../src/relations/AsyncReactiveField.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { getMetadata } from \"src/EntityMetadata.ts\";\nimport { getField, isFieldSet, setField } from \"src/fields.ts\";\nimport { type ReactiveField, deepNormalizeHint, isLoaded } from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { type Reacted, type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { AbstractPropertyImpl } from \"src/relations/AbstractPropertyImpl.ts\";\nimport { PropertyT } from \"src/relations/PropertySymbols.ts\";\nimport { mergeNormalizedHints } from \"src/utils.ts\";\n\n/**\n * An `AsyncReactiveField` is a value that is derived from a SQL query, similar to\n * a `ReactiveField`, but when the value needs to be calculated from SQL because\n * it would be too expensive to calculate in-memory.\n *\n * Its hint is split in two: the `loadHint` names data that is both reacted-to *and*\n * loaded into memory (and passed to `fn`), while the `reactiveHint` names data that is\n * only reacted-to (its changes recompute the value) but is left in the database rather\n * than pulled into memory. The `fn` lambda re-runs when data referred to by either hint\n * changes, but only the `loadHint`'s data is populated.\n */\nexport function hasAsyncReactiveField<\n  T extends Entity,\n  const H1 extends ReactiveHint<T>,\n  const H2 extends ReactiveHint<T>,\n  V,\n>(loadHint: H1, reactiveHint: H2, fn: (entity: Reacted<T, H1>) => Promise<V>): ReactiveField<T, V> {\n  return lazyField((entity: T, fieldName) => {\n    return new AsyncReactiveFieldImpl(entity, fieldName as keyof T & string, loadHint, reactiveHint, fn);\n  });\n}\n\nexport class AsyncReactiveFieldImpl<T extends Entity, H1 extends ReactiveHint<T>, H2 extends ReactiveHint<T>, V>\n  extends AbstractPropertyImpl<T>\n  implements ReactiveField<T, V>\n{\n  readonly #loadHint: H1;\n  readonly #reactiveHint: H2;\n  #loadPromise: any;\n  #loaded: boolean;\n  #useFactoryValue = false;\n\n  constructor(\n    entity: T,\n    public fieldName: keyof T & string,\n    loadHint: H1,\n    reactiveHint: H2,\n    private fn: (entity: Reacted<T, H1>) => Promise<V>,\n  ) {\n    super(entity);\n    this.#loadHint = loadHint;\n    this.#reactiveHint = reactiveHint;\n    this.#loaded = false;\n  }\n\n  /**\n   * Our combined load + reactive-only hint, so that we react to changes within both.\n   *\n   * The `loadHint` half is populated into memory (and passed to `fn`); the `reactiveHint`\n   * half only triggers recalculation, so its data stays in the database.\n   */\n  get reactiveHint(): ReactiveHint<any> {\n    // We do this in a getter (instead of the constructor) b/c it might be a little expensive,\n    // and I'm pretty sure this is only called on boot, when hooking up the reactivity.\n    const hint = deepNormalizeHint(this.#loadHint);\n    mergeNormalizedHints(hint, deepNormalizeHint(this.#reactiveHint));\n    return hint;\n  }\n\n  load(opts?: { forceReload?: boolean }): Promise<V> {\n    // if (!this.isSet || opts?.forceReload) {\n    return (this.#loadPromise ??= this.entity.em\n      .populate(this.entity, { hint: this.loadHint } as any)\n      .then(() => {\n        // Even if the factory used a `with...`, we'll still go through the RFQ logic, but just ignore the new value\n        return this.#useFactoryValue ? this.fieldValue : this.fn(this.entity as Reacted<T, H1>);\n      })\n      .then((newValue) => {\n        setField(this.entity, this.fieldName, newValue);\n        this.#loadPromise = undefined;\n        this.#loaded = true;\n        return newValue;\n      })\n      .catch((e) => {\n        // If we blow up calling `this.fn` i.e. due to a NoIdError, we want to make\n        // sure that the next `.load` call tries again.\n        this.#loadPromise = undefined;\n        throw e;\n      }));\n    // }\n    // return tryResolve(() => this.get);\n  }\n\n  /** Returns the previously-calculated value. */\n  get get(): V {\n    // Regular ReactiveFields repeatedly call their `fn` lambda to calculate the value, to ensure\n    // they always return the latest/correct value, but because AsyncReactiveFields are fundamentally\n    // calculated from DB queries, we can only return the previously-calculated value, if set.\n    if (this.isSet) {\n      return this.fieldValue;\n    } else {\n      throw new Error(`${this.fieldName} has not been derived yet`);\n    }\n  }\n\n  get fieldValue(): V {\n    return getField(this.entity, this.fieldName);\n  }\n\n  get isSet() {\n    return isFieldSet(this.entity, this.fieldName);\n  }\n\n  get isLoaded() {\n    const hintLoaded = isLoaded(this.entity, this.loadHint);\n    if (hintLoaded) {\n      this.#loaded = true;\n    }\n    return hintLoaded;\n  }\n\n  get loadHint(): any {\n    // Only convert the loadHint, so we don't pull the reactiveHint-referenced data into memory\n    const meta = getMetadata(this.entity);\n    return (meta.config.__data.cachedReactiveLoadHints[this.fieldName] ??= convertToLoadHint(meta, this.#loadHint));\n  }\n\n  setFactoryValue(newValue: any): void {\n    this.#useFactoryValue = true;\n    setField(this.entity, this.fieldName, newValue);\n  }\n\n  [PropertyT] = undefined as any as T;\n}\n\n/** Type guard utility for determining if an entity field is an AsyncReactiveField. */\nexport function isAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return maybe instanceof AsyncReactiveFieldImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded AsyncReactiveField. */\nexport function isLoadedAsyncReactiveField(maybe: any): maybe is ReactiveField<any, any> {\n  return isAsyncReactiveField(maybe) && maybe.isLoaded;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,sBAKd,UAAc,cAAkB,IAAiE;CACjG,OAAO,WAAW,QAAW,cAAc;EACzC,OAAO,IAAI,uBAAuB,QAAQ,WAA+B,UAAU,cAAc,EAAE;CACrG,CAAC;AACH;AAEA,IAAa,yBAAb,cACU,qBAEV;CASW;CAGC;CAXV;CACA;CACA;CACA;CACA,mBAAmB;CAEnB,YACE,QACA,WACA,UACA,cACA,IACA;EACA,MAAM,MAAM;EALL,KAAA,YAAA;EAGC,KAAA,KAAA;EAGR,KAAK,YAAY;EACjB,KAAK,gBAAgB;EACrB,KAAK,UAAU;CACjB;;;;;;;CAQA,IAAI,eAAkC;EAGpC,MAAM,OAAO,kBAAkB,KAAK,SAAS;EAC7C,qBAAqB,MAAM,kBAAkB,KAAK,aAAa,CAAC;EAChE,OAAO;CACT;CAEA,KAAK,MAA8C;EAEjD,OAAQ,KAAK,iBAAiB,KAAK,OAAO,GACvC,SAAS,KAAK,QAAQ,EAAE,MAAM,KAAK,SAAS,CAAQ,CAAC,CACrD,WAAW;GAEV,OAAO,KAAK,mBAAmB,KAAK,aAAa,KAAK,GAAG,KAAK,MAAwB;EACxF,CAAC,CAAC,CACD,MAAM,aAAa;GAClB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;GAC9C,KAAK,eAAe,KAAA;GACpB,KAAK,UAAU;GACf,OAAO;EACT,CAAC,CAAC,CACD,OAAO,MAAM;GAGZ,KAAK,eAAe,KAAA;GACpB,MAAM;EACR,CAAC;CAGL;;CAGA,IAAI,MAAS;EAIX,IAAI,KAAK,OACP,OAAO,KAAK;OAEZ,MAAM,IAAI,MAAM,GAAG,KAAK,UAAU,0BAA0B;CAEhE;CAEA,IAAI,aAAgB;EAClB,OAAO,SAAS,KAAK,QAAQ,KAAK,SAAS;CAC7C;CAEA,IAAI,QAAQ;EACV,OAAO,WAAW,KAAK,QAAQ,KAAK,SAAS;CAC/C;CAEA,IAAI,WAAW;EACb,MAAM,aAAa,SAAS,KAAK,QAAQ,KAAK,QAAQ;EACtD,IAAI,YACF,KAAK,UAAU;EAEjB,OAAO;CACT;CAEA,IAAI,WAAgB;EAElB,MAAM,OAAO,YAAY,KAAK,MAAM;EACpC,OAAQ,KAAK,OAAO,OAAO,wBAAwB,KAAK,eAAe,kBAAkB,MAAM,KAAK,SAAS;CAC/G;CAEA,gBAAgB,UAAqB;EACnC,KAAK,mBAAmB;EACxB,SAAS,KAAK,QAAQ,KAAK,WAAW,QAAQ;CAChD;CAEA,CAAC,aAAa,KAAA;AAChB;;AAGA,SAAgB,qBAAqB,OAA8C;CACjF,OAAO,iBAAiB;AAC1B;;AAGA,SAAgB,2BAA2B,OAA8C;CACvF,OAAO,qBAAqB,KAAK,KAAK,MAAM;AAC9C"}