joist-core 2.4.0-next.4 → 2.4.0-next.41

package/build/PluginManager.d.cts

@@ -62,12 +62,12 @@ declare const emsSymbol: unique symbol;
  * Plugins can implement any of the PluginMethods to intercept entity operations
  * and are automatically registered with the EntityManager when added via PluginManager.
  */
-declare abstract class Plugin {
+export declare abstract class Plugin {
   [emsSymbol]: WeakRef<EntityManager>[];
   maybeCloneForNewEm(): this | undefined;
   get ems(): readonly EntityManager[];
 }
-interface Plugin extends PluginMethods {}
+export interface Plugin extends PluginMethods {}
 /**
  * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
  *
@@ -75,7 +75,7 @@ interface Plugin extends PluginMethods {}
  * for callbacks that have at least one registered plugin, making unused plugin hooks
  * zero-cost at runtime.
  */
-declare class PluginManager implements Required<PluginMethods> {
+export declare class PluginManager implements Required<PluginMethods> {
   #private;
   readonly em: EntityManager;
   constructor(em: EntityManager);
@@ -108,5 +108,5 @@ declare class PluginManager implements Required<PluginMethods> {
   afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
 }
 //#endregion
-export { Plugin, PluginManager };
+export {};
 //# sourceMappingURL=PluginManager.d.cts.map

package/build/PluginManager.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.d.cts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;uBAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;UASL,eAAe;;;;;;;;cASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}
+{"version":3,"file":"PluginManager.d.cts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;8BAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;iBASL,eAAe;;;;;;;;qBASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}

package/build/PluginManager.d.mts

@@ -62,12 +62,12 @@ declare const emsSymbol: unique symbol;
  * Plugins can implement any of the PluginMethods to intercept entity operations
  * and are automatically registered with the EntityManager when added via PluginManager.
  */
-declare abstract class Plugin {
+export declare abstract class Plugin {
   [emsSymbol]: WeakRef<EntityManager>[];
   maybeCloneForNewEm(): this | undefined;
   get ems(): readonly EntityManager[];
 }
-interface Plugin extends PluginMethods {}
+export interface Plugin extends PluginMethods {}
 /**
  * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.
  *
@@ -75,7 +75,7 @@ interface Plugin extends PluginMethods {}
  * for callbacks that have at least one registered plugin, making unused plugin hooks
  * zero-cost at runtime.
  */
-declare class PluginManager implements Required<PluginMethods> {
+export declare class PluginManager implements Required<PluginMethods> {
   #private;
   readonly em: EntityManager;
   constructor(em: EntityManager);
@@ -108,5 +108,5 @@ declare class PluginManager implements Required<PluginMethods> {
   afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;
 }
 //#endregion
-export { Plugin, PluginManager };
+export {};
 //# sourceMappingURL=PluginManager.d.mts.map

package/build/PluginManager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.d.mts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;uBAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;UASL,eAAe;;;;;;;;cASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}
+{"version":3,"file":"PluginManager.d.mts","names":[],"sources":["../src/PluginManager.ts"],"mappings":";;;;;;;UAOU;;;;;;;EAOR,gBAAgB,QAAQ,QAAQ;;;;;;;;EAQhC,gBAAgB,QAAQ,QAAQ,eAAe;;;;;;;;;EAS/C,YACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;;;;;;;;;;;;;;EAgBJ,WAAW,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAEjE,gBAAgB,mBAAmB,WAAW;EAE9C,eAAe,mBAAmB,WAAW;EAE7C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe;;cAWvE;;;;;;;8BAOgB;GAGnB,YAAY,QAAQ;EAErB;MAII,gBAAgB;;iBASL,eAAe;;;;;;;;qBASnB,yBAAyB,SAAS;;WAGjB,IAAI;EAAhC,YAA4B,IAAI;;EAGhC,QAAQ,cAAc;;;;;;;;;EAYtB,UAAU,QAAQ;MAkCd,oBAAoB;EAIxB,QAAQ,OAAO;EAWf,eAAe,QAAQ,QAAQ;EAC/B,eAAe,QAAQ,QAAQ,eAAe;EAC9C,WACE,MAAM,gBACN,WAAW,eACX,OAAO,iBACP;IACE;IACA;IACA;IACA;IACA;IACA;;EAGJ,UAAU,MAAM,gBAAgB,WAAW,eAAe,MAAM;EAChE,eAAe,mBAAmB,WAAW;EAC7C,cAAc,mBAAmB,WAAW;EAC5C,WAAW,aAAa,eAAe,OAAO,cAAc,eAAe"}

package/build/PluginManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.js","names":["#pluginsByCallback","#plugins"],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"src/flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { type RowData } from \"src/RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAO,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAKA,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAKC,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAKA,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKD,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAKA,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAKA,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAKC,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAKA,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAO,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}
+{"version":3,"file":"PluginManager.js","names":[],"sources":["../src/PluginManager.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { type EntityManager, type FindOperation, isDefined } from \"src/EntityManager.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { JoinRowTodo, Todo } from \"src/flush/Todo.ts\";\nimport type { ParsedFindQuery } from \"src/queries/find/QueryParser.ts\";\nimport { type RowData } from \"src/RowData.ts\";\n\ninterface PluginMethods {\n  /**\n   * Called before a field value is retrieved from an entity via getField.\n   *\n   * @param entity The entity instance being accessed\n   * @param field The field name being retrieved\n   */\n  beforeGetField?(entity: Entity, field: string): void;\n  /**\n   * Called before a field value is set on an entity via setField.\n   *\n   * @param entity The entity instance being modified\n   * @param field The field name being set\n   * @param newValue The new value being assigned to the field\n   */\n  beforeSetField?(entity: Entity, field: string, newValue: any): void;\n  /**\n   * Called before a find operation is executed.\n   *\n   * @param meta Metadata for the entity type being queried\n   * @param operation The type of find operation being performed\n   * @param query The parsed query conditions\n   * @param settings Query settings including limit and offset\n   */\n  beforeFind?(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void;\n  /**\n   * Called after a find operation has been executed to observe the raw database rows.\n   *\n   * The result is an observation-only {@link RowData} view — i.e. `rows.rowCount` for metrics,\n   * `rows.get(i, columnName)` for specific cells, or `rows.toRows()` to materialize POJO rows.\n   * For lazy results, cells decode on access, so a hook that only counts rows costs nothing;\n   * materializing via `toRows()` decodes every cell of every row. Mutating materialized rows is\n   * unsupported and is not guaranteed to affect entity hydration.\n   *\n   * @param meta Metadata for the entity type that was queried\n   * @param operation The type of find operation that was performed\n   * @param rows A read-only view of the raw database rows returned from the query\n   */\n  afterFind?(meta: EntityMetadata, operation: FindOperation, rows: RowData): void;\n\n  beforeValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterValidate?(entities: readonly Entity[]): Promise<void> | void;\n\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void;\n}\n\nconst syncPluginMethods = [\n  \"beforeGetField\",\n  \"beforeSetField\",\n  \"beforeFind\",\n  \"afterFind\",\n  \"afterWrite\",\n] as const satisfies readonly (keyof PluginMethods)[];\nconst asyncPluginMethods = [\"beforeValidate\", \"afterValidate\"] as const satisfies readonly (keyof PluginMethods)[];\nconst emsSymbol = Symbol(\"ems\");\n/**\n * Base class for plugins that hook into entity lifecycle events.\n *\n * Plugins can implement any of the PluginMethods to intercept entity operations\n * and are automatically registered with the EntityManager when added via PluginManager.\n */\nexport abstract class Plugin {\n  // We need to store the EntityManager references in a WeakRef array so that they can be garbage collected.  If we\n  // didn't do this, then multiple EMs with the same plugin instance could keep each other from being garbage collected.\n  [emsSymbol]: WeakRef<EntityManager>[] = [];\n\n  maybeCloneForNewEm(): this | undefined {\n    return undefined;\n  }\n\n  get ems(): readonly EntityManager[] {\n    return this[emsSymbol]\n      .values()\n      .map((wr) => wr.deref())\n      .filter(isDefined)\n      .toArray();\n  }\n}\n\nexport interface Plugin extends PluginMethods {}\n\n/**\n * Manages plugin lifecycle and dispatches plugin callbacks to registered plugins.\n *\n * The PluginManager optimizes callback dispatch by only creating dispatcher methods\n * for callbacks that have at least one registered plugin, making unused plugin hooks\n * zero-cost at runtime.\n */\nexport class PluginManager implements Required<PluginMethods> {\n  #plugins = new Set<Plugin>();\n  readonly #pluginsByCallback: Partial<Record<keyof Plugin, Plugin[]>> = {};\n  constructor(public readonly em: EntityManager) {}\n\n  /** Returns whether any registered plugin implements `method`, i.e. so callers can skip building its args. */\n  hasHook(method: keyof PluginMethods): boolean {\n    return this.#pluginsByCallback[method] !== undefined;\n  }\n\n  /**\n   * Registers a plugin with this EntityManager.\n   *\n   * Dynamically creates dispatcher methods for any plugin callbacks implemented by this plugin,\n   * enabling lazy initialization of only the hooks that are actually used.\n   *\n   * @throws Error if the plugin is already registered with another EntityManager\n   */\n  addPlugin(plugin: Plugin) {\n    if (this.#plugins.has(plugin)) return; // if we're already added, then we can just early exit\n    this.#plugins.add(plugin);\n    plugin[emsSymbol].push(new WeakRef(this.em));\n    for (const method of syncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // As a performance optimization, we only create the actual implementation for each method on the plugin manager\n        // once we have at least one plugin using that method. This is to make it so any unused plugin methods are\n        // effectively no-ops when called from within the em.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              (plugin[method] as (...args: any[]) => unknown)(...args);\n            }\n          };\n        }\n      }\n    }\n    for (const method of asyncPluginMethods) {\n      if (method in plugin) {\n        (this.#pluginsByCallback[method] ??= []).push(plugin);\n        // Validate-phase plugin hooks are intentionally awaited without making hot-path hooks async.\n        if (!Object.hasOwn(this, method)) {\n          this[method] = async function (this: PluginManager, ...args: any[]) {\n            for (const plugin of this.#pluginsByCallback[method]!) {\n              await (plugin[method] as (...args: any[]) => Promise<void> | void)(...args);\n            }\n          };\n        }\n      }\n    }\n  }\n\n  get plugins(): readonly Plugin[] {\n    return [...this.#plugins];\n  }\n\n  cloneTo(other: PluginManager) {\n    this.#plugins\n      .values()\n      .map((plugin) => plugin.maybeCloneForNewEm())\n      .filter(isDefined)\n      .forEach((plugin) => other.addPlugin(plugin));\n  }\n\n  // Defined as no-op functions initially instead of using optional chaining for performance reasons, see:\n  // https://adventures.nodeland.dev/archive/noop-functions-vs-optional-chaining-a-performance/\n\n  beforeGetField(entity: Entity, field: string): void {}\n  beforeSetField(entity: Entity, field: string, newValue: any): void {}\n  beforeFind(\n    meta: EntityMetadata,\n    operation: FindOperation,\n    query: ParsedFindQuery,\n    settings: {\n      limit?: number;\n      offset?: number;\n      allowMultipleLeftJoins?: boolean;\n      optimizeJoinsToExists?: boolean;\n      pruneJoins?: boolean;\n      keepAliases?: string[];\n    },\n  ): void {}\n  afterFind(meta: EntityMetadata, operation: FindOperation, rows: RowData) {}\n  beforeValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterValidate(entities: readonly Entity[]): Promise<void> | void {}\n  afterWrite(entityTodos: Record<string, Todo>, joinRowTodos: Record<string, JoinRowTodo>): void {}\n}\n"],"mappings":";;;;AAkEA,MAAM,oBAAoB;CACxB;CACA;CACA;CACA;CACA;AACF;AACA,MAAM,qBAAqB,CAAC,kBAAkB,eAAe;AAC7D,MAAM,YAAY,OAAO,KAAK;;;;;;;AAO9B,IAAsB,SAAtB,MAA6B;CAG3B,CAAC,aAAuC,CAAC;CAEzC,qBAAuC,CAEvC;CAEA,IAAI,MAAgC;EAClC,OAAO,KAAK,UAAU,CACnB,OAAO,CAAC,CACR,KAAK,OAAO,GAAG,MAAM,CAAC,CAAC,CACvB,OAAO,SAAS,CAAC,CACjB,QAAQ;CACb;AACF;;;;;;;;AAWA,IAAa,gBAAb,MAA8D;CAGhC;CAF5B,2BAAW,IAAI,IAAY;CAC3B,qBAAuE,CAAC;CACxE,YAAY,IAAmC;EAAnB,KAAA,KAAA;CAAoB;;CAGhD,QAAQ,QAAsC;EAC5C,OAAO,KAAK,mBAAmB,YAAY,KAAA;CAC7C;;;;;;;;;CAUA,UAAU,QAAgB;EACxB,IAAI,KAAK,SAAS,IAAI,MAAM,GAAG;EAC/B,KAAK,SAAS,IAAI,MAAM;EACxB,OAAO,UAAU,CAAC,KAAK,IAAI,QAAQ,KAAK,EAAE,CAAC;EAC3C,KAAK,MAAM,UAAU,mBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAK,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAIpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,SAA+B,GAAG,MAAa;IAC5D,KAAK,MAAM,UAAU,KAAK,mBAAmB,SAC3C,OAAQ,OAAO,CAAiC,GAAG,IAAI;GAE3D;EAEJ;EAEF,KAAK,MAAM,UAAU,oBACnB,IAAI,UAAU,QAAQ;GACpB,CAAC,KAAK,mBAAmB,YAAY,CAAC,EAAA,CAAG,KAAK,MAAM;GAEpD,IAAI,CAAC,OAAO,OAAO,MAAM,MAAM,GAC7B,KAAK,UAAU,eAAqC,GAAG,MAAa;IAClE,KAAK,MAAM,UAAU,KAAK,mBAAmB,SAC3C,MAAO,OAAO,OAAO,CAA8C,GAAG,IAAI;GAE9E;EAEJ;CAEJ;CAEA,IAAI,UAA6B;EAC/B,OAAO,CAAC,GAAG,KAAK,QAAQ;CAC1B;CAEA,QAAQ,OAAsB;EAC5B,KAAK,SACF,OAAO,CAAC,CACR,KAAK,WAAW,OAAO,mBAAmB,CAAC,CAAC,CAC5C,OAAO,SAAS,CAAC,CACjB,SAAS,WAAW,MAAM,UAAU,MAAM,CAAC;CAChD;CAKA,eAAe,QAAgB,OAAqB,CAAC;CACrD,eAAe,QAAgB,OAAe,UAAqB,CAAC;CACpE,WACE,MACA,WACA,OACA,UAQM,CAAC;CACT,UAAU,MAAsB,WAA0B,MAAe,CAAC;CAC1E,eAAe,UAAmD,CAAC;CACnE,cAAc,UAAmD,CAAC;CAClE,WAAW,aAAmC,cAAiD,CAAC;AAClG"}

package/build/RowData.d.cts

@@ -20,7 +20,7 @@
  * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for
  * deferred temporals); the field serdes then convert them to domain values.
  */
-interface RowData {
+export interface RowData {
   /** The number of rows in this query result. */
   readonly rowCount: number;
   /** Returns the driver-level column value for a row, i.e. `rowData.get(0, "first_name")`. */
@@ -38,7 +38,7 @@ interface RowData {
   finalize?(): void;
 }
 /** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
-declare class PojoRowData implements RowData {
+export declare class PojoRowData implements RowData {
   private rows;
   constructor(rows: readonly any[]);
   get rowCount(): number;
@@ -47,7 +47,6 @@ declare class PojoRowData implements RowData {
   toRows(): any[];
 }
 /** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
-declare const emptyRowData: RowData;
+export declare const emptyRowData: RowData;
 //#endregion
-export { PojoRowData, RowData, emptyRowData };
 //# sourceMappingURL=RowData.d.cts.map

package/build/RowData.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"RowData.d.cts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;cAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;cAMW,cAAc"}
+{"version":3,"file":"RowData.d.cts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;qBAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;qBAMW,cAAc"}

package/build/RowData.d.mts

@@ -20,7 +20,7 @@
  * parsers produce (numbers for `int4`, parsed objects for `jsonb`, strings for
  * deferred temporals); the field serdes then convert them to domain values.
  */
-interface RowData {
+export interface RowData {
   /** The number of rows in this query result. */
   readonly rowCount: number;
   /** Returns the driver-level column value for a row, i.e. `rowData.get(0, "first_name")`. */
@@ -38,7 +38,7 @@ interface RowData {
   finalize?(): void;
 }
 /** Wraps classic materialized POJO rows, i.e. from node-pg results or hand-built test rows. */
-declare class PojoRowData implements RowData {
+export declare class PojoRowData implements RowData {
   private rows;
   constructor(rows: readonly any[]);
   get rowCount(): number;
@@ -47,7 +47,6 @@ declare class PojoRowData implements RowData {
   toRows(): any[];
 }
 /** A shared `RowData` for new entities, which have no database row yet (all columns undefined). */
-declare const emptyRowData: RowData;
+export declare const emptyRowData: RowData;
 //#endregion
-export { PojoRowData, RowData, emptyRowData };
 //# sourceMappingURL=RowData.d.mts.map

package/build/RowData.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"RowData.d.mts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;cAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;cAMW,cAAc"}
+{"version":3,"file":"RowData.d.mts","names":[],"sources":["../src/RowData.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAqBiB;;WAEN;;EAET,IAAI,kBAAkB;;EAEtB,MAAM;;EAEN;;EAEA,QAAQ;;;;;EAKR;;;qBAIW,uBAAuB;UACd;EAApB,YAAoB;MAEhB;EAIJ,IAAI,kBAAkB;EAItB,MAAM;EAIN;;;qBAMW,cAAc"}

package/build/batchloaders/BatchLoader.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"BatchLoader.cjs","names":["#batchFn","#ensureBatch","#pending","#batchPromise"],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAKA,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAKC,aAAa;EAClB,KAAKC,SAAU,KAAK,GAAG;EACvB,OAAO,KAAKC;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAKF,aAAa;EAIlB,MAAM,UAAU,KAAKC;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAKC;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAKD,UAAU;GAClB,KAAKA,WAAW,CAAC;GACjB,KAAKC,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAKD;KAClB,KAAKA,WAAW,KAAA;KAChB,KAAKC,gBAAgB,KAAA;KACrB,KAAKH,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}
+{"version":3,"file":"BatchLoader.cjs","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAK,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAK,aAAa;EAClB,KAAK,SAAU,KAAK,GAAG;EACvB,OAAO,KAAK;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAK,aAAa;EAIlB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAK;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAK,UAAU;GAClB,KAAK,WAAW,CAAC;GACjB,KAAK,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAK;KAClB,KAAK,WAAW,KAAA;KAChB,KAAK,gBAAgB,KAAA;KACrB,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}

package/build/batchloaders/BatchLoader.d.cts

@@ -6,12 +6,11 @@
  * or em.hydrate), so there's no per-key return value — just one shared promise
  * that signals "the batch is done".
  */
-declare class BatchLoader<K> {
+export declare class BatchLoader<K> {
   #private;
   constructor(batchFn: (keys: K[]) => Promise<void>);
   load(key: K): Promise<void>;
   loadAll(keys: K[]): Promise<void>;
 }
 //#endregion
-export { BatchLoader };
 //# sourceMappingURL=BatchLoader.d.cts.map

package/build/batchloaders/BatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"BatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;cAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}
+{"version":3,"file":"BatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;qBAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}

package/build/batchloaders/BatchLoader.d.mts

@@ -6,12 +6,11 @@
  * or em.hydrate), so there's no per-key return value — just one shared promise
  * that signals "the batch is done".
  */
-declare class BatchLoader<K> {
+export declare class BatchLoader<K> {
   #private;
   constructor(batchFn: (keys: K[]) => Promise<void>);
   load(key: K): Promise<void>;
   loadAll(keys: K[]): Promise<void>;
 }
 //#endregion
-export { BatchLoader };
 //# sourceMappingURL=BatchLoader.d.mts.map

package/build/batchloaders/BatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"BatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;cAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}
+{"version":3,"file":"BatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"mappings":";;;;;;;;qBAOa,YAAY;;EAKvB,YAAY,UAAU,MAAM,QAAQ;EAIpC,KAAK,KAAK,IAAI;EAMd,QAAQ,MAAM,MAAM"}

package/build/batchloaders/BatchLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"BatchLoader.js","names":["#batchFn","#ensureBatch","#pending","#batchPromise"],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAKA,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAKC,aAAa;EAClB,KAAKC,SAAU,KAAK,GAAG;EACvB,OAAO,KAAKC;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAKF,aAAa;EAIlB,MAAM,UAAU,KAAKC;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAKC;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAKD,UAAU;GAClB,KAAKA,WAAW,CAAC;GACjB,KAAKC,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAKD;KAClB,KAAKA,WAAW,KAAA;KAChB,KAAKC,gBAAgB,KAAA;KACrB,KAAKH,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}
+{"version":3,"file":"BatchLoader.js","names":[],"sources":["../../src/batchloaders/BatchLoader.ts"],"sourcesContent":["/**\n * Like DataLoader, but all callers in the same tick share a single Promise<void>.\n *\n * The batch function writes results into a side channel (e.g. setPreloadedRelation\n * or em.hydrate), so there's no per-key return value — just one shared promise\n * that signals \"the batch is done\".\n */\nexport class BatchLoader<K> {\n  #batchFn: (keys: K[]) => Promise<void>;\n  #pending: K[] | undefined;\n  #batchPromise: Promise<void> | undefined;\n\n  constructor(batchFn: (keys: K[]) => Promise<void>) {\n    this.#batchFn = batchFn;\n  }\n\n  load(key: K): Promise<void> {\n    this.#ensureBatch();\n    this.#pending!.push(key);\n    return this.#batchPromise!;\n  }\n\n  loadAll(keys: K[]): Promise<void> {\n    this.#ensureBatch();\n    // Avoid `push(...keys)`: spread passes each key as a separate function argument, exceeding the\n    // JS engine's argument-count limit on large arrays and throwing `RangeError: Maximum call stack\n    // size exceeded`. Trips on real-world m2m fan-outs (e.g. ~250k join rows).\n    const pending = this.#pending!;\n    const start = pending.length;\n    pending.length += keys.length;\n    for (let i = 0; i < keys.length; i++) {\n      pending[start + i] = keys[i];\n    }\n    return this.#batchPromise!;\n  }\n\n  #ensureBatch(): void {\n    if (!this.#pending) {\n      this.#pending = [];\n      this.#batchPromise = new Promise<void>((resolve, reject) => {\n        enqueuePostPromiseJob(() => {\n          const keys = this.#pending!;\n          this.#pending = undefined;\n          this.#batchPromise = undefined;\n          this.#batchFn(keys).then(resolve, reject);\n        });\n      });\n    }\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\n\n// Matches DataLoader's enqueuePostPromiseJob scheduling:\n// https://github.com/graphql/dataloader/blob/main/src/index.js#L214\nconst enqueuePostPromiseJob =\n  typeof process === \"object\" && typeof process.nextTick === \"function\"\n    ? (fn: () => void) => resolvedPromise.then(() => process.nextTick(fn))\n    : (fn: () => void) => setTimeout(fn);\n"],"mappings":";;;;;;;;AAOA,IAAa,cAAb,MAA4B;CAC1B;CACA;CACA;CAEA,YAAY,SAAuC;EACjD,KAAK,WAAW;CAClB;CAEA,KAAK,KAAuB;EAC1B,KAAK,aAAa;EAClB,KAAK,SAAU,KAAK,GAAG;EACvB,OAAO,KAAK;CACd;CAEA,QAAQ,MAA0B;EAChC,KAAK,aAAa;EAIlB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,QAAQ;EACtB,QAAQ,UAAU,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAC/B,QAAQ,QAAQ,KAAK,KAAK;EAE5B,OAAO,KAAK;CACd;CAEA,eAAqB;EACnB,IAAI,CAAC,KAAK,UAAU;GAClB,KAAK,WAAW,CAAC;GACjB,KAAK,gBAAgB,IAAI,SAAe,SAAS,WAAW;IAC1D,4BAA4B;KAC1B,MAAM,OAAO,KAAK;KAClB,KAAK,WAAW,KAAA;KAChB,KAAK,gBAAgB,KAAA;KACrB,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,SAAS,MAAM;IAC1C,CAAC;GACH,CAAC;EACH;CACF;AACF;AAEA,MAAM,kBAAkB,QAAQ,QAAQ;AAIxC,MAAM,wBACJ,OAAO,YAAY,YAAY,OAAO,QAAQ,aAAa,cACtD,OAAmB,gBAAgB,WAAW,QAAQ,SAAS,EAAE,CAAC,KAClE,OAAmB,WAAW,EAAE"}

package/build/batchloaders/enumCollectionBatchLoader.d.cts

@@ -3,9 +3,8 @@ import { ManyToManyLike } from "../flush/JoinRows.cjs";
 import "../index.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 //#region src/batchloaders/enumCollectionBatchLoader.d.ts
-declare const enumCollectionLoadOperation = "enum-collection-load";
+export declare const enumCollectionLoadOperation = "enum-collection-load";
 /** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
-declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+export declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
 //#endregion
-export { enumCollectionBatchLoader, enumCollectionLoadOperation };
 //# sourceMappingURL=enumCollectionBatchLoader.d.cts.map

package/build/batchloaders/enumCollectionBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"enumCollectionBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"mappings":";;;;;cAKa;;iBAGG,0BAA0B,IAAI,eAAe,YAAY,iBAAiB"}
+{"version":3,"file":"enumCollectionBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"mappings":";;;;;qBAKa;;wBAGG,0BAA0B,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/enumCollectionBatchLoader.d.mts

@@ -3,9 +3,8 @@ import { ManyToManyLike } from "../flush/JoinRows.mjs";
 import "../index.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 //#region src/batchloaders/enumCollectionBatchLoader.d.ts
-declare const enumCollectionLoadOperation = "enum-collection-load";
+export declare const enumCollectionLoadOperation = "enum-collection-load";
 /** Batches `EnumCollection.load` calls via BatchLoader; keys are the owning entities' tagged ids. */
-declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+export declare function enumCollectionBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
 //#endregion
-export { enumCollectionBatchLoader, enumCollectionLoadOperation };
 //# sourceMappingURL=enumCollectionBatchLoader.d.mts.map

package/build/batchloaders/enumCollectionBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"enumCollectionBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"mappings":";;;;;cAKa;;iBAGG,0BAA0B,IAAI,eAAe,YAAY,iBAAiB"}
+{"version":3,"file":"enumCollectionBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/enumCollectionBatchLoader.ts"],"mappings":";;;;;qBAKa;;wBAGG,0BAA0B,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/loadBatchLoader.d.cts

@@ -3,7 +3,7 @@ import { LoadHint } from "../loading/loadHints.cjs";
 import { EntityMetadata } from "../EntityMetadata.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 //#region src/batchloaders/loadBatchLoader.d.ts
-declare const loadOperation = "load";
+export declare const loadOperation = "load";
 /**
  * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
  * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
@@ -11,10 +11,9 @@ declare const loadOperation = "load";
  * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
  * preloading into the same SELECT that fetches the entities.
  */
-declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
+export declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
   taggedId: string;
   hint: LoadHint<any> | undefined;
 }>;
 //#endregion
-export { loadBatchLoader, loadOperation };
 //# sourceMappingURL=loadBatchLoader.d.cts.map

package/build/batchloaders/loadBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"loadBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;cAWa;;;;;;;;iBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}
+{"version":3,"file":"loadBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;qBAWa;;;;;;;;wBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}

package/build/batchloaders/loadBatchLoader.d.mts

@@ -3,7 +3,7 @@ import { LoadHint } from "../loading/loadHints.mjs";
 import { EntityMetadata } from "../EntityMetadata.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 //#region src/batchloaders/loadBatchLoader.d.ts
-declare const loadOperation = "load";
+export declare const loadOperation = "load";
 /**
  * Batches em.load-style fetches, writing to identity map (via hydrate) instead of returning values.
  * After the batch resolves, callers retrieve their entity from `em.findExistingInstance`.
@@ -11,10 +11,9 @@ declare const loadOperation = "load";
  * Accepts tuples of `{ taggedId, hint }` so the preloader can inject join-based
  * preloading into the same SELECT that fetches the entities.
  */
-declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
+export declare function loadBatchLoader(em: EntityManager, meta: EntityMetadata, overwriteExisting?: boolean): BatchLoader<{
   taggedId: string;
   hint: LoadHint<any> | undefined;
 }>;
 //#endregion
-export { loadBatchLoader, loadOperation };
 //# sourceMappingURL=loadBatchLoader.d.mts.map

package/build/batchloaders/loadBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"loadBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;cAWa;;;;;;;;iBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}
+{"version":3,"file":"loadBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/loadBatchLoader.ts"],"mappings":";;;;;qBAWa;;;;;;;;wBASG,gBACd,IAAI,eACJ,MAAM,gBACN,8BACC;EAAc;EAAkB,MAAM"}

package/build/batchloaders/manyToManyBatchLoader.d.cts

@@ -3,9 +3,8 @@ import { ManyToManyLike } from "../flush/JoinRows.cjs";
 import "../index.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 //#region src/batchloaders/manyToManyBatchLoader.d.ts
-declare const manyToManyLoadOperation = "m2m-load";
+export declare const manyToManyLoadOperation = "m2m-load";
 /** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
-declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+export declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
 //#endregion
-export { manyToManyBatchLoader, manyToManyLoadOperation };
 //# sourceMappingURL=manyToManyBatchLoader.d.cts.map

package/build/batchloaders/manyToManyBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"manyToManyBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;cAMa;;iBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}
+{"version":3,"file":"manyToManyBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;qBAMa;;wBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/manyToManyBatchLoader.d.mts

@@ -3,9 +3,8 @@ import { ManyToManyLike } from "../flush/JoinRows.mjs";
 import "../index.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 //#region src/batchloaders/manyToManyBatchLoader.d.ts
-declare const manyToManyLoadOperation = "m2m-load";
+export declare const manyToManyLoadOperation = "m2m-load";
 /** Batches m2m.packages/core/src/relations/ReactiveManyToMany.tsload calls via BatchLoader. */
-declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
+export declare function manyToManyBatchLoader(em: EntityManager, collection: ManyToManyLike): BatchLoader<string>;
 //#endregion
-export { manyToManyBatchLoader, manyToManyLoadOperation };
 //# sourceMappingURL=manyToManyBatchLoader.d.mts.map

package/build/batchloaders/manyToManyBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"manyToManyBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;cAMa;;iBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}
+{"version":3,"file":"manyToManyBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/manyToManyBatchLoader.ts"],"mappings":";;;;;qBAMa;;wBAGG,sBAAsB,IAAI,eAAe,YAAY,iBAAiB"}

package/build/batchloaders/oneToManyBatchLoader.d.cts

@@ -4,8 +4,7 @@ import "../index.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/batchloaders/oneToManyBatchLoader.d.ts
-declare const oneToManyLoadOperation = "o2m-load";
-declare function oneToManyBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: OneToManyCollection<T, U>): BatchLoader<string>;
+export declare const oneToManyLoadOperation = "o2m-load";
+export declare function oneToManyBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: OneToManyCollection<T, U>): BatchLoader<string>;
 //#endregion
-export { oneToManyBatchLoader, oneToManyLoadOperation };
 //# sourceMappingURL=oneToManyBatchLoader.d.cts.map

package/build/batchloaders/oneToManyBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"oneToManyBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/oneToManyBatchLoader.ts"],"mappings":";;;;;;cAea;iBAEG,qBAAqB,UAAU,QAAQ,UAAU,QAC/D,IAAI,eACJ,YAAY,oBAAoB,GAAG,KAClC"}
+{"version":3,"file":"oneToManyBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/oneToManyBatchLoader.ts"],"mappings":";;;;;;qBAea;wBAEG,qBAAqB,UAAU,QAAQ,UAAU,QAC/D,IAAI,eACJ,YAAY,oBAAoB,GAAG,KAClC"}

package/build/batchloaders/oneToManyBatchLoader.d.mts

@@ -4,8 +4,7 @@ import "../index.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/batchloaders/oneToManyBatchLoader.d.ts
-declare const oneToManyLoadOperation = "o2m-load";
-declare function oneToManyBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: OneToManyCollection<T, U>): BatchLoader<string>;
+export declare const oneToManyLoadOperation = "o2m-load";
+export declare function oneToManyBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: OneToManyCollection<T, U>): BatchLoader<string>;
 //#endregion
-export { oneToManyBatchLoader, oneToManyLoadOperation };
 //# sourceMappingURL=oneToManyBatchLoader.d.mts.map

package/build/batchloaders/oneToManyBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"oneToManyBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/oneToManyBatchLoader.ts"],"mappings":";;;;;;cAea;iBAEG,qBAAqB,UAAU,QAAQ,UAAU,QAC/D,IAAI,eACJ,YAAY,oBAAoB,GAAG,KAClC"}
+{"version":3,"file":"oneToManyBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/oneToManyBatchLoader.ts"],"mappings":";;;;;;qBAea;wBAEG,qBAAqB,UAAU,QAAQ,UAAU,QAC/D,IAAI,eACJ,YAAY,oBAAoB,GAAG,KAClC"}

