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

package/build/keys.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.mts","names":[],"sources":["../src/keys.ts"],"mappings":";;;;;;;iBAUgB,qBAAqB;KAMhC;EACH;;EAEA;;;iBAIc,OAAO,UAAU,QAAQ,MAAM,eAAe,IAAI,IAAI,uBAAuB,KAAK;iBAgBlF,0BACd,OAAO,SAAS,gDACf;;iBAKa,YAAY,MAAM,YAAY;iBAC9B,YAAY,MAAM,YAAY;;iBAwC9B,cAAc,MAAM,YAAY,2BAA2B;;iBAM3D,eAAe,MAAM,KAAK;;iBAK1B,mBAAmB;;iBAWnB,WAAW;;iBAEX,WAAW,MAAM,gBAAgB;iBAcjC,iBAAiB;;iBAOjB,WAAW,MAAM,YAAY,IAAI,SAAS;iBAC1C,WAAW,MAAM,YAAY,IAAI,qBAAqB;;iBA0BtD,aAAa,UAAU,QACrC,MAAM,YACN,OAAO,kCACN,IAAI;;iBAKS,MAAM,MAAM,YAAY;iBACxB,MAAM,MAAM,wBAAwB;iBACpC,MAAM,MAAM,YAAY;iBACxB,MAAM,MAAM,wBAAwB;;iBAgCpC,OAAO,MAAM,YAAY;iBACzB,OAAO,MAAM,wBAAwB;iBAQrC,QAAQ,MAAM,YAAY;iBAC1B,QAAQ,MAAM,YAAY;iBAC1B,QAAQ,QAAQ;;iBAQhB,SAAS,MAAM,YAAY;;iBAO3B,eAAe;;iBAcf,UAAU"}
+{"version":3,"file":"keys.d.mts","names":[],"sources":["../src/keys.ts"],"mappings":";;;;;;;wBAUgB,qBAAqB;KAMhC;EACH;;EAEA;;;wBAIc,OAAO,UAAU,QAAQ,MAAM,eAAe,IAAI,IAAI,uBAAuB,KAAK;wBAgBlF,0BACd,OAAO,SAAS,gDACf;;wBAKa,YAAY,MAAM,YAAY;wBAC9B,YAAY,MAAM,YAAY;;wBAwC9B,cAAc,MAAM,YAAY,2BAA2B;;wBAM3D,eAAe,MAAM,KAAK;;wBAK1B,mBAAmB;;wBAWnB,WAAW;;wBAEX,WAAW,MAAM,gBAAgB;wBAcjC,iBAAiB;;wBAOjB,WAAW,MAAM,YAAY,IAAI,SAAS;wBAC1C,WAAW,MAAM,YAAY,IAAI,qBAAqB;;wBA0BtD,aAAa,UAAU,QACrC,MAAM,YACN,OAAO,kCACN,IAAI;;wBAKS,MAAM,MAAM,YAAY;wBACxB,MAAM,MAAM,wBAAwB;wBACpC,MAAM,MAAM,YAAY;wBACxB,MAAM,MAAM,wBAAwB;;wBAgCpC,OAAO,MAAM,YAAY;wBACzB,OAAO,MAAM,wBAAwB;wBAQrC,QAAQ,MAAM,YAAY;wBAC1B,QAAQ,MAAM,YAAY;wBAC1B,QAAQ,QAAQ;;wBAQhB,SAAS,MAAM,YAAY;;wBAO3B,eAAe;;wBAcf,UAAU"}

package/build/loading/HintTree.d.cts

@@ -2,8 +2,8 @@ import { LoadHint } from "./loadHints.cjs";
 import { TaggedId } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/loading/HintTree.d.ts
