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

package/build/queries/ConditionBuilder.d.mts

@@ -4,7 +4,7 @@ import { Column } from "../serde/columns.mjs";
 //#region src/queries/ConditionBuilder.d.ts
 type PartialSome<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 /** Converts domain-level values like string ids/enums into their db equivalent. */
-declare class ConditionBuilder {
+export declare class ConditionBuilder {
   /** Simple, single-column conditions, which will be AND-d together. */
   private conditions;
   /** Complex expressions, which will also be AND-d together with `conditions`. */
@@ -27,5 +27,5 @@ declare class ConditionBuilder {
   toExpressionFilter(): ParsedExpressionFilter | undefined;
 }
 //#endregion
-export { ConditionBuilder };
+export {};
 //# sourceMappingURL=ConditionBuilder.d.mts.map

package/build/queries/ConditionBuilder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ConditionBuilder.d.mts","names":[],"sources":["../../src/queries/ConditionBuilder.ts"],"mappings":";;;;KAcK,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;cAGzD;;UAEH;;UAEA;;EAGR,mBAAmB,YAAY,eAAe;;EAM9C,mBAAmB,WAAW;;EAK9B,gBAAgB,WAAW,YAAY;;EASvC,oBAAoB,QAAQ;;;;;;EAS5B,eAAe,eAAe,QAAQ,QAAQ,QAAQ;;EAqCtD,sBAAsB"}
+{"version":3,"file":"ConditionBuilder.d.mts","names":[],"sources":["../../src/queries/ConditionBuilder.ts"],"mappings":";;;;KAcK,YAAY,GAAG,gBAAgB,KAAK,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG;;qBAGzD;;UAEH;;UAEA;;EAGR,mBAAmB,YAAY,eAAe;;EAM9C,mBAAmB,WAAW;;EAK9B,gBAAgB,WAAW,YAAY;;EASvC,oBAAoB,QAAQ;;;;;;EAS5B,eAAe,eAAe,QAAQ,QAAQ,QAAQ;;EAqCtD,sBAAsB"}

package/build/queries/conditions.d.cts

@@ -1,38 +1,37 @@
 import { ColumnCondition, RawCondition } from "./parsedConditions.cjs";
 //#region src/queries/conditions.d.ts
-declare const predicateBrand: unique symbol;
+export declare const predicateBrand: unique symbol;
 /** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */
-type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
+export type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
 /** Requires every surviving condition to match. */
-interface AndCondition<C> {
+export interface AndCondition<C> {
   and: Array<C | undefined>;
   or?: never;
   pruneIfUndefined?: "any" | "all";
 }
 /** Requires at least one surviving condition to match. */
-interface OrCondition<C> {
+export interface OrCondition<C> {
   or: Array<C | undefined>;
   and?: never;
   pruneIfUndefined?: "any" | "all";
 }
 /** Identifies which API can resolve a predicate's aliases. */
-interface PredicateBrand<K extends "domain" | "sql"> {
+export interface PredicateBrand<K extends "domain" | "sql"> {
   readonly [predicateBrand]: K;
 }
 /** A predicate built from alias(...) for em.find and scopes. */
-type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
+export type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
 /** A predicate built from table(...), an SQL expression, or sql.condition. */
-type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
+export type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
 /** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */
-type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
+export type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
   readonly [predicateBrand]?: never;
 };
 /** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */
-type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
+export type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
 /** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */
-type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
+export type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
 /** Marks a newly created predicate without changing its enumerable SQL representation. */
-declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
+export declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
 //#endregion
-export { AndCondition, ConditionGroup, ConditionInput, DomainPredicate, OrCondition, PredicateBrand, SqlCondition, SqlPredicate, UnbrandedPredicate, brandPredicate, predicateBrand };
 //# sourceMappingURL=conditions.d.cts.map

package/build/queries/conditions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.d.cts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;cAEa;;KAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;UAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;UAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;UAIe,eAAe;YACpB,iBAAiB;;;KAIjB,mBAAmB,kBAAkB,gBAAgB;;KAGrD,gBAAgB,kBAAkB,gBAAgB;;KAGlD,sBAAsB,kBAAkB;YAA4B;;;KAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;KAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;iBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}
+{"version":3,"file":"conditions.d.cts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;qBAEa;;YAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;iBAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;iBAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;iBAIe,eAAe;YACpB,iBAAiB;;;YAIjB,mBAAmB,kBAAkB,gBAAgB;;YAGrD,gBAAgB,kBAAkB,gBAAgB;;YAGlD,sBAAsB,kBAAkB;YAA4B;;;YAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;YAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;wBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}

package/build/queries/conditions.d.mts

@@ -1,38 +1,37 @@
 import { ColumnCondition, RawCondition } from "./parsedConditions.mjs";
 //#region src/queries/conditions.d.ts
-declare const predicateBrand: unique symbol;
+export declare const predicateBrand: unique symbol;
 /** Combines conditions without tying AND/OR or optional-filter pruning to either public API. */
-type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
+export type ConditionGroup<C> = AndCondition<C> | OrCondition<C>;
 /** Requires every surviving condition to match. */
-interface AndCondition<C> {
+export interface AndCondition<C> {
   and: Array<C | undefined>;
   or?: never;
   pruneIfUndefined?: "any" | "all";
 }
 /** Requires at least one surviving condition to match. */
-interface OrCondition<C> {
+export interface OrCondition<C> {
   or: Array<C | undefined>;
   and?: never;
   pruneIfUndefined?: "any" | "all";
 }
 /** Identifies which API can resolve a predicate's aliases. */
-interface PredicateBrand<K extends "domain" | "sql"> {
+export interface PredicateBrand<K extends "domain" | "sql"> {
   readonly [predicateBrand]: K;
 }
 /** A predicate built from alias(...) for em.find and scopes. */
-type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
+export type DomainPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"domain">;
 /** A predicate built from table(...), an SQL expression, or sql.condition. */
-type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
+export type SqlPredicate = (ColumnCondition | RawCondition) & PredicateBrand<"sql">;
 /** Existing hand-written conditions remain an escape hatch, but cannot accept a foreign branded predicate. */
-type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
+export type UnbrandedPredicate = (ColumnCondition | RawCondition) & {
   readonly [predicateBrand]?: never;
 };
 /** SQL predicates and nested AND/OR groups, before query-specific clauses such as EXISTS are added. */
-type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
+export type SqlCondition = AndCondition<SqlCondition> | OrCondition<SqlCondition> | SqlPredicate | UnbrandedPredicate;
 /** Unbranded compiler input shared by domain filtering and SQL queries after public API validation. */
-type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
+export type ConditionInput = AndCondition<ConditionInput> | OrCondition<ConditionInput> | ColumnCondition | RawCondition;
 /** Marks a newly created predicate without changing its enumerable SQL representation. */
-declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
+export declare function brandPredicate<C extends object, K extends "domain" | "sql">(cond: C, kind: K): C & PredicateBrand<K>;
 //#endregion
-export { AndCondition, ConditionGroup, ConditionInput, DomainPredicate, OrCondition, PredicateBrand, SqlCondition, SqlPredicate, UnbrandedPredicate, brandPredicate, predicateBrand };
 //# sourceMappingURL=conditions.d.mts.map

package/build/queries/conditions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"conditions.d.mts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;cAEa;;KAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;UAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;UAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;UAIe,eAAe;YACpB,iBAAiB;;;KAIjB,mBAAmB,kBAAkB,gBAAgB;;KAGrD,gBAAgB,kBAAkB,gBAAgB;;KAGlD,sBAAsB,kBAAkB;YAA4B;;;KAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;KAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;iBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}
+{"version":3,"file":"conditions.d.mts","names":[],"sources":["../../src/queries/conditions.ts"],"mappings":";;qBAEa;;YAGD,eAAe,KAAK,aAAa,KAAK,YAAY;;iBAG7C,aAAa;EAC5B,KAAK,MAAM;EACX;EACA;;;iBAIe,YAAY;EAC3B,IAAI,MAAM;EACV;EACA;;;iBAIe,eAAe;YACpB,iBAAiB;;;YAIjB,mBAAmB,kBAAkB,gBAAgB;;YAGrD,gBAAgB,kBAAkB,gBAAgB;;YAGlD,sBAAsB,kBAAkB;YAA4B;;;YAGpE,eAAe,aAAa,gBAAgB,YAAY,gBAAgB,eAAe;;YAGvF,iBACR,aAAa,kBACb,YAAY,kBACZ,kBACA;;wBAGY,eAAe,kBAAkB,4BAA4B,MAAM,GAAG,MAAM,IAAI,IAAI,eAAe"}

package/build/queries/entityQueryUtils.d.cts

@@ -7,13 +7,12 @@ import { EntityMetadata } from "../EntityMetadata.cjs";
  * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
  * that entities without lazy columns emit byte-identical SQL to before this feature existed.
  */
-declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
+export declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
 /** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
-declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
+export declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
 /** Returns whether the entity supports and requires soft-delete filtering for this query. */
-declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
+export declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
 /** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
-declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
+export declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
 //#endregion
-export { filterSoftDeletes, lazyExcludedSelects, maybeAddNotSoftDeleted, stiSubtypeFilter };
 //# sourceMappingURL=entityQueryUtils.d.cts.map

package/build/queries/entityQueryUtils.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"entityQueryUtils.d.cts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;iBAUgB,oBAAoB,MAAM,gBAAgB;;iBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;iBAec,kBAAkB,MAAM,gBAAgB;;iBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}
+{"version":3,"file":"entityQueryUtils.d.cts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;wBAUgB,oBAAoB,MAAM,gBAAgB;;wBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;wBAec,kBAAkB,MAAM,gBAAgB;;wBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}

package/build/queries/entityQueryUtils.d.mts

@@ -7,13 +7,12 @@ import { EntityMetadata } from "../EntityMetadata.mjs";
  * Only used when `meta.hasLazyColumns` is true; otherwise callers keep their plain `alias.*`, so
  * that entities without lazy columns emit byte-identical SQL to before this feature existed.
  */
-declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
+export declare function lazyExcludedSelects(meta: EntityMetadata, alias: string): string[];
 /** Adds a deleted-at condition when the entity's soft-deleted rows should be excluded. */
-declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
+export declare function maybeAddNotSoftDeleted(conditions: ColumnCondition[], meta: EntityMetadata, alias: string, softDeletes: "include" | "exclude"): void;
 /** Returns whether the entity supports and requires soft-delete filtering for this query. */
-declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
+export declare function filterSoftDeletes(meta: EntityMetadata, softDeletes: "include" | "exclude"): boolean;
 /** The `type_id = X` discriminator condition for an STI subtype, shared by em.find and em.query. */
-declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
+export declare function stiSubtypeFilter(meta: EntityMetadata, alias: string): ColumnCondition | undefined;
 //#endregion
-export { filterSoftDeletes, lazyExcludedSelects, maybeAddNotSoftDeleted, stiSubtypeFilter };
 //# sourceMappingURL=entityQueryUtils.d.mts.map

package/build/queries/entityQueryUtils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"entityQueryUtils.d.mts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;iBAUgB,oBAAoB,MAAM,gBAAgB;;iBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;iBAec,kBAAkB,MAAM,gBAAgB;;iBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}
+{"version":3,"file":"entityQueryUtils.d.mts","names":[],"sources":["../../src/queries/entityQueryUtils.ts"],"mappings":";;;;;;;;;wBAUgB,oBAAoB,MAAM,gBAAgB;;wBAW1C,uBACd,YAAY,mBACZ,MAAM,gBACN,eACA;;wBAec,kBAAkB,MAAM,gBAAgB;;wBAUxC,iBAAiB,MAAM,gBAAgB,gBAAgB"}

package/build/queries/find/Aliases.d.cts

@@ -7,13 +7,13 @@ import { IdOf, MaybeAbstractEntityConstructor, TaggedId } from "../../EntityMana
 import { Entity } from "../../Entity.cjs";
 //#region src/queries/find/Aliases.d.ts
 /** Creates an alias for complex domain filtering in `em.find`. */
-declare function alias<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
+export declare function alias<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
 /** Creates multiple aliases for complex filtering. */
-declare function aliases<T extends readonly MaybeAbstractEntityConstructor<any>[]>(...types: T): { [P in keyof T]: T[P] extends MaybeAbstractEntityConstructor<infer E extends Entity> ? Alias<E> : never; };
-declare const aliasMgmt: unique symbol;
+export declare function aliases<T extends readonly MaybeAbstractEntityConstructor<any>[]>(...types: T): { [P in keyof T]: T[P] extends MaybeAbstractEntityConstructor<infer E extends Entity> ? Alias<E> : never; };
+export declare const aliasMgmt: unique symbol;
 declare const aliasColumn: unique symbol;
 /** The identity and original entity metadata of an `em.find` alias. */
-interface AliasMgmt {
+export interface AliasMgmt {
   tableName: string;
   meta: EntityMetadata;
   /**
@@ -23,7 +23,7 @@ interface AliasMgmt {
   condition(build: (meta: EntityMetadata, alias: string) => RawCondition): RawCondition & PredicateBrand<"domain">;
 }
 /** Keeps domain aliases covariant in their entity type. */
-interface AliasBrand<T> extends AliasMgmt {
+export interface AliasBrand<T> extends AliasMgmt {
   readonly __entity: T;
 }
 /**
@@ -45,7 +45,7 @@ interface AliasBrand<T> extends AliasMgmt {
  * so they render through ExprContext rather than asking the find parser to bind a relationship path.
  * Neither path stores a resolved SQL name on the reusable handle or predicate.
  */
-type Alias<T extends Entity> = {
+export type Alias<T extends Entity> = {
   readonly [aliasMgmt]: AliasBrand<T>;
 } & { [P in keyof FieldsOf<T>]: P extends "id" ? EntityAlias<T> : FieldsOf<T>[P] extends {
   kind: "primitive" | "enum";
@@ -60,10 +60,10 @@ type Alias<T extends Entity> = {
   type: infer U extends Entity;
 } ? PolyAlias<U> : never; };
 /** A domain column accepted on the other side of a cross-alias comparison. */
-interface AliasColumn<V> {
+export interface AliasColumn<V> {
   readonly [aliasColumn]: V;
 }
-interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<V | N> {
+export interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<V | N> {
   eq(value: V | N | AliasColumn<V | null> | undefined): ExpressionCondition;
   ne(value: V | N | AliasColumn<V | null> | undefined): ExpressionCondition;
   in(values: readonly (V | null)[] | undefined): ExpressionCondition;
@@ -87,7 +87,7 @@ interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<
   /** Adds an operator and expression with knex-style placeholders, without the column name. */
   raw(exp: string, bindings: readonly unknown[] | undefined): ExpressionCondition;
 }
-interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdOf<T> | N> {
+export interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdOf<T> | N> {
   eq(value: T | IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   ne(value: T | IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   in(values: readonly (T | IdOf<T> | null)[] | null | undefined): ExpressionCondition;
@@ -98,25 +98,25 @@ interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdO
   lte(value: IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   raw(exp: string, bindings: readonly unknown[] | undefined): ExpressionCondition;
 }
-interface PolyAlias<T extends Entity> {
+export interface PolyAlias<T extends Entity> {
   eq(value: T | TaggedId | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   ne(value: T | TaggedId | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   in(values: readonly (T | TaggedId)[] | undefined): ExpressionCondition;
 }
 /** Returns the runtime identity bound by the find parser. */
-declare function getAliasMgmt(alias: {
+export declare function getAliasMgmt(alias: {
   readonly [aliasMgmt]: AliasMgmt;
 }): AliasMgmt;
 /** Returns the original metadata, preserving STI subtype identity. */
-declare function getAliasMetadata<T extends Entity>(alias: Alias<T>): EntityMetadata<T>;
+export declare function getAliasMetadata<T extends Entity>(alias: Alias<T>): EntityMetadata<T>;
 /** Creates domain predicates lazily from entity field metadata. */
-declare function newAliasProxy<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
+export declare function newAliasProxy<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
 /** Recognizes only domain aliases, not physical tables. */
-declare function isAlias(value: unknown): value is Alias<Entity>;
+export declare function isAlias(value: unknown): value is Alias<Entity>;
 /** Adjusts a field's SQL alias when a base alias is bound to a CTI subtype in the join tree. */
-declare function getMaybeCtiAlias(meta: EntityMetadata, field: Field & {
+export declare function getMaybeCtiAlias(meta: EntityMetadata, field: Field & {
   aliasSuffix: string;
 }, newMeta: EntityMetadata, newAlias: string): string;
 //#endregion
-export { Alias, AliasBrand, AliasColumn, AliasMgmt, EntityAlias, PolyAlias, PrimitiveAlias, alias, aliasMgmt, aliases, getAliasMetadata, getAliasMgmt, getMaybeCtiAlias, isAlias, newAliasProxy };
+export {};
 //# sourceMappingURL=Aliases.d.cts.map

package/build/queries/find/Aliases.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"Aliases.d.cts","names":[],"sources":["../../../src/queries/find/Aliases.ts"],"mappings":";;;;;;;;;iBAyBgB,MAAM,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;iBAKxE,QAAQ,mBAAmB,0CACtC,OAAO,OACN,WAAW,IAAI,EAAE,WAAW,qCAAqC,UAAU,UAAU,MAAM;cAIpF;cACP;;UAGW;EACf;EACA,MAAM;;;;;EAKN,UAAU,QAAQ,MAAM,gBAAgB,kBAAkB,eAAe,eAAe;;;UAIzE,WAAW,WAAW;WAC5B,UAAU;;;;;;;;;;;;;;;;;;;;;KAsBT,MAAM,UAAU;YAAsB,YAAY,WAAW;OACtE,WAAW,SAAS,KAAK,iBACtB,YAAY,KACZ,SAAS,GAAG;EAAa;EAA4B,YAAY;EAAG,gBAAgB;IAClF,eAAe,GAAG,sCAClB,SAAS,GAAG;EAAa;EAAa,YAAY,UAAU;EAAQ,gBAAgB;IAClF,YAAY,GAAG,sCACf,SAAS,GAAG;EAAa;EAAc,YAAY,UAAU;IAC3D,UAAU;;UAKL,YAAY;YACjB,cAAc;;UAGT,eAAe,GAAG,wCAAwC,YAAY,IAAI;EACzF,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,kBAAkB,0BAA0B;EAC/C,IAAI,kBAAkB,0BAA0B;EAChD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,KAAK,OAAO,gBAAgB;EAC5B,MAAM,OAAO,gBAAgB;EAC7B,OAAO,OAAO,gBAAgB;EAC9B,QAAQ,IAAI,eAAe,IAAI,gBAAgB;EAE/C,SAAS,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACrE,UAAU,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACtE,SAAS,OAAO,IAAI,YAAY,YAAY,gBAAgB;EAC5D,UAAU,OAAO,IAAI,YAAY,YAAY,gBAAgB;;EAE7D,WAAW,+BAA+B;;EAE1C,WAAW,+BAA+B;;EAE1C,IAAI,aAAa,2CAA2C;;UAG7C,YAAY,GAAG,wCAAwC,YAAY,KAAK,KAAK;EAC5F,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACzE,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EAEzE,GAAG,kBAAkB,IAAI,KAAK,kCAAkC;EAChE,IAAI,kBAAkB,IAAI,KAAK,kCAAkC;EACjE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,IAAI,aAAa,2CAA2C;;UAG7C,UAAU,UAAU;EACnC,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,kBAAkB,IAAI,0BAA0B;;;iBAIrC,aAAa;YAAmB,YAAY;IAAc;;iBAK1D,iBAAiB,UAAU,QAAQ,OAAO,MAAM,KAAK,eAAe;;iBAKpE,cAAc,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;iBA+BhF,QAAQ,iBAAiB,SAAS,MAAM;;iBAiMxC,iBACd,MAAM,gBACN,OAAO;EAAU;GACjB,SAAS,gBACT"}
+{"version":3,"file":"Aliases.d.cts","names":[],"sources":["../../../src/queries/find/Aliases.ts"],"mappings":";;;;;;;;;wBAyBgB,MAAM,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;wBAKxE,QAAQ,mBAAmB,0CACtC,OAAO,OACN,WAAW,IAAI,EAAE,WAAW,qCAAqC,UAAU,UAAU,MAAM;qBAIpF;cACP;;iBAGW;EACf;EACA,MAAM;;;;;EAKN,UAAU,QAAQ,MAAM,gBAAgB,kBAAkB,eAAe,eAAe;;;iBAIzE,WAAW,WAAW;WAC5B,UAAU;;;;;;;;;;;;;;;;;;;;;YAsBT,MAAM,UAAU;YAAsB,YAAY,WAAW;OACtE,WAAW,SAAS,KAAK,iBACtB,YAAY,KACZ,SAAS,GAAG;EAAa;EAA4B,YAAY;EAAG,gBAAgB;IAClF,eAAe,GAAG,sCAClB,SAAS,GAAG;EAAa;EAAa,YAAY,UAAU;EAAQ,gBAAgB;IAClF,YAAY,GAAG,sCACf,SAAS,GAAG;EAAa;EAAc,YAAY,UAAU;IAC3D,UAAU;;iBAKL,YAAY;YACjB,cAAc;;iBAGT,eAAe,GAAG,wCAAwC,YAAY,IAAI;EACzF,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,kBAAkB,0BAA0B;EAC/C,IAAI,kBAAkB,0BAA0B;EAChD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,KAAK,OAAO,gBAAgB;EAC5B,MAAM,OAAO,gBAAgB;EAC7B,OAAO,OAAO,gBAAgB;EAC9B,QAAQ,IAAI,eAAe,IAAI,gBAAgB;EAE/C,SAAS,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACrE,UAAU,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACtE,SAAS,OAAO,IAAI,YAAY,YAAY,gBAAgB;EAC5D,UAAU,OAAO,IAAI,YAAY,YAAY,gBAAgB;;EAE7D,WAAW,+BAA+B;;EAE1C,WAAW,+BAA+B;;EAE1C,IAAI,aAAa,2CAA2C;;iBAG7C,YAAY,GAAG,wCAAwC,YAAY,KAAK,KAAK;EAC5F,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACzE,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EAEzE,GAAG,kBAAkB,IAAI,KAAK,kCAAkC;EAChE,IAAI,kBAAkB,IAAI,KAAK,kCAAkC;EACjE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,IAAI,aAAa,2CAA2C;;iBAG7C,UAAU,UAAU;EACnC,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,kBAAkB,IAAI,0BAA0B;;;wBAIrC,aAAa;YAAmB,YAAY;IAAc;;wBAK1D,iBAAiB,UAAU,QAAQ,OAAO,MAAM,KAAK,eAAe;;wBAKpE,cAAc,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;wBA+BhF,QAAQ,iBAAiB,SAAS,MAAM;;wBAiMxC,iBACd,MAAM,gBACN,OAAO;EAAU;GACjB,SAAS,gBACT"}

package/build/queries/find/Aliases.d.mts

@@ -7,13 +7,13 @@ import { IdOf, MaybeAbstractEntityConstructor, TaggedId } from "../../EntityMana
 import { Entity } from "../../Entity.mjs";
 //#region src/queries/find/Aliases.d.ts
 /** Creates an alias for complex domain filtering in `em.find`. */
-declare function alias<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
+export declare function alias<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
 /** Creates multiple aliases for complex filtering. */
-declare function aliases<T extends readonly MaybeAbstractEntityConstructor<any>[]>(...types: T): { [P in keyof T]: T[P] extends MaybeAbstractEntityConstructor<infer E extends Entity> ? Alias<E> : never; };
-declare const aliasMgmt: unique symbol;
+export declare function aliases<T extends readonly MaybeAbstractEntityConstructor<any>[]>(...types: T): { [P in keyof T]: T[P] extends MaybeAbstractEntityConstructor<infer E extends Entity> ? Alias<E> : never; };
+export declare const aliasMgmt: unique symbol;
 declare const aliasColumn: unique symbol;
 /** The identity and original entity metadata of an `em.find` alias. */
-interface AliasMgmt {
+export interface AliasMgmt {
   tableName: string;
   meta: EntityMetadata;
   /**
@@ -23,7 +23,7 @@ interface AliasMgmt {
   condition(build: (meta: EntityMetadata, alias: string) => RawCondition): RawCondition & PredicateBrand<"domain">;
 }
 /** Keeps domain aliases covariant in their entity type. */
-interface AliasBrand<T> extends AliasMgmt {
+export interface AliasBrand<T> extends AliasMgmt {
   readonly __entity: T;
 }
 /**
@@ -45,7 +45,7 @@ interface AliasBrand<T> extends AliasMgmt {
  * so they render through ExprContext rather than asking the find parser to bind a relationship path.
  * Neither path stores a resolved SQL name on the reusable handle or predicate.
  */
-type Alias<T extends Entity> = {
+export type Alias<T extends Entity> = {
   readonly [aliasMgmt]: AliasBrand<T>;
 } & { [P in keyof FieldsOf<T>]: P extends "id" ? EntityAlias<T> : FieldsOf<T>[P] extends {
   kind: "primitive" | "enum";
@@ -60,10 +60,10 @@ type Alias<T extends Entity> = {
   type: infer U extends Entity;
 } ? PolyAlias<U> : never; };
 /** A domain column accepted on the other side of a cross-alias comparison. */
-interface AliasColumn<V> {
+export interface AliasColumn<V> {
   readonly [aliasColumn]: V;
 }
-interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<V | N> {
+export interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<V | N> {
   eq(value: V | N | AliasColumn<V | null> | undefined): ExpressionCondition;
   ne(value: V | N | AliasColumn<V | null> | undefined): ExpressionCondition;
   in(values: readonly (V | null)[] | undefined): ExpressionCondition;
@@ -87,7 +87,7 @@ interface PrimitiveAlias<V, N extends null | never = never> extends AliasColumn<
   /** Adds an operator and expression with knex-style placeholders, without the column name. */
   raw(exp: string, bindings: readonly unknown[] | undefined): ExpressionCondition;
 }
-interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdOf<T> | N> {
+export interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdOf<T> | N> {
   eq(value: T | IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   ne(value: T | IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   in(values: readonly (T | IdOf<T> | null)[] | null | undefined): ExpressionCondition;
@@ -98,25 +98,25 @@ interface EntityAlias<T, N extends null | never = never> extends AliasColumn<IdO
   lte(value: IdOf<T> | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   raw(exp: string, bindings: readonly unknown[] | undefined): ExpressionCondition;
 }
-interface PolyAlias<T extends Entity> {
+export interface PolyAlias<T extends Entity> {
   eq(value: T | TaggedId | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   ne(value: T | TaggedId | AliasColumn<IdOf<T> | null> | null | undefined): ExpressionCondition;
   in(values: readonly (T | TaggedId)[] | undefined): ExpressionCondition;
 }
 /** Returns the runtime identity bound by the find parser. */
-declare function getAliasMgmt(alias: {
+export declare function getAliasMgmt(alias: {
   readonly [aliasMgmt]: AliasMgmt;
 }): AliasMgmt;
 /** Returns the original metadata, preserving STI subtype identity. */
-declare function getAliasMetadata<T extends Entity>(alias: Alias<T>): EntityMetadata<T>;
+export declare function getAliasMetadata<T extends Entity>(alias: Alias<T>): EntityMetadata<T>;
 /** Creates domain predicates lazily from entity field metadata. */
-declare function newAliasProxy<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
+export declare function newAliasProxy<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): Alias<T>;
 /** Recognizes only domain aliases, not physical tables. */
-declare function isAlias(value: unknown): value is Alias<Entity>;
+export declare function isAlias(value: unknown): value is Alias<Entity>;
 /** Adjusts a field's SQL alias when a base alias is bound to a CTI subtype in the join tree. */
-declare function getMaybeCtiAlias(meta: EntityMetadata, field: Field & {
+export declare function getMaybeCtiAlias(meta: EntityMetadata, field: Field & {
   aliasSuffix: string;
 }, newMeta: EntityMetadata, newAlias: string): string;
 //#endregion
-export { Alias, AliasBrand, AliasColumn, AliasMgmt, EntityAlias, PolyAlias, PrimitiveAlias, alias, aliasMgmt, aliases, getAliasMetadata, getAliasMgmt, getMaybeCtiAlias, isAlias, newAliasProxy };
+export {};
 //# sourceMappingURL=Aliases.d.mts.map

package/build/queries/find/Aliases.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Aliases.d.mts","names":[],"sources":["../../../src/queries/find/Aliases.ts"],"mappings":";;;;;;;;;iBAyBgB,MAAM,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;iBAKxE,QAAQ,mBAAmB,0CACtC,OAAO,OACN,WAAW,IAAI,EAAE,WAAW,qCAAqC,UAAU,UAAU,MAAM;cAIpF;cACP;;UAGW;EACf;EACA,MAAM;;;;;EAKN,UAAU,QAAQ,MAAM,gBAAgB,kBAAkB,eAAe,eAAe;;;UAIzE,WAAW,WAAW;WAC5B,UAAU;;;;;;;;;;;;;;;;;;;;;KAsBT,MAAM,UAAU;YAAsB,YAAY,WAAW;OACtE,WAAW,SAAS,KAAK,iBACtB,YAAY,KACZ,SAAS,GAAG;EAAa;EAA4B,YAAY;EAAG,gBAAgB;IAClF,eAAe,GAAG,sCAClB,SAAS,GAAG;EAAa;EAAa,YAAY,UAAU;EAAQ,gBAAgB;IAClF,YAAY,GAAG,sCACf,SAAS,GAAG;EAAa;EAAc,YAAY,UAAU;IAC3D,UAAU;;UAKL,YAAY;YACjB,cAAc;;UAGT,eAAe,GAAG,wCAAwC,YAAY,IAAI;EACzF,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,kBAAkB,0BAA0B;EAC/C,IAAI,kBAAkB,0BAA0B;EAChD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,KAAK,OAAO,gBAAgB;EAC5B,MAAM,OAAO,gBAAgB;EAC7B,OAAO,OAAO,gBAAgB;EAC9B,QAAQ,IAAI,eAAe,IAAI,gBAAgB;EAE/C,SAAS,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACrE,UAAU,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACtE,SAAS,OAAO,IAAI,YAAY,YAAY,gBAAgB;EAC5D,UAAU,OAAO,IAAI,YAAY,YAAY,gBAAgB;;EAE7D,WAAW,+BAA+B;;EAE1C,WAAW,+BAA+B;;EAE1C,IAAI,aAAa,2CAA2C;;UAG7C,YAAY,GAAG,wCAAwC,YAAY,KAAK,KAAK;EAC5F,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACzE,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EAEzE,GAAG,kBAAkB,IAAI,KAAK,kCAAkC;EAChE,IAAI,kBAAkB,IAAI,KAAK,kCAAkC;EACjE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,IAAI,aAAa,2CAA2C;;UAG7C,UAAU,UAAU;EACnC,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,kBAAkB,IAAI,0BAA0B;;;iBAIrC,aAAa;YAAmB,YAAY;IAAc;;iBAK1D,iBAAiB,UAAU,QAAQ,OAAO,MAAM,KAAK,eAAe;;iBAKpE,cAAc,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;iBA+BhF,QAAQ,iBAAiB,SAAS,MAAM;;iBAiMxC,iBACd,MAAM,gBACN,OAAO;EAAU;GACjB,SAAS,gBACT"}
+{"version":3,"file":"Aliases.d.mts","names":[],"sources":["../../../src/queries/find/Aliases.ts"],"mappings":";;;;;;;;;wBAyBgB,MAAM,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;wBAKxE,QAAQ,mBAAmB,0CACtC,OAAO,OACN,WAAW,IAAI,EAAE,WAAW,qCAAqC,UAAU,UAAU,MAAM;qBAIpF;cACP;;iBAGW;EACf;EACA,MAAM;;;;;EAKN,UAAU,QAAQ,MAAM,gBAAgB,kBAAkB,eAAe,eAAe;;;iBAIzE,WAAW,WAAW;WAC5B,UAAU;;;;;;;;;;;;;;;;;;;;;YAsBT,MAAM,UAAU;YAAsB,YAAY,WAAW;OACtE,WAAW,SAAS,KAAK,iBACtB,YAAY,KACZ,SAAS,GAAG;EAAa;EAA4B,YAAY;EAAG,gBAAgB;IAClF,eAAe,GAAG,sCAClB,SAAS,GAAG;EAAa;EAAa,YAAY,UAAU;EAAQ,gBAAgB;IAClF,YAAY,GAAG,sCACf,SAAS,GAAG;EAAa;EAAc,YAAY,UAAU;IAC3D,UAAU;;iBAKL,YAAY;YACjB,cAAc;;iBAGT,eAAe,GAAG,wCAAwC,YAAY,IAAI;EACzF,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,OAAO,IAAI,IAAI,YAAY,wBAAwB;EACtD,GAAG,kBAAkB,0BAA0B;EAC/C,IAAI,kBAAkB,0BAA0B;EAChD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,GAAG,OAAO,IAAI,YAAY,wBAAwB;EAClD,IAAI,OAAO,IAAI,YAAY,wBAAwB;EACnD,KAAK,OAAO,gBAAgB;EAC5B,MAAM,OAAO,gBAAgB;EAC7B,OAAO,OAAO,gBAAgB;EAC9B,QAAQ,IAAI,eAAe,IAAI,gBAAgB;EAE/C,SAAS,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACrE,UAAU,gBAAgB,IAAI,YAAY,YAAY,gBAAgB;EACtE,SAAS,OAAO,IAAI,YAAY,YAAY,gBAAgB;EAC5D,UAAU,OAAO,IAAI,YAAY,YAAY,gBAAgB;;EAE7D,WAAW,+BAA+B;;EAE1C,WAAW,+BAA+B;;EAE1C,IAAI,aAAa,2CAA2C;;iBAG7C,YAAY,GAAG,wCAAwC,YAAY,KAAK,KAAK;EAC5F,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACzE,GAAG,OAAO,IAAI,KAAK,KAAK,YAAY,KAAK,gCAAgC;EAEzE,GAAG,kBAAkB,IAAI,KAAK,kCAAkC;EAChE,IAAI,kBAAkB,IAAI,KAAK,kCAAkC;EACjE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,GAAG,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACrE,IAAI,OAAO,KAAK,KAAK,YAAY,KAAK,gCAAgC;EACtE,IAAI,aAAa,2CAA2C;;iBAG7C,UAAU,UAAU;EACnC,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,OAAO,IAAI,WAAW,YAAY,KAAK,gCAAgC;EAC1E,GAAG,kBAAkB,IAAI,0BAA0B;;;wBAIrC,aAAa;YAAmB,YAAY;IAAc;;wBAK1D,iBAAiB,UAAU,QAAQ,OAAO,MAAM,KAAK,eAAe;;wBAKpE,cAAc,UAAU,QAAQ,MAAM,+BAA+B,KAAK,MAAM;;wBA+BhF,QAAQ,iBAAiB,SAAS,MAAM;;wBAiMxC,iBACd,MAAM,gBACN,OAAO;EAAU;GACjB,SAAS,gBACT"}

package/build/queries/find/DeferredAlias.d.cts

@@ -3,20 +3,19 @@ import { PredicateBrand } from "../conditions.cjs";
 import { AliasMgmt } from "./Aliases.cjs";
 import { EntityMetadata } from "../../EntityMetadata.cjs";
 //#region src/queries/find/DeferredAlias.d.ts
-declare const deferredAliasSym: unique symbol;
+export declare const deferredAliasSym: unique symbol;
 /** Resolves a domain alias to this em.find parse's binding. */
-type AliasResolver = (handle: AliasMgmt) => {
+export type AliasResolver = (handle: AliasMgmt) => {
   meta: EntityMetadata;
   alias: string;
 };
 /** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */
-interface DeferredAliasCondition<C = ColumnCondition | RawCondition> extends PredicateBrand<"domain"> {
+export interface DeferredAliasCondition<C = ColumnCondition | RawCondition> extends PredicateBrand<"domain"> {
   [deferredAliasSym]: (resolve: AliasResolver) => C;
 }
 /** Detects conditions that carry a per-parse alias resolver. */
-declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
+export declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
 /** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
-declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
+export declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
 //#endregion
-export { AliasResolver, DeferredAliasCondition, deferredAliasSym, isDeferredAliasCondition, withDeferredAlias };
 //# sourceMappingURL=DeferredAlias.d.cts.map

package/build/queries/find/DeferredAlias.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"DeferredAlias.d.cts","names":[],"sources":["../../../src/queries/find/DeferredAlias.ts"],"mappings":";;;;;cAMa;;KAGD,iBAAiB,QAAQ;EACnC,MAAM;EACN;;;UAIe,uBAAuB,IAAI,kBAAkB,sBAAsB;GACjF,oBAAoB,SAAS,kBAAkB;;;iBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;iBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}
+{"version":3,"file":"DeferredAlias.d.cts","names":[],"sources":["../../../src/queries/find/DeferredAlias.ts"],"mappings":";;;;;qBAMa;;YAGD,iBAAiB,QAAQ;EACnC,MAAM;EACN;;;iBAIe,uBAAuB,IAAI,kBAAkB,sBAAsB;GACjF,oBAAoB,SAAS,kBAAkB;;;wBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;wBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}

package/build/queries/find/DeferredAlias.d.mts

@@ -3,20 +3,19 @@ import { PredicateBrand } from "../conditions.mjs";
 import { AliasMgmt } from "./Aliases.mjs";
 import { EntityMetadata } from "../../EntityMetadata.mjs";
 //#region src/queries/find/DeferredAlias.d.ts
-declare const deferredAliasSym: unique symbol;
+export declare const deferredAliasSym: unique symbol;
 /** Resolves a domain alias to this em.find parse's binding. */
-type AliasResolver = (handle: AliasMgmt) => {
+export type AliasResolver = (handle: AliasMgmt) => {
   meta: EntityMetadata;
   alias: string;
 };
 /** A domain condition whose SQL aliases are resolved afresh for each occurrence in em.find. */
-interface DeferredAliasCondition<C = ColumnCondition | RawCondition> extends PredicateBrand<"domain"> {
+export interface DeferredAliasCondition<C = ColumnCondition | RawCondition> extends PredicateBrand<"domain"> {
   [deferredAliasSym]: (resolve: AliasResolver) => C;
 }
 /** Detects conditions that carry a per-parse alias resolver. */
-declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
+export declare function isDeferredAliasCondition<C>(cond: C): cond is C & DeferredAliasCondition<C>;
 /** Tags a condition without changing its enumerable shape; resolution only mutates a fresh copy. */
-declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
+export declare function withDeferredAlias<C extends object>(cond: C, resolve: (r: AliasResolver, copy: C) => void): C & DeferredAliasCondition<C>;
 //#endregion
-export { AliasResolver, DeferredAliasCondition, deferredAliasSym, isDeferredAliasCondition, withDeferredAlias };
 //# sourceMappingURL=DeferredAlias.d.mts.map

package/build/queries/find/DeferredAlias.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"DeferredAlias.d.mts","names":[],"sources":["../../../src/queries/find/DeferredAlias.ts"],"mappings":";;;;;cAMa;;KAGD,iBAAiB,QAAQ;EACnC,MAAM;EACN;;;UAIe,uBAAuB,IAAI,kBAAkB,sBAAsB;GACjF,oBAAoB,SAAS,kBAAkB;;;iBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;iBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}
+{"version":3,"file":"DeferredAlias.d.mts","names":[],"sources":["../../../src/queries/find/DeferredAlias.ts"],"mappings":";;;;;qBAMa;;YAGD,iBAAiB,QAAQ;EACnC,MAAM;EACN;;;iBAIe,uBAAuB,IAAI,kBAAkB,sBAAsB;GACjF,oBAAoB,SAAS,kBAAkB;;;wBAIlC,yBAAyB,GAAG,MAAM,IAAI,QAAQ,IAAI,uBAAuB;;wBAKzE,kBAAkB,kBAChC,MAAM,GACN,UAAU,GAAG,eAAe,MAAM,aACjC,IAAI,uBAAuB"}

package/build/queries/find/EntityFilter.d.cts

@@ -6,7 +6,7 @@ import { FindFilterOptions, IdOf } from "../../EntityManager.cjs";
 import { Entity } from "../../Entity.cjs";
 //#region src/queries/find/EntityFilter.d.ts
 /** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
-type FilterAndSettings<T extends Entity> = {
+export type FilterAndSettings<T extends Entity> = {
   where: FindFilter<T>;
   conditions?: ExpressionFilter;
   orderBy?: OrderOf<T> | OrderOf<T>[];
@@ -16,7 +16,7 @@ type FilterAndSettings<T extends Entity> = {
   allowMultipleLeftJoins?: boolean;
   optimizeJoinsToExists?: boolean;
 };
-type OrderBy = "ASC" | "DESC";
+export type OrderBy = "ASC" | "DESC";
 /**
  * A filter for an entity of type `T` for `em.find` inline conditions.
  *
@@ -28,16 +28,16 @@ type OrderBy = "ASC" | "DESC";
  * @typeparam F The filter type for the entity, i.e. `AuthorFilter`
  * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.
  */
-type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
+export type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
   ne: T | I | N | undefined;
 } | boolean | Alias<T>;
 /** A nested object filter, including logical composition at the current entity alias. */
-type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
+export type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
   as?: Alias<T>;
   and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
   or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
 } & F;
-type BooleanFilter<N> = true | false | N;
+export type BooleanFilter<N> = true | false | N;
 /**
  * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.
  *
@@ -47,10 +47,10 @@ type BooleanFilter<N> = true | false | N;
  * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't
  * supply, so the shape lives on `EntityFilterObject` and this just specializes it.
  */
-type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
+export type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
 /** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */
-type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
-type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
+export type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
+export type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
   unique: true;
 } ? K : never]?: FilterOf<T>[K]; };
 /**
@@ -59,7 +59,7 @@ type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf
  * We always allow `undefined` to support condition pruning, but only conditionally
  * allow `null` if the column is actually nullable.
  */
-type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
+export type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
   eq: V | N | undefined;
 } | {
   ne: V | N | undefined;
@@ -114,14 +114,13 @@ type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
  *
  * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.
  */
-type ExpressionFilter = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;
+export type ExpressionFilter = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;
 /** A domain-alias predicate or nested group for em.find and scopes, not SQL table expressions. */
-type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;
+export type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;
 /** Merges root-scope find settings with caller options, letting caller options win. */
-declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
+export declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
   where: FindFilter<T>;
   options: FindFilterOptions<T>;
 };
 //#endregion
-export { BooleanFilter, EntityFilter, EntityFilterObject, ExpressionCondition, ExpressionFilter, FilterAndSettings, FilterWithAlias, FindFilter, OrderBy, UniqueFilter, ValueFilter, mergeFindOptions };
 //# sourceMappingURL=EntityFilter.d.cts.map

package/build/queries/find/EntityFilter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityFilter.d.cts","names":[],"sources":["../../../src/queries/find/EntityFilter.ts"],"mappings":";;;;;;;;KAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;KAGU;;;;;;;;;;;;KAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;KAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;KAEQ,cAAc,oBAAoB;;;;;;;;;;KAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;KAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;KAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;KASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;KAOP,mBAAmB,aAAa,uBAAuB,YAAY;;KAGnE,sBAAsB,mBAAmB,kBAAkB;;iBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}
+{"version":3,"file":"EntityFilter.d.cts","names":[],"sources":["../../../src/queries/find/EntityFilter.ts"],"mappings":";;;;;;;;YAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;YAGU;;;;;;;;;;;;YAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;YAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;YAEQ,cAAc,oBAAoB;;;;;;;;;;YAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;YAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;YAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;YASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;YAOP,mBAAmB,aAAa,uBAAuB,YAAY;;YAGnE,sBAAsB,mBAAmB,kBAAkB;;wBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}