package/build/batchloaders/oneToOneBatchLoader.d.cts

@@ -3,8 +3,7 @@ import { OneToOneReferenceImpl } from "../relations/OneToOneReference.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/batchloaders/oneToOneBatchLoader.d.ts
-declare const oneToOneLoadOperation = "o2o-load";
-declare function oneToOneBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, reference: OneToOneReferenceImpl<T, U>): BatchLoader<string>;
+export declare const oneToOneLoadOperation = "o2o-load";
+export declare function oneToOneBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, reference: OneToOneReferenceImpl<T, U>): BatchLoader<string>;
 //#endregion
-export { oneToOneBatchLoader, oneToOneLoadOperation };
 //# sourceMappingURL=oneToOneBatchLoader.d.cts.map

package/build/batchloaders/oneToOneBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"oneToOneBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/oneToOneBatchLoader.ts"],"mappings":";;;;;cAea;iBAEG,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,IAAI,eACJ,WAAW,sBAAsB,GAAG,KACnC"}
+{"version":3,"file":"oneToOneBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/oneToOneBatchLoader.ts"],"mappings":";;;;;qBAea;wBAEG,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,IAAI,eACJ,WAAW,sBAAsB,GAAG,KACnC"}

package/build/batchloaders/oneToOneBatchLoader.d.mts