-type EntityOrId = Entity | TaggedId;
-type HintNode<E extends EntityOrId> = {
+export type EntityOrId = Entity | TaggedId;
+export type HintNode<E extends EntityOrId> = {
   /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */
   entities: Set<E>;
   /** A runtime indication of the type of `E`. */
@@ -36,10 +36,9 @@ type HintNode<E extends EntityOrId> = {
  * Which will let us preload `authors` for all three publishers, but `books` only for the
  * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
  */
-declare function buildHintTree<E extends EntityOrId>(hints: readonly {
+export declare function buildHintTree<E extends EntityOrId>(hints: readonly {
   entity: E;
   hint: LoadHint<any> | undefined;
 }[] | LoadHint<any>): HintNode<E>;
 //#endregion
-export { EntityOrId, HintNode, buildHintTree };
 //# sourceMappingURL=HintTree.d.cts.map

package/build/loading/HintTree.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"HintTree.d.cts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;KASY,aAAa,SAAS;KAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}
+{"version":3,"file":"HintTree.d.cts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;YASY,aAAa,SAAS;YAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}

package/build/loading/HintTree.d.mts

@@ -2,8 +2,8 @@ import { LoadHint } from "./loadHints.mjs";
 import { TaggedId } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/loading/HintTree.d.ts
-type EntityOrId = Entity | TaggedId;
-type HintNode<E extends EntityOrId> = {
+export type EntityOrId = Entity | TaggedId;
+export type HintNode<E extends EntityOrId> = {
   /** These entities are the root entities of our preload, i.e. we use them to trim the tree to prevent over-fetching. */
   entities: Set<E>;
   /** A runtime indication of the type of `E`. */
@@ -36,10 +36,9 @@ type HintNode<E extends EntityOrId> = {
  * Which will let us preload `authors` for all three publishers, but `books` only for the
  * first two, and `reviews` only for the third, i.e. we can prevent over-fetching.
  */
-declare function buildHintTree<E extends EntityOrId>(hints: readonly {
+export declare function buildHintTree<E extends EntityOrId>(hints: readonly {
   entity: E;
   hint: LoadHint<any> | undefined;
 }[] | LoadHint<any>): HintNode<E>;
 //#endregion
-export { EntityOrId, HintNode, buildHintTree };
 //# sourceMappingURL=HintTree.d.mts.map

package/build/loading/HintTree.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"HintTree.d.mts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;KASY,aAAa,SAAS;KAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}
+{"version":3,"file":"HintTree.d.mts","names":[],"sources":["../../src/loading/HintTree.ts"],"mappings":";;;;YASY,aAAa,SAAS;YAEtB,SAAS,UAAU;;EAE7B,UAAU,IAAI;;EAEd;;EAEA;KAAU,cAAc,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0BnB,cAAc,UAAU,YACtC;EAAkB,QAAQ;EAAG,MAAM;MAAgC,gBAClE,SAAS"}

package/build/loading/IsLoadedCache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"IsLoadedCache.cjs","names":["getMetadata","#smartCache","#smartDirtySets","#naiveCache","#naiveDirtySets","#resetDownstreamReactables"],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAOA,uBAAAA,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAKC,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAKC;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAKC,YAAY,SAAS,GAAG,KAAKC;EACtC,KAAKD,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAKD,oBAAoB,KAAK,KAAKE,oBAAoB,GAAG;EAE9D,IAAI,KAAKF,kBAAkB,GACzB,KAAKG,2BAA2BL,uBAAAA,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAKG,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAKA,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAKA,YAAY,MAAM;GACvB,KAAKC;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAKF,oBAAoB,GAAG;GAEhC,MAAM,YAAYF,uBAAAA,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAKC,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAYD,uBAAAA,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAKK,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAKH;GACP;EACF;CACF;AACF"}
+{"version":3,"file":"IsLoadedCache.cjs","names":["getMetadata"],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAOA,uBAAAA,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAK,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAK;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAK,YAAY,SAAS,GAAG,KAAK;EACtC,KAAK,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAK,oBAAoB,KAAK,KAAK,oBAAoB,GAAG;EAE9D,IAAI,KAAK,kBAAkB,GACzB,KAAK,2BAA2BA,uBAAAA,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAK,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAK,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAK,YAAY,MAAM;GACvB,KAAK;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAK,oBAAoB,GAAG;GAEhC,MAAM,YAAYA,uBAAAA,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAK,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAYA,uBAAAA,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAK,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAK;GACP;EACF;CACF;AACF"}

package/build/loading/IsLoadedCache.d.cts

@@ -16,13 +16,13 @@ import { Entity } from "../Entity.cjs";
  * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven
  * cache invalidation whenever relations are mutated (via a hook in `setField`).
  */
-interface IsLoadedCachable {
+export interface IsLoadedCachable {
   entity: Entity;
   fieldName: string;
   isLoaded: boolean;
   resetIsLoaded(): void;
 }
-declare class IsLoadedCache {
+export declare class IsLoadedCache {
   #private;
   /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */
   add(target: IsLoadedCachable): void;
@@ -31,5 +31,4 @@ declare class IsLoadedCache {
   resetIsLoaded(entity: Entity, fieldName: string): void;
 }
 //#endregion
-export { IsLoadedCachable, IsLoadedCache };
 //# sourceMappingURL=IsLoadedCache.d.cts.map

package/build/loading/IsLoadedCache.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"IsLoadedCache.d.cts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAmBiB;EACf,QAAQ;EACR;EACA;EACA;;cAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}
+{"version":3,"file":"IsLoadedCache.d.cts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAmBiB;EACf,QAAQ;EACR;EACA;EACA;;qBAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}

package/build/loading/IsLoadedCache.d.mts

@@ -16,13 +16,13 @@ import { Entity } from "../Entity.mjs";
  * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven
  * cache invalidation whenever relations are mutated (via a hook in `setField`).
  */
-interface IsLoadedCachable {
+export interface IsLoadedCachable {
   entity: Entity;
   fieldName: string;
   isLoaded: boolean;
   resetIsLoaded(): void;
 }
-declare class IsLoadedCache {
+export declare class IsLoadedCache {
   #private;
   /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */
   add(target: IsLoadedCachable): void;
@@ -31,5 +31,4 @@ declare class IsLoadedCache {
   resetIsLoaded(entity: Entity, fieldName: string): void;
 }
 //#endregion
-export { IsLoadedCachable, IsLoadedCache };
 //# sourceMappingURL=IsLoadedCache.d.mts.map

package/build/loading/IsLoadedCache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"IsLoadedCache.d.mts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;UAmBiB;EACf,QAAQ;EACR;EACA;EACA;;cAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}
+{"version":3,"file":"IsLoadedCache.d.mts","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"mappings":";;;;;;;;;;;;;;;;;;iBAmBiB;EACf,QAAQ;EACR;EACA;EACA;;qBAGW;;;EAcX,IAAI,QAAQ;EASZ,SAAS,QAAQ;;EAMjB,cAAc,QAAQ,QAAQ"}

package/build/loading/IsLoadedCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"IsLoadedCache.js","names":["#smartCache","#smartDirtySets","#naiveCache","#naiveDirtySets","#resetDownstreamReactables"],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAO,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAKA,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAKC;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAKC,YAAY,SAAS,GAAG,KAAKC;EACtC,KAAKD,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAKD,oBAAoB,KAAK,KAAKE,oBAAoB,GAAG;EAE9D,IAAI,KAAKF,kBAAkB,GACzB,KAAKG,2BAA2B,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAKF,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAKA,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAKA,YAAY,MAAM;GACvB,KAAKC;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAKF,oBAAoB,GAAG;GAEhC,MAAM,YAAY,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAKD,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAY,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAKI,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAKH;GACP;EACF;CACF;AACF"}
+{"version":3,"file":"IsLoadedCache.js","names":[],"sources":["../../src/loading/IsLoadedCache.ts"],"sourcesContent":["import type { Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Interface for our relations that have dynamic & expensive `isLoaded` checks.\n *\n * ...and also `OneToManyCollection.get` calls.\n *\n * The primary m2o/o2m/m2m relations all have trivial `isLoaded` checks--are they\n * loaded or not.\n *\n * But for \"composite relations\", i.e. a ReactiveField or ReactiveRelation whose\n * \"load-ness\" is calculated by evaluating its load hint across a subgraph of entities\n * & relations, load-ness can be more dynamic true-then-false, as its subgraph changes.\n *\n * To avoid performance issues (see https://github.com/joist-orm/joist-orm/issues/1166),\n * we cache this dynamic/expensive `isLoaded` checks, and then do targeted, reactivity-driven\n * cache invalidation whenever relations are mutated (via a hook in `setField`).\n */\nexport interface IsLoadedCachable {\n  entity: Entity;\n  fieldName: string;\n  isLoaded: boolean;\n  resetIsLoaded(): void;\n}\n\nexport class IsLoadedCache {\n  // Cache of `{ tag -> { fieldName -> Set<IsLoadedCachable> } }` to hold derived relations\n  // we can selectively invalidate by walking from the mutated field to any downstream\n  // cacheables.\n  #smartCache: Record<string, Record<string, Set<IsLoadedCachable>>> = {};\n  // A dumb cache for things that are hard selectively invalidate (o2m.get, recursive collections,\n  // and custom references/collections), so any mutation resets these.\n  #naiveCache = new Set<IsLoadedCachable>();\n  // Counter to skip reactive hint walking when no smart cache sets are populated.\n  #smartDirtySets = 0;\n  // Counter to fast-path resetIsLoaded when the naive cache is empty.\n  #naiveDirtySets = 0;\n\n  /** Adds a ReactiveField/Relation/Collection to be invalidated when its dependencies change. */\n  add(target: IsLoadedCachable): void {\n    const meta = getMetadata(target.entity);\n    const set = ((this.#smartCache[meta.tagName] ??= {})[target.fieldName] ??= new Set());\n    if (set.size === 0) {\n      this.#smartDirtySets++;\n    }\n    set.add(target);\n  }\n\n  addNaive(target: IsLoadedCachable): void {\n    if (this.#naiveCache.size === 0) this.#naiveDirtySets++;\n    this.#naiveCache.add(target);\n  }\n\n  /** Resets any in-memory #isLoaded/#isCached caches that depend on `entity.fieldName`. */\n  resetIsLoaded(entity: Entity, fieldName: string): void {\n    if (this.#smartDirtySets === 0 && this.#naiveDirtySets === 0) return;\n    // Reset caches that we can deterministically find by walking the reactivity hints\n    if (this.#smartDirtySets > 0) {\n      this.#resetDownstreamReactables(getMetadata(entity), fieldName);\n    }\n    // We could use this to invalidate m2o.get, but it doesn't work for collections\n    // with an orderBy, when the orderBy changes, so for now we use the blunt naiveCache.\n    // const field = meta.allFields[fieldName];\n    // if (field.kind === \"m2o\") {\n    //   const otherMeta = field.otherMetadata();\n    //   const set = this.smartCache[otherMeta.tagName]?.[field.otherFieldName];\n    //   if (set) {\n    //     for (const target of set) target.resetIsLoaded();\n    //     set.clear();\n    //   }\n    // }\n    if (this.#naiveCache.size > 0) {\n      for (const target of this.#naiveCache.values()) target.resetIsLoaded();\n      this.#naiveCache.clear();\n      this.#naiveDirtySets--;\n    }\n  }\n\n  /**\n   * Given a `meta+field`, statically find all downstream Reactables, and if any of those\n   * Reactables are a) in-memory already, and b) registered themselves as cached,\n   * tell them to reset.\n   */\n  #resetDownstreamReactables(meta: EntityMetadata, fieldName: string): void {\n    // These are reactables in other entities that are watching/reacting to this entity/fieldName\n    const reactables = meta.reactablesIncludingReadOnlyByField!.get(fieldName);\n    if (reactables === undefined) return;\n    for (const r of reactables) {\n      if (this.#smartDirtySets === 0) return;\n      // I.e. we've written to Author.firstName, and this reactable in Book/otherMeta depends on it\n      const otherMeta = getMetadata(r.cstr);\n      // Find any cache entries for this cstr + name\n      const set = this.#smartCache[otherMeta.tagName]?.[r.name];\n      if (set?.size > 0) {\n        for (const target of set) {\n          target.resetIsLoaded();\n          // Is this target itself a RF/RR? If so, transitively reset its cache as well.\n          const otherMeta = getMetadata(target.entity);\n          const otherField = otherMeta.allFields[target.fieldName];\n          if (\"derived\" in otherField && otherField.derived) {\n            this.#resetDownstreamReactables(otherMeta, otherField.fieldName);\n          }\n        }\n        set.clear();\n        this.#smartDirtySets--;\n      }\n    }\n  }\n}\n"],"mappings":";;AA0BA,IAAa,gBAAb,MAA2B;CAIzB,cAAqE,CAAC;CAGtE,8BAAc,IAAI,IAAsB;CAExC,kBAAkB;CAElB,kBAAkB;;CAGlB,IAAI,QAAgC;EAClC,MAAM,OAAO,YAAY,OAAO,MAAM;EACtC,MAAM,MAAO,CAAC,KAAK,YAAY,KAAK,aAAa,CAAC,EAAA,CAAG,OAAO,+BAAe,IAAI,IAAI;EACnF,IAAI,IAAI,SAAS,GACf,KAAK;EAEP,IAAI,IAAI,MAAM;CAChB;CAEA,SAAS,QAAgC;EACvC,IAAI,KAAK,YAAY,SAAS,GAAG,KAAK;EACtC,KAAK,YAAY,IAAI,MAAM;CAC7B;;CAGA,cAAc,QAAgB,WAAyB;EACrD,IAAI,KAAK,oBAAoB,KAAK,KAAK,oBAAoB,GAAG;EAE9D,IAAI,KAAK,kBAAkB,GACzB,KAAK,2BAA2B,YAAY,MAAM,GAAG,SAAS;EAahE,IAAI,KAAK,YAAY,OAAO,GAAG;GAC7B,KAAK,MAAM,UAAU,KAAK,YAAY,OAAO,GAAG,OAAO,cAAc;GACrE,KAAK,YAAY,MAAM;GACvB,KAAK;EACP;CACF;;;;;;CAOA,2BAA2B,MAAsB,WAAyB;EAExE,MAAM,aAAa,KAAK,mCAAoC,IAAI,SAAS;EACzE,IAAI,eAAe,KAAA,GAAW;EAC9B,KAAK,MAAM,KAAK,YAAY;GAC1B,IAAI,KAAK,oBAAoB,GAAG;GAEhC,MAAM,YAAY,YAAY,EAAE,IAAI;GAEpC,MAAM,MAAM,KAAK,YAAY,UAAU,QAAQ,GAAG,EAAE;GACpD,IAAI,KAAK,OAAO,GAAG;IACjB,KAAK,MAAM,UAAU,KAAK;KACxB,OAAO,cAAc;KAErB,MAAM,YAAY,YAAY,OAAO,MAAM;KAC3C,MAAM,aAAa,UAAU,UAAU,OAAO;KAC9C,IAAI,aAAa,cAAc,WAAW,SACxC,KAAK,2BAA2B,WAAW,WAAW,SAAS;IAEnE;IACA,IAAI,MAAM;IACV,KAAK;GACP;EACF;CACF;AACF"}

package/build/loading/loadHints.d.cts

@@ -18,7 +18,7 @@ type DeepLoadHint<T extends Entity> = NestedLoadHint<T> & {
 };
 type MaybeBaseType = any;
 /** Marks a given `T[K]` field as the loaded/synchronous version of the collection. */
-type MarkLoaded<T extends Entity, P, UH = {}> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, UH>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, UH>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, UH>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, UH>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, UH> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, UH>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
+export type MarkLoaded<T extends Entity, P, UH = {}> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, UH>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, UH>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, UH>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, UH>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, UH> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, UH>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
 /** A version of MarkLoaded the uses `DeepLoadHint` for tests. */
 type MarkDeepLoaded<T extends Entity, P> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, DeepLoadHint<U>>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, DeepLoadHint<U>>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, DeepLoadHint<U>>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, DeepLoadHint<U>>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
 /**
@@ -42,14 +42,14 @@ type MaybeUseOptsType<T extends Entity, O, K extends keyof T & keyof O> = O[K] e
  * `O` is the generic from the call site so that if the caller passes `{ author: SomeLoadedAuthor }`,
  * we'll prefer that type, as it might have more nested load hints that we can't otherwise assume.
  */
-type New<T extends Entity, O extends OptsOf<T> = OptsOf<T>> = T & { [K in keyof T]: K extends keyof O ? MaybeUseOptsType<T, O, K> : MarkLoaded<T, T[K]>; };
+export type New<T extends Entity, O extends OptsOf<T> = OptsOf<T>> = T & { [K in keyof T]: K extends keyof O ? MaybeUseOptsType<T, O, K> : MarkLoaded<T, T[K]>; };
 /**
  * Marks all references/collections of `T` as deeply loaded, which is only useful for
  * tests where we can have "the whole object graph" in-memory.
  */
-type DeepNew<T extends Entity> = Loaded<T, DeepLoadHint<T>>;
+export type DeepNew<T extends Entity> = Loaded<T, DeepLoadHint<T>>;
 /** Detects whether an entity is newly created, and so we can treat all the relations as loaded. */
-declare function isNew<T extends Entity>(e: T): e is New<T>;
+export declare function isNew<T extends Entity>(e: T): e is New<T>;
 /**
  * All the loadable fields, i.e. relations or lazy-loaded/async properties, in an entity.
  *
@@ -57,7 +57,7 @@ declare function isNew<T extends Entity>(e: T): e is New<T>;
  * fields that have be added to the entity classes, i.e. `Author.numberOfBooks2` async
  * properties.
  */
-type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K]> extends never ? never : K]: LoadableValue<T[K]>; };
+export type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K]> extends never ? never : K]: LoadableValue<T[K]>; };
 /**
  * Given an entity field/value, return the loadable entity.
  *
@@ -66,7 +66,7 @@ type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K
  * Note that we usually return entities, but for AsyncProperties it could be
  * a calculated primitive value like number or string.
  */
-type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends Reference<any, infer U, any> ? U : V extends Collection<any, infer U> ? U : V extends ReadOnlyCollection<any, infer U> ? U : V extends AsyncMethod<any, any, infer V> ? V : V extends Property<any, infer P> ? P extends (infer U extends Entity) | undefined ? U : P : never;
+export type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends Reference<any, infer U, any> ? U : V extends Collection<any, infer U> ? U : V extends ReadOnlyCollection<any, infer U> ? U : V extends AsyncMethod<any, any, infer V> ? V : V extends Property<any, infer P> ? P extends (infer U extends Entity) | undefined ? U : P : never;
 /**
  *  A load hint of a single key, multiple keys, or nested keys and sub-hints.
  *
@@ -74,12 +74,12 @@ type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends R
  * collections, and async properties to preload (like `Book.author` or `Author.books`), and
  * do not include any primitive fields (like `Author.firstName`).
  */
-type LoadHint<T extends Entity> = (keyof Loadable<T> & string) | ReadonlyArray<keyof Loadable<T> & string> | NestedLoadHint<T>;
-type NestedLoadHint<T extends Entity> = { [K in keyof Loadable<T>]?: Loadable<T>[K] extends (infer U extends Entity) ? LoadHint<U> : {}; };
+export type LoadHint<T extends Entity> = (keyof Loadable<T> & string) | ReadonlyArray<keyof Loadable<T> & string> | NestedLoadHint<T>;
+export type NestedLoadHint<T extends Entity> = { [K in keyof Loadable<T>]?: Loadable<T>[K] extends (infer U extends Entity) ? LoadHint<U> : {}; };
 /** Given an entity `T` that is being populated with hints `H`, marks the `H` attributes as populated. */
-type Loaded<T extends Entity, H> = T & { [K in keyof T & keyof NormalizeHint<H>]: H extends DeepLoadHint<T> ? MarkDeepLoaded<T, T[K]> : MarkLoaded<T, T[K], NormalizeHint<H>[K]>; };
+export type Loaded<T extends Entity, H> = T & { [K in keyof T & keyof NormalizeHint<H>]: H extends DeepLoadHint<T> ? MarkDeepLoaded<T, T[K]> : MarkLoaded<T, T[K], NormalizeHint<H>[K]>; };
 /** Recursively checks if the relations from a load hint are loaded on an entity. */
-declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
+export declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
 /**
  * Recursively checks if a relation-only populate hint is loaded on an entity.
  *
@@ -88,29 +88,29 @@ declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hi
  * Treating those primitive leaves as loaded would let `EntityManager.populate` skip the batchloader path and change
  * reactive recalculation ordering, so the populate fast-path only applies to true relation populate hints.
  */
-declare function isLoadedForPopulate<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
-declare function maybePopulateThen<T extends Entity, H extends LoadHint<T>, R>(entity: T, hint: H, fn: (loaded: Loaded<T, H>) => R): MaybePromise<R>;
+export declare function isLoadedForPopulate<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
+export declare function maybePopulateThen<T extends Entity, H extends LoadHint<T>, R>(entity: T, hint: H, fn: (loaded: Loaded<T, H>) => R): MaybePromise<R>;
 /**
  * Runtime checks that `entity` has `hint` loaded, and type guards it as a `Loaded<T, hint>`.
  *
  * Similar to `ensureLoaded`, although `ensureLoaded` returns its value.
  */
-declare function assertLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): asserts entity is Loaded<T, H>;
+export declare function assertLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): asserts entity is Loaded<T, H>;
 /**
  * Runtime checks that `entity` has `hint` loaded, and returns it as a `Loaded<T, entity>`.
  *
  * Similar to `assertLoaded`, although `assertLoaded` is a boolean type guard.
  */
-declare function ensureLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
+export declare function ensureLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
 /**
  * Unsafe type check for `entity` to `hint`, *without* a runtime type check.
  *
  * You should only use this if you're extremely sure that entity has hint loaded.
  */
-declare function unsafeLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
+export declare function unsafeLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
 /** From any `Relations` field in `T`, i.e. for loader hints. */
-type RelationsIn<T extends Entity> = SubType<T, Relation<any, any>>;
+export type RelationsIn<T extends Entity> = SubType<T, Relation<any, any>>;
 type SubType<T, C> = Pick<T, { [K in keyof T]: T[K] extends C ? K : never; }[keyof T]>;
 //#endregion
-export { DeepNew, LoadHint, Loadable, LoadableValue, Loaded, MarkLoaded, NestedLoadHint, New, RelationsIn, assertLoaded, ensureLoaded, isLoaded, isLoadedForPopulate, isNew, maybePopulateThen, unsafeLoaded };
+export {};
 //# sourceMappingURL=loadHints.d.cts.map

package/build/loading/loadHints.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"loadHints.d.cts","names":[],"sources":["../../src/loading/loadHints.ts"],"mappings":"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"}
+{"version":3,"file":"loadHints.d.cts","names":[],"sources":["../../src/loading/loadHints.ts"],"mappings":"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"}

package/build/loading/loadHints.d.mts

@@ -18,7 +18,7 @@ type DeepLoadHint<T extends Entity> = NestedLoadHint<T> & {
 };
 type MaybeBaseType = any;
 /** Marks a given `T[K]` field as the loaded/synchronous version of the collection. */
-type MarkLoaded<T extends Entity, P, UH = {}> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, UH>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, UH>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, UH>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, UH>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, UH> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, UH>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
+export type MarkLoaded<T extends Entity, P, UH = {}> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, UH>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, UH>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, UH>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, UH>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, UH> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, UH>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
 /** A version of MarkLoaded the uses `DeepLoadHint` for tests. */
 type MarkDeepLoaded<T extends Entity, P> = P extends EnumCollection<MaybeBaseType, infer E> ? LoadedEnumCollection<T, E> : P extends OneToOneReference<MaybeBaseType, infer U> ? LoadedOneToOneReference<T, Loaded<U, DeepLoadHint<U>>> : P extends Reference<MaybeBaseType, infer U, infer N> ? LoadedReference<T, Loaded<U, DeepLoadHint<U>>, N> : P extends Collection<MaybeBaseType, infer U> ? LoadedCollection<T, Loaded<U, DeepLoadHint<U>>> : P extends ReadOnlyCollection<MaybeBaseType, infer U> ? LoadedReadOnlyCollection<T, Loaded<U, DeepLoadHint<U>>> : P extends Property<MaybeBaseType, infer V> ? [V] extends [(infer U extends Entity) | undefined] ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>> | Exclude<V, U>> : V extends readonly (infer U extends Entity)[] ? LoadedProperty<T, Loaded<U, DeepLoadHint<U>>[]> : LoadedProperty<T, V> : P extends AsyncMethod<T, infer A, infer V> ? LoadedMethod<T, A, V> : unknown;
 /**
@@ -42,14 +42,14 @@ type MaybeUseOptsType<T extends Entity, O, K extends keyof T & keyof O> = O[K] e
  * `O` is the generic from the call site so that if the caller passes `{ author: SomeLoadedAuthor }`,
  * we'll prefer that type, as it might have more nested load hints that we can't otherwise assume.
  */
-type New<T extends Entity, O extends OptsOf<T> = OptsOf<T>> = T & { [K in keyof T]: K extends keyof O ? MaybeUseOptsType<T, O, K> : MarkLoaded<T, T[K]>; };
+export type New<T extends Entity, O extends OptsOf<T> = OptsOf<T>> = T & { [K in keyof T]: K extends keyof O ? MaybeUseOptsType<T, O, K> : MarkLoaded<T, T[K]>; };
 /**
  * Marks all references/collections of `T` as deeply loaded, which is only useful for
  * tests where we can have "the whole object graph" in-memory.
  */
-type DeepNew<T extends Entity> = Loaded<T, DeepLoadHint<T>>;
+export type DeepNew<T extends Entity> = Loaded<T, DeepLoadHint<T>>;
 /** Detects whether an entity is newly created, and so we can treat all the relations as loaded. */
-declare function isNew<T extends Entity>(e: T): e is New<T>;
+export declare function isNew<T extends Entity>(e: T): e is New<T>;
 /**
  * All the loadable fields, i.e. relations or lazy-loaded/async properties, in an entity.
  *
@@ -57,7 +57,7 @@ declare function isNew<T extends Entity>(e: T): e is New<T>;
  * fields that have be added to the entity classes, i.e. `Author.numberOfBooks2` async
  * properties.
  */
-type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K]> extends never ? never : K]: LoadableValue<T[K]>; };
+export type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K]> extends never ? never : K]: LoadableValue<T[K]>; };
 /**
  * Given an entity field/value, return the loadable entity.
  *
@@ -66,7 +66,7 @@ type Loadable<T extends Entity> = { -readonly [K in keyof T as LoadableValue<T[K
  * Note that we usually return entities, but for AsyncProperties it could be
  * a calculated primitive value like number or string.
  */
-type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends Reference<any, infer U, any> ? U : V extends Collection<any, infer U> ? U : V extends ReadOnlyCollection<any, infer U> ? U : V extends AsyncMethod<any, any, infer V> ? V : V extends Property<any, infer P> ? P extends (infer U extends Entity) | undefined ? U : P : never;
+export type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends Reference<any, infer U, any> ? U : V extends Collection<any, infer U> ? U : V extends ReadOnlyCollection<any, infer U> ? U : V extends AsyncMethod<any, any, infer V> ? V : V extends Property<any, infer P> ? P extends (infer U extends Entity) | undefined ? U : P : never;
 /**
  *  A load hint of a single key, multiple keys, or nested keys and sub-hints.
  *
@@ -74,12 +74,12 @@ type LoadableValue<V> = V extends EnumCollection<any, infer E> ? E : V extends R
  * collections, and async properties to preload (like `Book.author` or `Author.books`), and
  * do not include any primitive fields (like `Author.firstName`).
  */
-type LoadHint<T extends Entity> = (keyof Loadable<T> & string) | ReadonlyArray<keyof Loadable<T> & string> | NestedLoadHint<T>;
-type NestedLoadHint<T extends Entity> = { [K in keyof Loadable<T>]?: Loadable<T>[K] extends (infer U extends Entity) ? LoadHint<U> : {}; };
+export type LoadHint<T extends Entity> = (keyof Loadable<T> & string) | ReadonlyArray<keyof Loadable<T> & string> | NestedLoadHint<T>;
+export type NestedLoadHint<T extends Entity> = { [K in keyof Loadable<T>]?: Loadable<T>[K] extends (infer U extends Entity) ? LoadHint<U> : {}; };
 /** Given an entity `T` that is being populated with hints `H`, marks the `H` attributes as populated. */
-type Loaded<T extends Entity, H> = T & { [K in keyof T & keyof NormalizeHint<H>]: H extends DeepLoadHint<T> ? MarkDeepLoaded<T, T[K]> : MarkLoaded<T, T[K], NormalizeHint<H>[K]>; };
+export type Loaded<T extends Entity, H> = T & { [K in keyof T & keyof NormalizeHint<H>]: H extends DeepLoadHint<T> ? MarkDeepLoaded<T, T[K]> : MarkLoaded<T, T[K], NormalizeHint<H>[K]>; };
 /** Recursively checks if the relations from a load hint are loaded on an entity. */
-declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
+export declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
 /**
  * Recursively checks if a relation-only populate hint is loaded on an entity.
  *
@@ -88,29 +88,29 @@ declare function isLoaded<T extends Entity, H extends LoadHint<T>>(entity: T, hi
  * Treating those primitive leaves as loaded would let `EntityManager.populate` skip the batchloader path and change
  * reactive recalculation ordering, so the populate fast-path only applies to true relation populate hints.
  */
-declare function isLoadedForPopulate<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
-declare function maybePopulateThen<T extends Entity, H extends LoadHint<T>, R>(entity: T, hint: H, fn: (loaded: Loaded<T, H>) => R): MaybePromise<R>;
+export declare function isLoadedForPopulate<T extends Entity, H extends LoadHint<T>>(entity: T, hint: H): entity is Loaded<T, H>;
+export declare function maybePopulateThen<T extends Entity, H extends LoadHint<T>, R>(entity: T, hint: H, fn: (loaded: Loaded<T, H>) => R): MaybePromise<R>;
 /**
  * Runtime checks that `entity` has `hint` loaded, and type guards it as a `Loaded<T, hint>`.
  *
  * Similar to `ensureLoaded`, although `ensureLoaded` returns its value.
  */
-declare function assertLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): asserts entity is Loaded<T, H>;
+export declare function assertLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): asserts entity is Loaded<T, H>;
 /**
  * Runtime checks that `entity` has `hint` loaded, and returns it as a `Loaded<T, entity>`.
  *
  * Similar to `assertLoaded`, although `assertLoaded` is a boolean type guard.
  */
-declare function ensureLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
+export declare function ensureLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
 /**
  * Unsafe type check for `entity` to `hint`, *without* a runtime type check.
  *
  * You should only use this if you're extremely sure that entity has hint loaded.
  */
-declare function unsafeLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
+export declare function unsafeLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): Loaded<T, H>;
 /** From any `Relations` field in `T`, i.e. for loader hints. */
-type RelationsIn<T extends Entity> = SubType<T, Relation<any, any>>;
+export type RelationsIn<T extends Entity> = SubType<T, Relation<any, any>>;
 type SubType<T, C> = Pick<T, { [K in keyof T]: T[K] extends C ? K : never; }[keyof T]>;
 //#endregion
-export { DeepNew, LoadHint, Loadable, LoadableValue, Loaded, MarkLoaded, NestedLoadHint, New, RelationsIn, assertLoaded, ensureLoaded, isLoaded, isLoadedForPopulate, isNew, maybePopulateThen, unsafeLoaded };
+export {};
 //# sourceMappingURL=loadHints.d.mts.map

package/build/loading/loadHints.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"loadHints.d.mts","names":[],"sources":["../../src/loading/loadHints.ts"],"mappings":"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"}
+{"version":3,"file":"loadHints.d.mts","names":[],"sources":["../../src/loading/loadHints.ts"],"mappings":"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"}

package/build/loading/loadLens.d.cts

@@ -33,7 +33,7 @@ type DropUndefined<T> = Exclude<T, undefined>;
  * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a
  * list at any point in the lens navigation path.
  */
-type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
+export type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
 /**
  * Allows declaratively loading/traversing several layers of references at once.
  *
@@ -43,35 +43,35 @@ type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<Ma
  * const publisher = await book.load(b => b.author.publisher);
  * ```
  */
-declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
+export declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
   forceReload?: boolean;
   sql?: boolean;
 }): Promise<V>;
 /** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
-declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
+export declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
   forceReload?: boolean;
   sql?: boolean;
 }): Promise<V>;
-declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
-declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
+export declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
+export declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
 /**
  * The synchronous version of `loadLens`.
  *
  * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
  */
-declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
+export declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
 /** Synchronously traverses a precomputed lens path. */
-declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
+export declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
 /** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */
-declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
+export declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
 /** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
-declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
+export declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
 /** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */
-declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
+export declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
 /** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */
-declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
+export declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
 /** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */
-declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
+export declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
 //#endregion
-export { Lens, getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+export {};
 //# sourceMappingURL=loadLens.d.cts.map

package/build/loading/loadLens.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"loadLens.d.cts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}
+{"version":3,"file":"loadLens.d.cts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;YAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;wBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;wBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;wBA8FK,cAAc,MAAM,gBAAgB;wBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;wBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;wBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;wBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;wBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;wBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;wBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;wBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}

package/build/loading/loadLens.d.mts

@@ -33,7 +33,7 @@ type DropUndefined<T> = Exclude<T, undefined>;
  * `R` is either a `T` or `T[]` or `T | undefined` and just captures whether we've hit a
  * list at any point in the lens navigation path.
  */
-type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
+export type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : T[P] extends PromiseFnLike<infer U> ? Lens<MaybeDropArray<DropUndefined<U>>, MaybeArray<R, U>> : Lens<MaybeDropArray<DropUndefined<T[P]>>, MaybeArray<R, T[P]>>; };
 /**
  * Allows declaratively loading/traversing several layers of references at once.
  *
@@ -43,35 +43,35 @@ type Lens<T, R = T> = { [P in keyof T]: T[P] extends LoadLike<infer U> ? Lens<Ma
  * const publisher = await book.load(b => b.author.publisher);
  * ```
  */
-declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
+export declare function loadLens<T extends Entity, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>, opts?: {
   forceReload?: boolean;
   sql?: boolean;
 }): Promise<V>;
 /** Loads a precomputed lens path, avoiding repeated lambda/proxy evaluation for long-lived relation declarations. */
-declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
+export declare function loadLensPath<T extends Entity, V>(start: T | readonly T[], paths: string[], opts?: {
   forceReload?: boolean;
   sql?: boolean;
 }): Promise<V>;
-declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
-declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
+export declare function isAllSqlPaths(meta: EntityMetadata, paths: string[]): boolean;
+export declare function mapPathsToTarget(source: EntityMetadata, paths: string[]): [EntityMetadata, [EntityMetadata, Field][]];
 /**
  * The synchronous version of `loadLens`.
  *
  * This assumes you've first evaluated the lens with `loadLens` and now can access it synchronously.
  */
-declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
+export declare function getLens<T, U, V>(startMeta: EntityMetadata, start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): V;
 /** Synchronously traverses a precomputed lens path. */
-declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
+export declare function getLensPath<T, V>(startMeta: EntityMetadata, start: T | readonly T[], paths: string[]): V;
 /** Returns whether a lens is loaded; primarily for deeply loaded instances in tests. */
-declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
+export declare function isLensLoaded<T, U, V>(start: T | readonly T[], fn: (lens: Lens<T>) => Lens<U, V>): boolean;
 /** Returns whether a precomputed lens path is loaded; primarily for deeply loaded instances in tests. */
-declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
+export declare function isLensLoadedPath<T>(start: T | readonly T[], paths: string[]): boolean;
 /** Accepts a lens like `a => a.books.reviews` and returns a hint like `{ books: { reviews: {} } }`. */
-declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
+export declare function lensToLoadHint<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): LoadHint<T>;
 /** Accepts lens paths like `[books, reviews]` and returns a hint like `{ books: { reviews: {} } }`. */
-declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
+export declare function lensPathToLoadHint<T extends Entity>(paths: string[]): LoadHint<T>;
 /** Accepts a lens like `a => a.books.reviews` and returns the paths like `[books, reviews]`. */
-declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
+export declare function lensToPath<T extends Entity, U, V>(fn: (lens: Lens<T>) => Lens<U, V>): string[];
 //#endregion
-export { Lens, getLens, getLensPath, isAllSqlPaths, isLensLoaded, isLensLoadedPath, lensPathToLoadHint, lensToLoadHint, lensToPath, loadLens, loadLensPath, mapPathsToTarget };
+export {};
 //# sourceMappingURL=loadLens.d.mts.map

package/build/loading/loadLens.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"loadLens.d.mts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;KAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;iBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;iBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;iBA8FK,cAAc,MAAM,gBAAgB;iBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;iBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;iBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;iBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;iBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;iBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;iBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;iBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}
+{"version":3,"file":"loadLens.d.mts","names":[],"sources":["../../src/loading/loadLens.ts"],"mappings":";;;;;KAkBK,SAAS;EAAO,QAAQ,QAAQ;;;KAGhC,cAAc,WAAW,YAAY;;;;;;;;;;;;;KAiBrC,WAAW,GAAG,KACjB,UAAU,sBACL,YAAY,oBAAoB,MAC/B,cAAc,OACd,cAAc,OAChB,UAAU,qBACR,KACC,yBACC,gBACA;;KAKL,eAAe,KAAK,UAAU,oBAAoB,KAAK,IAAI;KAE3D,cAAc,KAAK,QAAQ;;;;;;;;;;YAWpB,KAAK,GAAG,IAAI,QACrB,WAAW,IAAI,EAAE,WAAW,eAAe,KACxC,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,EAAE,WAAW,oBAAoB,KAC/B,KAAK,eAAe,cAAc,KAAK,WAAW,GAAG,MACrD,KAAK,eAAe,cAAc,EAAE,MAAM,WAAW,GAAG,EAAE;;;;;;;;;;wBAe5C,SAAS,UAAU,QAAQ,GAAG,GAClD,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,IAC/B;EAAQ;EAAuB;IAC9B,QAAQ;;wBAKK,aAAa,UAAU,QAAQ,GAC7C,OAAO,aAAa,KACpB,iBACA;EAAQ;EAAuB;IAC9B,QAAQ;wBA8FK,cAAc,MAAM,gBAAgB;wBAapC,iBAAiB,QAAQ,gBAAgB,mBAAmB,iBAAiB,gBAAgB;;;;;;wBAkC7F,QAAQ,GAAG,GAAG,GAC5B,WAAW,gBACX,OAAO,aAAa,KACpB,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAC9B;;wBAKa,YAAY,GAAG,GAAG,WAAW,gBAAgB,OAAO,aAAa,KAAK,kBAAkB;;wBAqDxF,aAAa,GAAG,GAAG,GAAG,OAAO,aAAa,KAAK,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG;;wBAK9E,iBAAiB,GAAG,OAAO,aAAa,KAAK;;wBAgC7C,eAAe,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG,KAAK,SAAS;;wBAKpF,mBAAmB,UAAU,QAAQ,kBAAkB,SAAS;;wBAUhE,WAAW,UAAU,QAAQ,GAAG,GAAG,KAAK,MAAM,KAAK,OAAO,KAAK,GAAG"}