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

package/build/loading/withLoaded.d.cts

@@ -8,7 +8,7 @@ import "../relations/index.cjs";
 import { LoadHint, Loaded } from "./loadHints.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/loading/withLoaded.d.ts
-type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
+export type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
   get: unknown;
 } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
 /**
@@ -31,9 +31,9 @@ type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>
  * This is also why the function is not recursive, as returning nested proxies could result in
  * them inadvertently being stored and passed to code that expects a real entity.
  */
-declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
-declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
-declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
+export declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
+export declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
+export declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
 /**
  * Allow stubbing of relations with dummy values.
  *
@@ -53,7 +53,7 @@ declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>
  *  });
  * ```
  */
-declare class StubbedRelation {
+export declare class StubbedRelation {
   private value;
   constructor(value: any);
   get get(): any;
@@ -61,5 +61,4 @@ declare class StubbedRelation {
   load(): any;
 }
 //#endregion
-export { StubbedRelation, WithLoaded, ensureWithLoaded, withLoaded };
 //# sourceMappingURL=withLoaded.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}
+{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;YAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;wBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;wBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;wBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;qBAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/loading/withLoaded.d.mts

@@ -8,7 +8,7 @@ import "../relations/index.mjs";
 import { LoadHint, Loaded } from "./loadHints.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/loading/withLoaded.d.ts
-type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
+export type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = { [K in keyof L as L[K] extends {
   get: unknown;
 } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K]: L[K] extends PolymorphicReference<T, infer U, infer N> ? L[K] extends LoadedReference<T, U, N> ? U | N : L[K] : L[K] extends LoadedReference<T, infer U, never> ? U : L[K] extends LoadedReference<T, infer U, undefined> ? U | undefined : L[K] extends LoadedCollection<T, infer U> ? U[] : L[K] extends LoadedReadOnlyCollection<T, infer U> ? U[] : L[K] extends LoadedProperty<T, infer V> ? V : L[K]; };
 /**
@@ -31,9 +31,9 @@ type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>
  * This is also why the function is not recursive, as returning nested proxies could result in
  * them inadvertently being stored and passed to code that expects a real entity.
  */
-declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
-declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
-declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
+export declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(promise: Promise<L>): Promise<WithLoaded<T, H, L>>;
+export declare function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(loaded: L): WithLoaded<T, H, L>;
+export declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(entity: T, hint: H): WithLoaded<T, H, Loaded<T, H>>;
 /**
  * Allow stubbing of relations with dummy values.
  *
@@ -53,7 +53,7 @@ declare function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>
  *  });
  * ```
  */
-declare class StubbedRelation {
+export declare class StubbedRelation {
   private value;
   constructor(value: any);
   get get(): any;
@@ -61,5 +61,4 @@ declare class StubbedRelation {
   load(): any;
 }
 //#endregion
-export { StubbedRelation, WithLoaded, ensureWithLoaded, withLoaded };
 //# sourceMappingURL=withLoaded.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}
+{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../../src/loading/withLoaded.ts"],"mappings":";;;;;;;;;;YAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;wBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;wBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;wBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;qBAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/logging/FactoryLogger.d.cts

@@ -2,8 +2,8 @@ import { EntityMetadata } from "../EntityMetadata.cjs";
 import { UseMapSource } from "../newTestInstance.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/logging/FactoryLogger.d.ts
-type WriteFn = (line: string) => void;
-declare class FactoryLogger {
+export type WriteFn = (line: string) => void;
+export declare class FactoryLogger {
   private level;
   private writeFn;
   private skipNextLogCreating;
@@ -21,7 +21,6 @@ declare class FactoryLogger {
   private write;
   private prefix;
 }
-declare function setFactoryWriter(write: WriteFn | undefined): void;
+export declare function setFactoryWriter(write: WriteFn | undefined): void;
 //#endregion
-export { FactoryLogger, WriteFn, setFactoryWriter };
 //# sourceMappingURL=FactoryLogger.d.cts.map

package/build/logging/FactoryLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.d.cts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAOY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}
+{"version":3,"file":"FactoryLogger.d.cts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;YAOY,WAAW;qBAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;wBAMM,iBAAiB,OAAO"}

package/build/logging/FactoryLogger.d.mts

@@ -2,8 +2,8 @@ import { EntityMetadata } from "../EntityMetadata.mjs";
 import { UseMapSource } from "../newTestInstance.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/logging/FactoryLogger.d.ts
-type WriteFn = (line: string) => void;
-declare class FactoryLogger {
+export type WriteFn = (line: string) => void;
+export declare class FactoryLogger {
   private level;
   private writeFn;
   private skipNextLogCreating;
@@ -21,7 +21,6 @@ declare class FactoryLogger {
   private write;
   private prefix;
 }
-declare function setFactoryWriter(write: WriteFn | undefined): void;
+export declare function setFactoryWriter(write: WriteFn | undefined): void;
 //#endregion
-export { FactoryLogger, WriteFn, setFactoryWriter };
 //# sourceMappingURL=FactoryLogger.d.mts.map

package/build/logging/FactoryLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"FactoryLogger.d.mts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;KAOY,WAAW;cAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;iBAMM,iBAAiB,OAAO"}
+{"version":3,"file":"FactoryLogger.d.mts","names":[],"sources":["../../src/logging/FactoryLogger.ts"],"mappings":";;;;YAOY,WAAW;qBAIV;UACH;UACA;UACA;EAIR;EAIA,YAAY;EASZ,eAAe,GAAG,QAAQ,QAAQ;EAQlC,WAAW,GAAG;EAKd,iBAAiB,GAAG;EAKpB,YAAY,mBAAmB,GAAG;EAIlC,uBAAuB,mBAAmB,MAAM;EAKhD,iBAAiB,mBAAmB,GAAG;EAIvC,qBAAqB,mBAAmB,GAAG;EAI3C;EAIA;UAIQ;UAIA;;wBAMM,iBAAiB,OAAO"}

package/build/logging/FieldLogger.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.cjs","names":["#writeFn","#watching","getFuzzyCallerName","isEntity"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ,MAAA;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAMC,eAAAA,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAMA,eAAAA,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKF,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACAE,eAAAA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}
+{"version":3,"file":"FieldLogger.cjs","names":["getFuzzyCallerName","isEntity"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ,MAAA;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAK,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAK,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAMA,eAAAA,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAMA,eAAAA,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAK,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAK,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAK,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACAC,eAAAA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}

package/build/logging/FieldLogger.d.cts

@@ -1,7 +1,7 @@
 import { Entity } from "../Entity.cjs";
 //#region src/logging/FieldLogger.d.ts
-type WriteFn = (line: string) => void;
-type FieldLoggerWatch = {
+export type WriteFn = (line: string) => void;
+export type FieldLoggerWatch = {
   /** The entity name, i.e. `Author` */
   entity: string;
   /** The fields, i.e. `["firstName", "lastName"]`. */
@@ -12,7 +12,7 @@ type FieldLoggerWatch = {
 /**
  * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.
  */
-declare class FieldLogger {
+export declare class FieldLogger {
   #private;
   constructor(
   /** The fields to watch, defaults to all fields. */
@@ -26,7 +26,6 @@ declare class FieldLogger {
   private getColor;
 }
 /** A shared no-op logger that avoids optional chaining in hot field access paths. */
-declare const noopFieldLogger: FieldLogger;
+export declare const noopFieldLogger: FieldLogger;
 //#endregion
-export { FieldLogger, FieldLoggerWatch, WriteFn, noopFieldLogger };
 //# sourceMappingURL=FieldLogger.d.cts.map

package/build/logging/FieldLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.d.cts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAKY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}
+{"version":3,"file":"FieldLogger.d.cts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;YAKY,WAAW;YAEX;;EAEV;;EAEA;;EAEA;;;;;qBAMW;;EAIX;;EAEE,UAAU;;EAEV,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;qBAoBG,iBAAiB"}

package/build/logging/FieldLogger.d.mts

@@ -1,7 +1,7 @@
 import { Entity } from "../Entity.mjs";
 //#region src/logging/FieldLogger.d.ts
-type WriteFn = (line: string) => void;
-type FieldLoggerWatch = {
+export type WriteFn = (line: string) => void;
+export type FieldLoggerWatch = {
   /** The entity name, i.e. `Author` */
   entity: string;
   /** The fields, i.e. `["firstName", "lastName"]`. */
@@ -12,7 +12,7 @@ type FieldLoggerWatch = {
 /**
  * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.
  */
-declare class FieldLogger {
+export declare class FieldLogger {
   #private;
   constructor(
   /** The fields to watch, defaults to all fields. */
@@ -26,7 +26,6 @@ declare class FieldLogger {
   private getColor;
 }
 /** A shared no-op logger that avoids optional chaining in hot field access paths. */
-declare const noopFieldLogger: FieldLogger;
+export declare const noopFieldLogger: FieldLogger;
 //#endregion
-export { FieldLogger, FieldLoggerWatch, WriteFn, noopFieldLogger };
 //# sourceMappingURL=FieldLogger.d.mts.map

package/build/logging/FieldLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.d.mts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;KAKY,WAAW;KAEX;;EAEV;;EAEA;;EAEA;;;;;cAMW;;EAIX,YAEE;;EAAA,UAAU,oBAEV;;EAAA,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;cAoBG,iBAAiB"}
+{"version":3,"file":"FieldLogger.d.mts","names":[],"sources":["../../src/logging/FieldLogger.ts"],"mappings":";;YAKY,WAAW;YAEX;;EAEV;;EAEA;;EAEA;;;;;qBAMW;;EAIX;;EAEE,UAAU;;EAEV,UAAU;EAOZ,UAAU,QAAQ;EAOlB,OAAO,QAAQ,QAAQ,mBAAmB;UAelC;UAIA;UAWA;;;qBAoBG,iBAAiB"}

package/build/logging/FieldLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"FieldLogger.js","names":["#writeFn","#watching"],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAKA,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAKC,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAM,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAM,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAKD,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAKC,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAKA,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}
+{"version":3,"file":"FieldLogger.js","names":[],"sources":["../../src/logging/FieldLogger.ts"],"sourcesContent":["import ansis from \"ansis\";\nimport { getFuzzyCallerName } from \"src/config.ts\";\nimport { type Entity, isEntity } from \"src/Entity.ts\";\n\nconst { gray, green, yellow, blue, red } = ansis;\nexport type WriteFn = (line: string) => void;\n\nexport type FieldLoggerWatch = {\n  /** The entity name, i.e. `Author` */\n  entity: string;\n  /** The fields, i.e. `[\"firstName\", \"lastName\"]`. */\n  fieldNames?: string[];\n  /** Whether to stop a debugger when the field is set. */\n  breakpoint?: boolean;\n};\n\n/**\n * Logs the setting of fields on entities to a `writeFn`, which defaults to `process.stdout`.\n */\nexport class FieldLogger {\n  readonly #writeFn: WriteFn;\n  readonly #watching: FieldLoggerWatch[] = [];\n\n  constructor(\n    /** The fields to watch, defaults to all fields. */\n    watching: FieldLoggerWatch[],\n    /** An optional/semi-internal write function, mostly for testing. */\n    writeFn?: WriteFn,\n  ) {\n    // We default to process.stdout.write to side-step around Jest's console.log instrumentation\n    this.#writeFn = writeFn ?? ((line) => process.stdout.write(`${line}\\n`));\n    this.#watching = watching ?? [];\n  }\n\n  logCreate(entity: Entity): void {\n    const log = this.shouldLog(entity, \"constructor\");\n    if (!log) return;\n    this.log(green.bold(`${entity.toTaggedString()}`) + \" \" + yellow(`created`), gray(`at ${getFuzzyCallerName()}`));\n    if (log === \"breakpoint\") debugger;\n  }\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {\n    const log = this.shouldLog(entity, fieldName);\n    if (!log) return;\n    const color = this.getColor(value);\n    this.log(\n      green.bold(`${entity.toTaggedString()}`) + yellow(`.${fieldName}`),\n      gray(`=`),\n      color(`${value}`),\n      // We don't know if we'll be called from getField or M2O.set+getField, i.e. how many stack frames to skip\n      // to really get \"the caller's location\", so use `getFuzzyCallerName` instead of `getCallerName`.\n      gray(`at ${getFuzzyCallerName()}`),\n    );\n    if (log === \"breakpoint\") debugger;\n  }\n\n  private log(...line: string[]): void {\n    this.#writeFn(`${line.join(\" \")}`);\n  }\n\n  private shouldLog(entity: Entity, fieldName: string): boolean | \"breakpoint\" {\n    if (this.#watching.length === 0) return true;\n    for (const { entity: entityName, fieldNames, breakpoint } of this.#watching) {\n      if (entity.constructor.name === entityName && (fieldNames === undefined || fieldNames.includes(fieldName))) {\n        return breakpoint ? \"breakpoint\" : true;\n      }\n    }\n    return false;\n  }\n\n  // Do some `typeof` -> color\n  private getColor(value: unknown): typeof red {\n    return typeof value === \"boolean\"\n      ? red // boolean => red\n      : isEntity(value)\n        ? green // entity => green (matches other logging)\n        : blue; // otherwise strings/dates/numbers are blue;\n  }\n}\n\nclass NoopFieldLogger extends FieldLogger {\n  constructor() {\n    super([]);\n  }\n\n  logCreate(entity: Entity): void {}\n\n  logSet(entity: Entity, fieldName: string, value: unknown): void {}\n}\n\n/** A shared no-op logger that avoids optional chaining in hot field access paths. */\nexport const noopFieldLogger: FieldLogger = new NoopFieldLogger();\n"],"mappings":";;;;AAIA,MAAM,EAAE,MAAM,OAAO,QAAQ,MAAM,QAAQ;;;;AAe3C,IAAa,cAAb,MAAyB;CACvB;CACA,YAAyC,CAAC;CAE1C,YAEE,UAEA,SACA;EAEA,KAAK,WAAW,aAAa,SAAS,QAAQ,OAAO,MAAM,GAAG,KAAK,GAAG;EACtE,KAAK,YAAY,YAAY,CAAC;CAChC;CAEA,UAAU,QAAsB;EAC9B,MAAM,MAAM,KAAK,UAAU,QAAQ,aAAa;EAChD,IAAI,CAAC,KAAK;EACV,KAAK,IAAI,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,MAAM,OAAO,SAAS,GAAG,KAAK,MAAM,mBAAmB,GAAG,CAAC;EAC/G,IAAI,QAAQ,cAAc;CAC5B;CAEA,OAAO,QAAgB,WAAmB,OAAsB;EAC9D,MAAM,MAAM,KAAK,UAAU,QAAQ,SAAS;EAC5C,IAAI,CAAC,KAAK;EACV,MAAM,QAAQ,KAAK,SAAS,KAAK;EACjC,KAAK,IACH,MAAM,KAAK,GAAG,OAAO,eAAe,GAAG,IAAI,OAAO,IAAI,WAAW,GACjE,KAAK,GAAG,GACR,MAAM,GAAG,OAAO,GAGhB,KAAK,MAAM,mBAAmB,GAAG,CACnC;EACA,IAAI,QAAQ,cAAc;CAC5B;CAEA,IAAY,GAAG,MAAsB;EACnC,KAAK,SAAS,GAAG,KAAK,KAAK,GAAG,GAAG;CACnC;CAEA,UAAkB,QAAgB,WAA2C;EAC3E,IAAI,KAAK,UAAU,WAAW,GAAG,OAAO;EACxC,KAAK,MAAM,EAAE,QAAQ,YAAY,YAAY,gBAAgB,KAAK,WAChE,IAAI,OAAO,YAAY,SAAS,eAAe,eAAe,KAAA,KAAa,WAAW,SAAS,SAAS,IACtG,OAAO,aAAa,eAAe;EAGvC,OAAO;CACT;CAGA,SAAiB,OAA4B;EAC3C,OAAO,OAAO,UAAU,YACpB,MACA,SAAS,KAAK,IACZ,QACA;CACR;AACF;AAEA,IAAM,kBAAN,cAA8B,YAAY;CACxC,cAAc;EACZ,MAAM,CAAC,CAAC;CACV;CAEA,UAAU,QAAsB,CAAC;CAEjC,OAAO,QAAgB,WAAmB,OAAsB,CAAC;AACnE;;AAGA,MAAa,kBAA+B,IAAI,gBAAgB"}

package/build/logging/ReactionLogger.d.cts

@@ -4,14 +4,14 @@ import { Reactable, ReactiveRule } from "../config.cjs";
 import { EntityManager } from "../EntityManager.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/logging/ReactionLogger.d.ts
-declare let globalLogger: ReactionLogger | undefined;
+export declare let globalLogger: ReactionLogger | undefined;
 type WriteFn = (line: string) => void;
-type ReactionWalk = {
+export type ReactionWalk = {
   todo: Entity[];
   r: Reactable | ReactiveRule;
   entities: Entity[];
 };
-declare class ReactionLogger {
+export declare class ReactionLogger {
   private writeFn;
   constructor(writeFn?: WriteFn);
   now(): number;
@@ -28,10 +28,10 @@ declare class ReactionLogger {
   private entityCount;
   private log;
 }
-declare function setReactionLogging(enabled: boolean): void;
-declare function setReactionLogging(logger: ReactionLogger): void;
+export declare function setReactionLogging(enabled: boolean): void;
+export declare function setReactionLogging(logger: ReactionLogger): void;
 /** A shared no-op logger that avoids optional chaining in hot reaction paths. */
-declare const noopReactionLogger: ReactionLogger;
+export declare const noopReactionLogger: ReactionLogger;
 //#endregion
-export { ReactionLogger, ReactionWalk, globalLogger, noopReactionLogger, setReactionLogging };
+export {};
 //# sourceMappingURL=ReactionLogger.d.cts.map

package/build/logging/ReactionLogger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.d.cts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAUW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}
+{"version":3,"file":"ReactionLogger.d.cts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;mBAUW,cAAc;KACpB,WAAW;YACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;qBAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;wBAKM,mBAAmB;wBACnB,mBAAmB,QAAQ;;qBA8B9B,oBAAoB"}

package/build/logging/ReactionLogger.d.mts

@@ -4,14 +4,14 @@ import { Reactable, ReactiveRule } from "../config.mjs";
 import { EntityManager } from "../EntityManager.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/logging/ReactionLogger.d.ts
-declare let globalLogger: ReactionLogger | undefined;
+export declare let globalLogger: ReactionLogger | undefined;
 type WriteFn = (line: string) => void;
-type ReactionWalk = {
+export type ReactionWalk = {
   todo: Entity[];
   r: Reactable | ReactiveRule;
   entities: Entity[];
 };
-declare class ReactionLogger {
+export declare class ReactionLogger {
   private writeFn;
   constructor(writeFn?: WriteFn);
   now(): number;
@@ -28,10 +28,10 @@ declare class ReactionLogger {
   private entityCount;
   private log;
 }
-declare function setReactionLogging(enabled: boolean): void;
-declare function setReactionLogging(logger: ReactionLogger): void;
+export declare function setReactionLogging(enabled: boolean): void;
+export declare function setReactionLogging(logger: ReactionLogger): void;
 /** A shared no-op logger that avoids optional chaining in hot reaction paths. */
-declare const noopReactionLogger: ReactionLogger;
+export declare const noopReactionLogger: ReactionLogger;
 //#endregion
-export { ReactionLogger, ReactionWalk, globalLogger, noopReactionLogger, setReactionLogging };
+export {};
 //# sourceMappingURL=ReactionLogger.d.mts.map

package/build/logging/ReactionLogger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ReactionLogger.d.mts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;YAUW,cAAc;KACpB,WAAW;KACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;cAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;iBAKM,mBAAmB;iBACnB,mBAAmB,QAAQ;;cA8B9B,oBAAoB"}
+{"version":3,"file":"ReactionLogger.d.mts","names":[],"sources":["../../src/logging/ReactionLogger.ts"],"mappings":";;;;;;mBAUW,cAAc;KACpB,WAAW;YACJ;EACV,MAAM;EACN,GAAG,YAAY;EACf,UAAU;;qBAGC;UACH;EAGR,YAAY,UAAS;EAIrB;EAIA,UAAU,QAAQ,QAAQ,mBAAmB,GAAG;EAQhD,aAAa,QAAQ,QAAQ,gBAAgB,GAAG;EAQhD,kBAAkB,IAAI,eAAe;EAOrC,oBAAoB,IAAI,eAAe,OAAO,eAAe;;EAS7D,SAAS,iBAAiB,6BAA6B;;EA4BvD,gBAAgB,IAAI,eAAe,SAAS;;EAgB5C,cAAc,IAAI,eAAe;UAIzB;UAIA;;wBAKM,mBAAmB;wBACnB,mBAAmB,QAAQ;;qBA8B9B,oBAAoB"}

package/build/newEntity.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"newEntity.cjs","names":["getMetadata","getLazyFields","hasAnyKey","fail","#fn"],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { getLazyFields } from \"src/getProperties.ts\";\nimport { fail, hasAnyKey } from \"src/utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAOA,uBAAAA,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,cAAA,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,mBAAA,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAUC,sBAAAA,cAAcD,uBAAAA,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAaE,cAAAA,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAOF,uBAAAA,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAcG,cAAAA,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAKC,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAKA,IAAI,QAAQ,SAAS;CACnC;AACF"}
+{"version":3,"file":"newEntity.cjs","names":["getMetadata","getLazyFields","hasAnyKey","fail"],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { getLazyFields } from \"src/getProperties.ts\";\nimport { fail, hasAnyKey } from \"src/utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAOA,uBAAAA,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,cAAA,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,mBAAA,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAUC,sBAAAA,cAAcD,uBAAAA,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAaE,cAAAA,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAOF,uBAAAA,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAcG,cAAAA,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAK,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAK,IAAI,QAAQ,SAAS;CACnC;AACF"}

package/build/newEntity.d.cts

@@ -11,7 +11,7 @@ import { Entity } from "./Entity.cjs";
  * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead
  * let any `this.books` accesses resolve to the getters we've installed on the prototype.
  */
-declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
+export declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
 /**
  * A function for `has...` methods to integrate with the `newEntity` lazy field system.
  *
@@ -21,7 +21,7 @@ declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityCons
  * But at runtime we actually want this to be a `LazyRelation` that can be rewritten
  * into a getter, and only invoked when the relation is actually accessed.
  */
-declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
+export declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
 /**
  * Easily resolves `otherMetadata` fields for lazy relations.
  *
@@ -35,14 +35,13 @@ declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: strin
  * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has
  * finished importing, and the consts are all defined.
  */
-declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
+export declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
 /** Wraps `has...` relation constructors in an easily-identifiable container. */
-declare class LazyRelation<T extends Entity> {
+export declare class LazyRelation<T extends Entity> {
   #private;
   constructor(fn: (entity: T, fieldName: string) => any);
   /** Called by our getters to lazily create the relation on first access. */
   create(entity: T, fieldName: string): any;
 }
 //#endregion
-export { LazyRelation, lazyField, newEntity, resolveOtherMeta };
 //# sourceMappingURL=newEntity.d.cts.map

package/build/newEntity.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"newEntity.d.cts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;iBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;iBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;cAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}
+{"version":3,"file":"newEntity.d.cts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;wBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;wBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;wBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;qBAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}

package/build/newEntity.d.mts

@@ -11,7 +11,7 @@ import { Entity } from "./Entity.mjs";
  * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead
  * let any `this.books` accesses resolve to the getters we've installed on the prototype.
  */
-declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
+export declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T;
 /**
  * A function for `has...` methods to integrate with the `newEntity` lazy field system.
  *
@@ -21,7 +21,7 @@ declare function newEntity<T extends Entity>(em: EntityManager, cstr: EntityCons
  * But at runtime we actually want this to be a `LazyRelation` that can be rewritten
  * into a getter, and only invoked when the relation is actually accessed.
  */
-declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
+export declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R;
 /**
  * Easily resolves `otherMetadata` fields for lazy relations.
  *
@@ -35,14 +35,13 @@ declare function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: strin
  * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has
  * finished importing, and the consts are all defined.
  */
-declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
+export declare function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata;
 /** Wraps `has...` relation constructors in an easily-identifiable container. */
-declare class LazyRelation<T extends Entity> {
+export declare class LazyRelation<T extends Entity> {
   #private;
   constructor(fn: (entity: T, fieldName: string) => any);
   /** Called by our getters to lazily create the relation on first access. */
   create(entity: T, fieldName: string): any;
 }
 //#endregion
-export { LazyRelation, lazyField, newEntity, resolveOtherMeta };
 //# sourceMappingURL=newEntity.d.mts.map

package/build/newEntity.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"newEntity.d.mts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;iBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;iBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;cAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}
+{"version":3,"file":"newEntity.d.mts","names":[],"sources":["../src/newEntity.ts"],"mappings":";;;;;;;;;;;;;wBAmBgB,UAAU,UAAU,QAAQ,IAAI,eAAe,MAAM,kBAAkB,IAAI,iBAAiB;;;;;;;;;;wBAuD5F,UAAU,UAAU,QAAQ,GAAG,KAAK,QAAQ,GAAG,sBAAsB,IAAI;;;;;;;;;;;;;;wBAiBzE,iBAAiB,QAAQ,QAAQ,oBAAoB;;qBAOxD,aAAa,UAAU;;EAElC,YAAY,KAAK,QAAQ,GAAG;;EAK5B,OAAO,QAAQ,GAAG"}

package/build/newEntity.js.map

@@ -1 +1 @@
-{"version":3,"file":"newEntity.js","names":["#fn"],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { getLazyFields } from \"src/getProperties.ts\";\nimport { fail, hasAnyKey } from \"src/utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAO,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAU,cAAc,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAa,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAO,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAc,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAKA,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAKA,IAAI,QAAQ,SAAS;CACnC;AACF"}
+{"version":3,"file":"newEntity.js","names":[],"sources":["../src/newEntity.ts"],"sourcesContent":["import { baseEntityCstr } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityConstructor, type EntityManager } from \"src/EntityManager.ts\";\nimport { type EntityMetadata, getMetadata } from \"src/EntityMetadata.ts\";\nimport { getLazyFields } from \"src/getProperties.ts\";\nimport { fail, hasAnyKey } from \"src/utils.ts\";\n\n// Marks a constructor like Author has having had our relation getters installed\nconst lazySymbol = Symbol(\"lazy\");\n\n/**\n * Constructs an instance of `cstr` but with relations all made lazy.\n *\n * Specifically we avoid going through `new` b/c that invokes the `constructor` which instantiates\n * the instance-level class fields/relations like `books = hasMany`.\n *\n * Instead, we just call `Object.create`, which does not make any constructor/super calls, and instead\n * let any `this.books` accesses resolve to the getters we've installed on the prototype.\n */\nexport function newEntity<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>, isNew: boolean): T {\n  if (!Object.hasOwn(cstr, lazySymbol)) {\n    moveRelationsToGetters(cstr);\n    (cstr as any)[lazySymbol] = true;\n  }\n  const meta = getMetadata(cstr);\n  if (meta.ctiAbstract) fail(`Cannot create an instance of abstract entity ${meta.type}`);\n  // This side-steps the `Author` constructor that initializes fields instance-level fields, which instead\n  // we've shoved up to be getters on the prototype, and the only instance field we expect to have is `__data`,\n  // which is set by the `baseEntityCstr` call.\n  const entity = Object.create(cstr.prototype) as T;\n  baseEntityCstr(em, entity as any, isNew);\n  return entity;\n}\n\nfunction moveRelationsToGetters(cstr: EntityConstructor<any>): void {\n  let transientFieldsValue: any = {};\n  for (const [fieldName, value] of getLazyFields(getMetadata(cstr))) {\n    if (value instanceof LazyRelation) {\n      Object.defineProperty(cstr.prototype, fieldName, {\n        get(this: any) {\n          return ((this.__data.relations ??= {})[fieldName] ??= value.create(this, fieldName));\n        },\n      });\n    } else if (fieldName === \"transientFields\") {\n      // We'll define transientFields for all entities outside the loop\n      transientFieldsValue = value;\n    }\n  }\n  // Most entities have no transientFields, so skip the structuredClone for the empty default\n  const needsClone = hasAnyKey(transientFieldsValue);\n  Object.defineProperty(cstr.prototype, \"transientFields\", {\n    get(this: any) {\n      // This prototype-level `get` will only ever be called once per instance, b/c when we're\n      // called for the first/only time, we set an instance-level `this.transientFields` that, for\n      // all future calls, will resolve to the instance's own copy of the fields.\n      //\n      // This has the pleasant upshot of making the instance-level `transientFields` lazy, and\n      // they will not be created on an instance until they're actually asked for.\n      const copy = needsClone ? structuredClone(transientFieldsValue) : {};\n      Object.defineProperty(this, \"transientFields\", { value: copy });\n      return copy;\n    },\n  });\n}\n\n/**\n * A function for `has...` methods to integrate with the `newEntity` lazy field system.\n *\n * We need TypeScript to still see `books = hasMany(...)` as being typed as `Many<Book>`,\n * so this method's return type is `R` i.e. the `Many<Book>` relation type.\n *\n * But at runtime we actually want this to be a `LazyRelation` that can be rewritten\n * into a getter, and only invoked when the relation is actually accessed.\n */\nexport function lazyField<T extends Entity, R>(fn: (entity: T, fieldName: string) => R): R {\n  return new LazyRelation(fn) as R;\n}\n\n/**\n * Easily resolves `otherMetadata` fields for lazy relations.\n *\n * When `lazyRelation`s are initialized for their first/only time, i.e. the `books = hasBooks(authorMetadata)`\n * call that `getFakeInstance` does, it's when the class bodies are still being evaled, which is before the\n * `metadata.ts` file has run.\n *\n * This means that any `authorMetadata` consts would still be undefined.\n *\n * So instead we just do not bother passing metadata consts to `has...` methods, and instead let the methods\n * one-time resolve `otherMetadata` on their first invocation, which will be after the `metadata.ts` file has\n * finished importing, and the consts are all defined.\n */\nexport function resolveOtherMeta(entity: Entity, fieldName: string): EntityMetadata {\n  const meta = getMetadata(entity);\n  const field: any = meta.allFields[fieldName] ?? fail(`Could not find field ${meta.type}.${fieldName}`);\n  return field.otherMetadata();\n}\n\n/** Wraps `has...` relation constructors in an easily-identifiable container. */\nexport class LazyRelation<T extends Entity> {\n  #fn: (entity: T, fieldName: string) => any;\n  constructor(fn: (entity: T, fieldName: string) => any) {\n    this.#fn = fn;\n  }\n\n  /** Called by our getters to lazily create the relation on first access. */\n  create(entity: T, fieldName: string) {\n    return this.#fn(entity, fieldName);\n  }\n}\n"],"mappings":";;;;;;;AAQA,MAAM,aAAa,OAAO,MAAM;;;;;;;;;;AAWhC,SAAgB,UAA4B,IAAmB,MAA4B,OAAmB;CAC5G,IAAI,CAAC,OAAO,OAAO,MAAM,UAAU,GAAG;EACpC,uBAAuB,IAAI;EAC3B,KAAc,cAAc;CAC9B;CACA,MAAM,OAAO,YAAY,IAAI;CAC7B,IAAI,KAAK,aAAa,KAAK,gDAAgD,KAAK,MAAM;CAItF,MAAM,SAAS,OAAO,OAAO,KAAK,SAAS;CAC3C,eAAe,IAAI,QAAe,KAAK;CACvC,OAAO;AACT;AAEA,SAAS,uBAAuB,MAAoC;CAClE,IAAI,uBAA4B,CAAC;CACjC,KAAK,MAAM,CAAC,WAAW,UAAU,cAAc,YAAY,IAAI,CAAC,GAC9D,IAAI,iBAAiB,cACnB,OAAO,eAAe,KAAK,WAAW,WAAW,EAC/C,MAAe;EACb,OAAQ,CAAC,KAAK,OAAO,cAAc,CAAC,EAAA,CAAG,eAAe,MAAM,OAAO,MAAM,SAAS;CACpF,EACF,CAAC;MACI,IAAI,cAAc,mBAEvB,uBAAuB;CAI3B,MAAM,aAAa,UAAU,oBAAoB;CACjD,OAAO,eAAe,KAAK,WAAW,mBAAmB,EACvD,MAAe;EAOb,MAAM,OAAO,aAAa,gBAAgB,oBAAoB,IAAI,CAAC;EACnE,OAAO,eAAe,MAAM,mBAAmB,EAAE,OAAO,KAAK,CAAC;EAC9D,OAAO;CACT,EACF,CAAC;AACH;;;;;;;;;;AAWA,SAAgB,UAA+B,IAA4C;CACzF,OAAO,IAAI,aAAa,EAAE;AAC5B;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAAgB,WAAmC;CAClF,MAAM,OAAO,YAAY,MAAM;CAE/B,QADmB,KAAK,UAAU,cAAc,KAAK,wBAAwB,KAAK,KAAK,GAAG,WAAW,EAAA,CACxF,cAAc;AAC7B;;AAGA,IAAa,eAAb,MAA4C;CAC1C;CACA,YAAY,IAA2C;EACrD,KAAK,MAAM;CACb;;CAGA,OAAO,QAAW,WAAmB;EACnC,OAAO,KAAK,IAAI,QAAQ,SAAS;CACnC;AACF"}