@@ -3,8 +3,7 @@ import { OneToOneReferenceImpl } from "../relations/OneToOneReference.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/batchloaders/oneToOneBatchLoader.d.ts
-declare const oneToOneLoadOperation = "o2o-load";
-declare function oneToOneBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, reference: OneToOneReferenceImpl<T, U>): BatchLoader<string>;
+export declare const oneToOneLoadOperation = "o2o-load";
+export declare function oneToOneBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, reference: OneToOneReferenceImpl<T, U>): BatchLoader<string>;
 //#endregion
-export { oneToOneBatchLoader, oneToOneLoadOperation };
 //# sourceMappingURL=oneToOneBatchLoader.d.mts.map

package/build/batchloaders/oneToOneBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"oneToOneBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/oneToOneBatchLoader.ts"],"mappings":";;;;;cAea;iBAEG,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,IAAI,eACJ,WAAW,sBAAsB,GAAG,KACnC"}
+{"version":3,"file":"oneToOneBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/oneToOneBatchLoader.ts"],"mappings":";;;;;qBAea;wBAEG,oBAAoB,UAAU,QAAQ,UAAU,QAC9D,IAAI,eACJ,WAAW,sBAAsB,GAAG,KACnC"}

package/build/batchloaders/populateBatchLoader.cjs

@@ -1,7 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./BatchLoader.cjs");
-const require_normalizeHints = require("../normalizeHints.cjs");
-const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
 const require_keys = require("../keys.cjs");
 const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
 const require_batchloaders_manyToManyBatchLoader = require("./manyToManyBatchLoader.cjs");
@@ -10,6 +8,8 @@ const require_queries_find_QueryParser = require("../queries/find/QueryParser.cj
 const require_batchloaders_oneToOneBatchLoader = require("./oneToOneBatchLoader.cjs");
 const require_relations_ReactiveField = require("../relations/ReactiveField.cjs");
 const require_utils = require("../utils.cjs");
+const require_normalizeHints = require("../normalizeHints.cjs");
+const require_reactivity_reactiveHints = require("../reactivity/reactiveHints.cjs");
 require("../EntityMetadata.cjs");
 const require_queries_sql_AliasAssigner = require("../queries/sql/AliasAssigner.cjs");
 const require_loading_HintTree = require("../loading/HintTree.cjs");

package/build/batchloaders/populateBatchLoader.d.cts

@@ -5,13 +5,12 @@ import "../index.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/batchloaders/populateBatchLoader.d.ts
-declare const populateOperation = "populate";
-declare function populateBatchLoader(em: EntityManager, meta: EntityMetadata, hint: LoadHint<any>, mode: "preload" | "intermixed", opts?: {
+export declare const populateOperation = "populate";
+export declare function populateBatchLoader(em: EntityManager, meta: EntityMetadata, hint: LoadHint<any>, mode: "preload" | "intermixed", opts?: {
   forceReload?: boolean;
 }): BatchLoader<{
   entity: Entity;
   hint: LoadHint<any>;
 }>;
 //#endregion
-export { populateBatchLoader, populateOperation };
 //# sourceMappingURL=populateBatchLoader.d.cts.map

package/build/batchloaders/populateBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"populateBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/populateBatchLoader.ts"],"mappings":";;;;;;;cAwBa;iBAEG,oBACd,IAAI,eACJ,MAAM,gBACN,MAAM,eACN,gCACA;EAAQ;IACP;EAAc,QAAQ;EAAQ,MAAM"}
+{"version":3,"file":"populateBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/populateBatchLoader.ts"],"mappings":";;;;;;;qBAwBa;wBAEG,oBACd,IAAI,eACJ,MAAM,gBACN,MAAM,eACN,gCACA;EAAQ;IACP;EAAc,QAAQ;EAAQ,MAAM"}

package/build/batchloaders/populateBatchLoader.d.mts

@@ -5,13 +5,12 @@ import "../index.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/batchloaders/populateBatchLoader.d.ts
-declare const populateOperation = "populate";
-declare function populateBatchLoader(em: EntityManager, meta: EntityMetadata, hint: LoadHint<any>, mode: "preload" | "intermixed", opts?: {
+export declare const populateOperation = "populate";
+export declare function populateBatchLoader(em: EntityManager, meta: EntityMetadata, hint: LoadHint<any>, mode: "preload" | "intermixed", opts?: {
   forceReload?: boolean;
 }): BatchLoader<{
   entity: Entity;
   hint: LoadHint<any>;
 }>;
 //#endregion
-export { populateBatchLoader, populateOperation };
 //# sourceMappingURL=populateBatchLoader.d.mts.map

package/build/batchloaders/populateBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"populateBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/populateBatchLoader.ts"],"mappings":";;;;;;;cAwBa;iBAEG,oBACd,IAAI,eACJ,MAAM,gBACN,MAAM,eACN,gCACA;EAAQ;IACP;EAAc,QAAQ;EAAQ,MAAM"}
+{"version":3,"file":"populateBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/populateBatchLoader.ts"],"mappings":";;;;;;;qBAwBa;wBAEG,oBACd,IAAI,eACJ,MAAM,gBACN,MAAM,eACN,gCACA;EAAQ;IACP;EAAc,QAAQ;EAAQ,MAAM"}

package/build/batchloaders/populateBatchLoader.js

@@ -1,6 +1,4 @@
 import "./BatchLoader.js";
-import { hintKey } from "../normalizeHints.js";
-import { getRelationFromMaybePolyKey, isPolyHint } from "../reactivity/reactiveHints.js";
 import { keyToNumber } from "../keys.js";
 import { kqDot } from "../queries/sql/keywords.js";
 import { manyToManyBatchLoader } from "./manyToManyBatchLoader.js";
@@ -9,6 +7,8 @@ import { addTablePerClassJoinsAndClassTag } from "../queries/find/QueryParser.js
 import { oneToOneBatchLoader } from "./oneToOneBatchLoader.js";
 import { ReactiveFieldImpl } from "../relations/ReactiveField.js";
 import { indexBy, toArray } from "../utils.js";
+import { hintKey } from "../normalizeHints.js";
+import { getRelationFromMaybePolyKey, isPolyHint } from "../reactivity/reactiveHints.js";
 import "../EntityMetadata.js";
 import { AliasAssigner } from "../queries/sql/AliasAssigner.js";
 import { buildHintTree } from "../loading/HintTree.js";

package/build/batchloaders/recursiveChildrenBatchLoader.cjs

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./BatchLoader.cjs");
 const require_relations_Collection = require("../relations/Collection.cjs");
-require("../relations/RecursiveCollection.cjs");
 const require_fields = require("../fields.cjs");
 const require_keys = require("../keys.cjs");
 const require_queries_sql_keywords = require("../queries/sql/keywords.cjs");
 const require_queries_find_QueryParser = require("../queries/find/QueryParser.cjs");
 const require_relations_OneToOneReference = require("../relations/OneToOneReference.cjs");
+require("../relations/RecursiveCollection.cjs");
 const require_utils = require("../utils.cjs");
 const require_configure = require("../configure.cjs");
 require("../index.cjs");

package/build/batchloaders/recursiveChildrenBatchLoader.d.cts

@@ -3,8 +3,7 @@ import { RecursiveChildrenCollectionImpl } from "../relations/RecursiveCollectio
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/batchloaders/recursiveChildrenBatchLoader.d.ts
-declare const recursiveChildrenOperation = "o2m-recursive";
-declare function recursiveChildrenBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveChildrenCollectionImpl<T, U>): BatchLoader<Entity>;
+export declare const recursiveChildrenOperation = "o2m-recursive";
+export declare function recursiveChildrenBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveChildrenCollectionImpl<T, U>): BatchLoader<Entity>;
 //#endregion
-export { recursiveChildrenBatchLoader, recursiveChildrenOperation };
 //# sourceMappingURL=recursiveChildrenBatchLoader.d.cts.map

package/build/batchloaders/recursiveChildrenBatchLoader.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"recursiveChildrenBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"mappings":";;;;;cAoBa;iBAEG,6BAA6B,UAAU,QAAQ,UAAU,QACvE,IAAI,eACJ,YAAY,gCAAgC,GAAG,KAC9C,YAAY"}
+{"version":3,"file":"recursiveChildrenBatchLoader.d.cts","names":[],"sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"mappings":";;;;;qBAoBa;wBAEG,6BAA6B,UAAU,QAAQ,UAAU,QACvE,IAAI,eACJ,YAAY,gCAAgC,GAAG,KAC9C,YAAY"}

package/build/batchloaders/recursiveChildrenBatchLoader.d.mts

@@ -3,8 +3,7 @@ import { RecursiveChildrenCollectionImpl } from "../relations/RecursiveCollectio
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/batchloaders/recursiveChildrenBatchLoader.d.ts
-declare const recursiveChildrenOperation = "o2m-recursive";
-declare function recursiveChildrenBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveChildrenCollectionImpl<T, U>): BatchLoader<Entity>;
+export declare const recursiveChildrenOperation = "o2m-recursive";
+export declare function recursiveChildrenBatchLoader<T extends Entity, U extends Entity>(em: EntityManager, collection: RecursiveChildrenCollectionImpl<T, U>): BatchLoader<Entity>;
 //#endregion
-export { recursiveChildrenBatchLoader, recursiveChildrenOperation };
 //# sourceMappingURL=recursiveChildrenBatchLoader.d.mts.map

package/build/batchloaders/recursiveChildrenBatchLoader.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"recursiveChildrenBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"mappings":";;;;;cAoBa;iBAEG,6BAA6B,UAAU,QAAQ,UAAU,QACvE,IAAI,eACJ,YAAY,gCAAgC,GAAG,KAC9C,YAAY"}
+{"version":3,"file":"recursiveChildrenBatchLoader.d.mts","names":[],"sources":["../../src/batchloaders/recursiveChildrenBatchLoader.ts"],"mappings":";;;;;qBAoBa;wBAEG,6BAA6B,UAAU,QAAQ,UAAU,QACvE,IAAI,eACJ,YAAY,gCAAgC,GAAG,KAC9C,YAAY"}