@rvoh/dream 2.12.1 → 2.13.1

package/dist/cjs/src/Dream.js

@@ -2020,10 +2020,10 @@ export default class Dream {
      * //       as: 'ratings',
      * //       polymorphic: true,
      * //       source: 'ratings',
-     * //       where: undefined,
-     * //       whereNot: undefined,
-     * //       selfWhere: undefined,
-     * //       selfWhereNot: undefined,
+     * //       and: undefined,
+     * //       andNot: undefined,
+     * //       selfAnd: undefined,
+     * //       selfAndNot: undefined,
      * //       primaryKeyOverride: null,
      * //       primaryKey: [Function: primaryKey],
      * //       primaryKeyValue: [Function: primaryKeyValue],

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -1007,7 +1007,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 joinAndStatements: query['innerJoinAndStatements'],
                 dreamClass: query['dreamClass'],
                 // As recursivelyJoin progresses through the chain of associations that
-                // the developer has inclued in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
+                // the developer has included in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
                 // previousTableAlias will be modified so that the join statement can properly reference
                 // what we are joining on. When an `associationQuery` is the start of a join, then `baseSqlAlias` is set,
                 // this is passed into the very beginning of recursivelyJoin.
@@ -1022,7 +1022,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 joinAndStatements: query['leftJoinAndStatements'],
                 dreamClass: query['dreamClass'],
                 // As recursivelyJoin progresses through the chain of associations that
-                // the developer has inclued in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
+                // the developer has included in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
                 // previousTableAlias will be modified so that the join statement can properly reference
                 // what we are joining on. When an `associationQuery` is the start of a join, then `baseSqlAlias` is set,
                 // this is passed into the very beginning of recursivelyJoin.
@@ -1367,6 +1367,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     namespaceColumn(column, alias = this.query['baseSqlAlias']) {
         return namespaceColumn(column, alias);
     }
+    /**
+     * @internal
+     *
+     * Builds the table expression passed to Kysely's `innerJoin`/`leftJoin` for an
+     * association. When the alias already snakeifies to the table name, Kysely's
+     * CamelCasePlugin emits the correct identifier from the alias alone, so no
+     * explicit `as` clause is needed; otherwise we join the table aliased as `alias`.
+     *
+     * @returns A table expression string, e.g. `"beautiful_balloons as balloon"`
+     */
+    aliasedJoinTableExpression(tableName, alias) {
+        return snakeify(alias) === tableName ? alias : `${tableName} as ${alias}`;
+    }
     checkForQueryViolations() {
         const invalidWhereNotClauses = this.similarityStatementBuilder().whereNotStatementsWithSimilarityClauses();
         if (invalidWhereNotClauses.length) {
@@ -1502,12 +1515,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      */
     joinsBridgeThroughAssociations({ query, dreamClassTheAssociationIsDefinedOn, throughAssociation, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1628,12 +1648,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     }
     applyOneJoin({ query, dreamClass, association, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1672,12 +1699,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     }
     addAssociationJoinStatementToQuery({ query, dreamClass, association, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1714,7 +1748,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     leftJoinStatements: this.query['leftJoinStatements'],
                 });
             const to = (dreamClassThroughAssociationWantsToHydrate ?? association.modelCB()).table;
-            const joinTableExpression = snakeify(currentTableAlias) === to ? currentTableAlias : `${to} as ${currentTableAlias}`;
+            const joinTableExpression = this.aliasedJoinTableExpression(to, currentTableAlias);
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
                 join = join.onRef(this.namespaceColumn(association.foreignKey(), previousTableAlias), '=', this.namespaceColumn(association.primaryKey(undefined, {
                     associatedClassOverride: dreamClassThroughAssociationWantsToHydrate,
@@ -1747,7 +1781,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         }
         else {
             const to = association.modelCB().table;
-            const joinTableExpression = snakeify(currentTableAlias) === to ? currentTableAlias : `${to} as ${currentTableAlias}`;
+            const joinTableExpression = this.aliasedJoinTableExpression(to, currentTableAlias);
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
                 join = join.onRef(this.namespaceColumn(association.primaryKey(), previousTableAlias), '=', this.namespaceColumn(association.foreignKey(), currentTableAlias));
                 if (association.polymorphic) {

package/dist/cjs/src/helpers/range.js

@@ -9,7 +9,7 @@ export class Range {
         this.begin = begin;
         this.end = end;
         this.excludeEnd = excludeEnd;
-        if (!begin && !end)
+        if (begin == null && end == null)
             throw new Error('Must pass either begin or end to a range');
     }
 }

package/dist/cjs/src/utils/datetime/DateTime.js

@@ -682,14 +682,23 @@ export class DateTime {
         return this.luxonDatetime.toJSDate();
     }
     /**
-     * Returns an ISO 8601 string representation (for valueOf() operations).
+     * Returns a UTC-normalized ISO 8601 string representation (for valueOf() operations).
      *
-     * Preserves the timezone of the DateTime instance.
+     * Unlike {@link DateTime.toISO} / {@link DateTime.toString} / {@link DateTime.toJSON}, which
+     * preserve the instance's zone, `valueOf` always normalizes to UTC (`…Z`) before stringifying.
+     * Because every value is rendered in the same zone with fixed-width 6-digit fractional seconds,
+     * JavaScript's relational operators (`<`, `>`, `<=`, `>=`), loose `==`, and `+` — which route
+     * through `valueOf` — order and compare by the underlying instant rather than by wall-clock text.
+     * This makes cross-zone comparisons correct. As a consequence `dt + ''` and `Number(dt)` reflect
+     * UTC, while `` `${dt}` ``, `toString`, and `toJSON` stay local because they don't use `valueOf`.
      *
-     * @returns ISO datetime string with microsecond precision
+     * Limit: lexical ordering equals chronological ordering only for years 0001–9999. BC/negative
+     * years and years ≥ 10000 sort incorrectly (ISO's `-`/`+` year prefixes break lexical order).
+     *
+     * @returns UTC ISO datetime string with microsecond precision
      * @example
      * ```ts
-     * DateTime.local(2017, 3, 12).valueOf() // Preserves local timezone
+     * DateTime.local(2017, 3, 12).valueOf()                                  // UTC-normalized ISO string
      * DateTime.fromISO('2026-02-07T09:03:44.123456Z').valueOf()              // '2026-02-07T09:03:44.123456Z'
      * ```
      */
@@ -697,7 +706,7 @@ export class DateTime {
     valueOf() {
         if (this._valueOf)
             return this._valueOf;
-        this._valueOf = this.toISO();
+        this._valueOf = this.toUTC().toISO();
         return this._valueOf;
     }
     /**

package/dist/esm/src/Dream.js

@@ -2020,10 +2020,10 @@ export default class Dream {
      * //       as: 'ratings',
      * //       polymorphic: true,
      * //       source: 'ratings',
-     * //       where: undefined,
-     * //       whereNot: undefined,
-     * //       selfWhere: undefined,
-     * //       selfWhereNot: undefined,
+     * //       and: undefined,
+     * //       andNot: undefined,
+     * //       selfAnd: undefined,
+     * //       selfAndNot: undefined,
      * //       primaryKeyOverride: null,
      * //       primaryKey: [Function: primaryKey],
      * //       primaryKeyValue: [Function: primaryKeyValue],

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -1007,7 +1007,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 joinAndStatements: query['innerJoinAndStatements'],
                 dreamClass: query['dreamClass'],
                 // As recursivelyJoin progresses through the chain of associations that
-                // the developer has inclued in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
+                // the developer has included in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
                 // previousTableAlias will be modified so that the join statement can properly reference
                 // what we are joining on. When an `associationQuery` is the start of a join, then `baseSqlAlias` is set,
                 // this is passed into the very beginning of recursivelyJoin.
@@ -1022,7 +1022,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                 joinAndStatements: query['leftJoinAndStatements'],
                 dreamClass: query['dreamClass'],
                 // As recursivelyJoin progresses through the chain of associations that
-                // the developer has inclued in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
+                // the developer has included in a join statement (e.g. `leftJoinPreload('hello as ho', 'world as wd')`),
                 // previousTableAlias will be modified so that the join statement can properly reference
                 // what we are joining on. When an `associationQuery` is the start of a join, then `baseSqlAlias` is set,
                 // this is passed into the very beginning of recursivelyJoin.
@@ -1367,6 +1367,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     namespaceColumn(column, alias = this.query['baseSqlAlias']) {
         return namespaceColumn(column, alias);
     }
+    /**
+     * @internal
+     *
+     * Builds the table expression passed to Kysely's `innerJoin`/`leftJoin` for an
+     * association. When the alias already snakeifies to the table name, Kysely's
+     * CamelCasePlugin emits the correct identifier from the alias alone, so no
+     * explicit `as` clause is needed; otherwise we join the table aliased as `alias`.
+     *
+     * @returns A table expression string, e.g. `"beautiful_balloons as balloon"`
+     */
+    aliasedJoinTableExpression(tableName, alias) {
+        return snakeify(alias) === tableName ? alias : `${tableName} as ${alias}`;
+    }
     checkForQueryViolations() {
         const invalidWhereNotClauses = this.similarityStatementBuilder().whereNotStatementsWithSimilarityClauses();
         if (invalidWhereNotClauses.length) {
@@ -1502,12 +1515,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      */
     joinsBridgeThroughAssociations({ query, dreamClassTheAssociationIsDefinedOn, throughAssociation, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1628,12 +1648,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     }
     applyOneJoin({ query, dreamClass, association, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1672,12 +1699,19 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     }
     addAssociationJoinStatementToQuery({ query, dreamClass, association, 
     /**
-     * If the join statement includes an explicit alias, e.g.,
-     * `leftJoinPreload('hello as ho', 'world as wd')`
-     * then explicitAlias is set (e.g., to 'ho' the first time that `recursivelyJoin`
-     * calls this method and to 'ho' the second time `recursivelyJoin` is called)
-     * If only implicit aliasing happens (based on association name)
-     * (e.g. `leftJoinPreload('hello', 'world')`), then explicitAlias is null
+     * The table alias to use for the association being joined.
+     *
+     * When the join statement includes an explicit alias, e.g.
+     * `leftJoinPreload('hello as ho', 'world as wd')`, explicitAlias is that
+     * alias ('ho' for `hello`, 'wd' for `world`).
+     *
+     * When no explicit alias is given (e.g. `leftJoinPreload('hello', 'world')`),
+     * `recursivelyJoin` passes the association name itself ('hello', 'world') as
+     * the alias, so explicitAlias is still defined.
+     *
+     * explicitAlias is only `undefined` for the intermediate join tables that
+     * `joinsBridgeThroughAssociations` synthesizes while bridging a `through`
+     * association — those tables are never aliased by the developer.
      */
     explicitAlias, 
     /**
@@ -1714,7 +1748,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     leftJoinStatements: this.query['leftJoinStatements'],
                 });
             const to = (dreamClassThroughAssociationWantsToHydrate ?? association.modelCB()).table;
-            const joinTableExpression = snakeify(currentTableAlias) === to ? currentTableAlias : `${to} as ${currentTableAlias}`;
+            const joinTableExpression = this.aliasedJoinTableExpression(to, currentTableAlias);
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
                 join = join.onRef(this.namespaceColumn(association.foreignKey(), previousTableAlias), '=', this.namespaceColumn(association.primaryKey(undefined, {
                     associatedClassOverride: dreamClassThroughAssociationWantsToHydrate,
@@ -1747,7 +1781,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         }
         else {
             const to = association.modelCB().table;
-            const joinTableExpression = snakeify(currentTableAlias) === to ? currentTableAlias : `${to} as ${currentTableAlias}`;
+            const joinTableExpression = this.aliasedJoinTableExpression(to, currentTableAlias);
             query = query[(joinType === 'inner' ? 'innerJoin' : 'leftJoin')](joinTableExpression, (join) => {
                 join = join.onRef(this.namespaceColumn(association.primaryKey(), previousTableAlias), '=', this.namespaceColumn(association.foreignKey(), currentTableAlias));
                 if (association.polymorphic) {

package/dist/esm/src/helpers/range.js

@@ -9,7 +9,7 @@ export class Range {
         this.begin = begin;
         this.end = end;
         this.excludeEnd = excludeEnd;
-        if (!begin && !end)
+        if (begin == null && end == null)
             throw new Error('Must pass either begin or end to a range');
     }
 }

package/dist/esm/src/utils/datetime/DateTime.js

@@ -682,14 +682,23 @@ export class DateTime {
         return this.luxonDatetime.toJSDate();
     }
     /**
-     * Returns an ISO 8601 string representation (for valueOf() operations).
+     * Returns a UTC-normalized ISO 8601 string representation (for valueOf() operations).
      *
-     * Preserves the timezone of the DateTime instance.
+     * Unlike {@link DateTime.toISO} / {@link DateTime.toString} / {@link DateTime.toJSON}, which
+     * preserve the instance's zone, `valueOf` always normalizes to UTC (`…Z`) before stringifying.
+     * Because every value is rendered in the same zone with fixed-width 6-digit fractional seconds,
+     * JavaScript's relational operators (`<`, `>`, `<=`, `>=`), loose `==`, and `+` — which route
+     * through `valueOf` — order and compare by the underlying instant rather than by wall-clock text.
+     * This makes cross-zone comparisons correct. As a consequence `dt + ''` and `Number(dt)` reflect
+     * UTC, while `` `${dt}` ``, `toString`, and `toJSON` stay local because they don't use `valueOf`.
      *
-     * @returns ISO datetime string with microsecond precision
+     * Limit: lexical ordering equals chronological ordering only for years 0001–9999. BC/negative
+     * years and years ≥ 10000 sort incorrectly (ISO's `-`/`+` year prefixes break lexical order).
+     *
+     * @returns UTC ISO datetime string with microsecond precision
      * @example
      * ```ts
-     * DateTime.local(2017, 3, 12).valueOf() // Preserves local timezone
+     * DateTime.local(2017, 3, 12).valueOf()                                  // UTC-normalized ISO string
      * DateTime.fromISO('2026-02-07T09:03:44.123456Z').valueOf()              // '2026-02-07T09:03:44.123456Z'
      * ```
      */
@@ -697,7 +706,7 @@ export class DateTime {
     valueOf() {
         if (this._valueOf)
             return this._valueOf;
-        this._valueOf = this.toISO();
+        this._valueOf = this.toUTC().toISO();
         return this._valueOf;
     }
     /**

package/dist/types/src/Dream.d.ts

@@ -1660,10 +1660,10 @@ export default class Dream {
      * //       as: 'ratings',
      * //       polymorphic: true,
      * //       source: 'ratings',
-     * //       where: undefined,
-     * //       whereNot: undefined,
-     * //       selfWhere: undefined,
-     * //       selfWhereNot: undefined,
+     * //       and: undefined,
+     * //       andNot: undefined,
+     * //       selfAnd: undefined,
+     * //       selfAndNot: undefined,
      * //       primaryKeyOverride: null,
      * //       primaryKey: [Function: primaryKey],
      * //       primaryKeyValue: [Function: primaryKeyValue],

package/dist/types/src/db/migration-helpers/DreamMigrationHelpers.d.ts

@@ -154,11 +154,11 @@ interface DropValueFromEnumTablesAndColumnsForArrayBase {
     array: true;
 }
 interface DropValueWithRemovalFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
-    behavior: 'replace';
-    replaceWith: string;
+    behavior: 'remove';
 }
 interface DropValueWithReplacementFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
-    behavior: 'remove';
+    behavior: 'replace';
+    replaceWith: string;
 }
 type DropValueFromEnumTablesAndColumnsForNonArray = {
     table: string;

package/dist/types/src/dream/QueryDriver/Kysely.d.ts

@@ -362,6 +362,17 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns A string
      */
     private namespaceColumn;
+    /**
+     * @internal
+     *
+     * Builds the table expression passed to Kysely's `innerJoin`/`leftJoin` for an
+     * association. When the alias already snakeifies to the table name, Kysely's
+     * CamelCasePlugin emits the correct identifier from the alias alone, so no
+     * explicit `as` clause is needed; otherwise we join the table aliased as `alias`.
+     *
+     * @returns A table expression string, e.g. `"beautiful_balloons as balloon"`
+     */
+    private aliasedJoinTableExpression;
     private checkForQueryViolations;
     private similarityStatementBuilder;
     /**

package/dist/types/src/types/utils.d.ts

@@ -59,7 +59,7 @@ type DecrementTable = {
     12: 11;
     13: 12;
     14: 13;
-    15: 15;
+    15: 14;
     16: 15;
     17: 16;
     18: 17;

package/dist/types/src/types/utils.ts

@@ -74,7 +74,7 @@ type DecrementTable = {
   12: 11
   13: 12
   14: 13
-  15: 15
+  15: 14
   16: 15
   17: 16
   18: 17

package/dist/types/src/types/variadic.d.ts

@@ -23,7 +23,7 @@ export type VariadicJoinsArgs<I extends Dream, DB, Schema, ConcreteTableName ext
 type VariadicCheckThenRecurse<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, AssociationNamesOrOnClause, LastDream extends Dream = I, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], AllowedNamesForArrayArg = PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : keyof SchemaAssociations & string, NthArgument extends VALID | INVALID = ConcreteArgs['length'] extends 0 ? VALID : ConcreteArgs[0] extends keyof SchemaAssociations & string ? VALID : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? VALID : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? VALID : ConcreteArgs[0] extends readonly AllowedNamesForArrayArg[] ? VALID : ConcreteArgs[0] extends JoinAndStatements<LastDream, DB, Schema, ConcreteTableName, RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>> ? VALID : ConcreteArgs[0] extends AllowedNamesForArrayArg ? VALID : INVALID> = NthArgument extends INVALID ? `invalid where clause in argument ${Inc<Depth>}` : ConcreteArgs['length'] extends 0 ? AssociationNamesOrOnClause : VariadicRecurse<I, DB, Schema, ConcreteTableName, ConcreteArgs, RecursionType, UsedNamespaces, Depth, PreviousConcreteTableName, ConcreteAssociationName, LastDream>;
 export type AliasedSchemaAssociation<Schema, ConcreteTableName extends keyof Schema, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]]> = `${keyof SchemaAssociations & string} as ${string}`;
 type VariadicRecurse<I extends Dream, DB, Schema, ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, ConcreteArgs extends readonly unknown[], RecursionType extends RecursionTypes, UsedNamespaces, Depth extends number, PreviousConcreteTableName, ConcreteAssociationName, LastDream extends Dream, SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]], PolymorphicTableNamesUnion = PreviousConcreteTableName extends keyof Schema ? AssociationTableNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : ConcreteTableName, CrossPolymorphicTableForCurrentArg = ConcreteArgs[0] extends string ? TableContainingAssociationInUnion<Schema, PolymorphicTableNamesUnion, ConcreteArgs[0]> : never, EffectiveConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = ConcreteArgs[0] extends keyof SchemaAssociations & string ? ConcreteTableName : [CrossPolymorphicTableForCurrentArg] extends [never] ? ConcreteTableName : CrossPolymorphicTableForCurrentArg extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB ? CrossPolymorphicTableForCurrentArg : ConcreteTableName, EffectiveSchemaAssociations = Schema[EffectiveConcreteTableName]['associations' & keyof Schema[EffectiveConcreteTableName]], ConcreteNthArg extends (keyof SchemaAssociations & string) | (keyof EffectiveSchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName> | null = ConcreteArgs[0] extends undefined ? null : ConcreteArgs[0] extends null ? null : ConcreteArgs[0] extends keyof SchemaAssociations & string ? ConcreteArgs[0] & keyof SchemaAssociations & string : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? ConcreteArgs[0] & AliasedSchemaAssociation<Schema, ConcreteTableName> : ConcreteArgs[0] extends keyof EffectiveSchemaAssociations & string ? ConcreteArgs[0] & keyof EffectiveSchemaAssociations & string : null, NextUsedNamespaces = ConcreteArgs[0] extends undefined ? never : ConcreteArgs[0] extends null ? never : ConcreteNthArg extends null ? UsedNamespaces : UsedNamespaces | ConcreteNthArg, CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME | IS_NOT_ASSOCIATION_NAME = ConcreteNthArg extends null ? IS_NOT_ASSOCIATION_NAME : ConcreteNthArg extends keyof SchemaAssociations & string ? IS_ASSOCIATION_NAME : ConcreteNthArg extends AliasedSchemaAssociation<Schema, ConcreteTableName> ? IS_ASSOCIATION_ALIAS : ConcreteNthArg extends keyof EffectiveSchemaAssociations & string ? IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME : IS_NOT_ASSOCIATION_NAME, NextPreviousConcreteTableName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteTableName : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteTableName : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? EffectiveConcreteTableName : PreviousConcreteTableName, NextUnaliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${infer AssocName extends string} as ${string}` ? AssocName & keyof SchemaAssociations & string : never : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? ConcreteNthArg : never, NextAliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME ? ConcreteNthArg : CurrentArgumentType extends IS_ASSOCIATION_ALIAS ? ConcreteNthArg extends `${string} as ${infer AssocAlias extends string}` ? AssocAlias & string : ConcreteAssociationName : CurrentArgumentType extends IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? ConcreteNthArg : ConcreteAssociationName, IsAssociationNameOrAlias extends boolean = CurrentArgumentType extends IS_ASSOCIATION_NAME | IS_ASSOCIATION_ALIAS | IS_CROSS_POLYMORPHIC_ASSOCIATION_NAME ? true : false, NextTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName & AssociationTableNames<DB, Schema> & keyof DB, AllowedAssociationNames = IsAssociationNameOrAlias extends true ? AssociationNamesForAssociation<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : PreviousConcreteTableName extends keyof Schema ? AssociationNamesForAssociation<Schema, PreviousConcreteTableName, ConcreteAssociationName> : AssociationNamesForTable<Schema, ConcreteTableName>, // fall back to association names for table for root only
-AssociationTableOrConcreteTable extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName, CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextAliasedAssociationName> : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<I, DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, AllowedNextArgValues, DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> extends Dream ? DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> : LastDream>;
+AssociationTableOrConcreteTable extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB = IsAssociationNameOrAlias extends true ? AssociationTableName<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : ConcreteTableName, CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName> : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>, AllowedNextArgValues = RecursionType extends 'load' ? AllowedNextArgValuesForLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys> : RecursionType extends 'leftJoinLoad' ? AllowedNextArgValuesForLeftJoinLoad<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : RecursionType extends 'join' ? AllowedNextArgValuesForJoin<DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream>, DB, Schema, AllowedAssociationNames, AssociationTableOrConcreteTable, CurrentRequiredOnClauseKeys, NextUsedNamespaces> : never> = Depth extends MAX_VARIADIC_DEPTH ? never : VariadicCheckThenRecurse<I, DB, Schema, NextTableName, ReadonlyTail<ConcreteArgs>, RecursionType, NextUsedNamespaces, Inc<Depth>, NextPreviousConcreteTableName, NextAliasedAssociationName, AllowedNextArgValues, DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> extends Dream ? DreamAssociationNameToAssociatedModel<LastDream, ConcreteArgs[0] & keyof LastDream> : LastDream>;
 type AllowedNextArgValuesForLoad<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation> = AllowedNames | AllowedNames[] | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;
 type AllowedNextArgValuesForLeftJoinLoad<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AllowedNames, UsedNamespaces> | Exclude<AllowedNames, UsedNamespaces>[] | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;
 type AllowedNextArgValuesForJoin<I extends Dream, DB, Schema, AllowedNames, TableForJoin extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB, RequiredOnClauseKeysForThisAssociation, UsedNamespaces> = Exclude<AllowedNames, UsedNamespaces> | JoinAndStatements<I, DB, Schema, TableForJoin, RequiredOnClauseKeysForThisAssociation>;

package/dist/types/src/types/variadic.ts

@@ -341,7 +341,7 @@ type VariadicRecurse<
     : ConcreteTableName,
   //
   CurrentRequiredOnClauseKeys = IsAssociationNameOrAlias extends true
-    ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextAliasedAssociationName>
+    ? RequiredOnClauseKeys<Schema, EffectiveConcreteTableName, NextUnaliasedAssociationName>
     : RequiredOnClauseKeys<Schema, PreviousConcreteTableName, ConcreteAssociationName>,
   //
   AllowedNextArgValues = RecursionType extends 'load'

package/dist/types/src/utils/datetime/DateTime.d.ts

@@ -546,14 +546,23 @@ export declare class DateTime {
      */
     toJSDate(): Date;
     /**
-     * Returns an ISO 8601 string representation (for valueOf() operations).
+     * Returns a UTC-normalized ISO 8601 string representation (for valueOf() operations).
      *
-     * Preserves the timezone of the DateTime instance.
+     * Unlike {@link DateTime.toISO} / {@link DateTime.toString} / {@link DateTime.toJSON}, which
+     * preserve the instance's zone, `valueOf` always normalizes to UTC (`…Z`) before stringifying.
+     * Because every value is rendered in the same zone with fixed-width 6-digit fractional seconds,
+     * JavaScript's relational operators (`<`, `>`, `<=`, `>=`), loose `==`, and `+` — which route
+     * through `valueOf` — order and compare by the underlying instant rather than by wall-clock text.
+     * This makes cross-zone comparisons correct. As a consequence `dt + ''` and `Number(dt)` reflect
+     * UTC, while `` `${dt}` ``, `toString`, and `toJSON` stay local because they don't use `valueOf`.
      *
-     * @returns ISO datetime string with microsecond precision
+     * Limit: lexical ordering equals chronological ordering only for years 0001–9999. BC/negative
+     * years and years ≥ 10000 sort incorrectly (ISO's `-`/`+` year prefixes break lexical order).
+     *
+     * @returns UTC ISO datetime string with microsecond precision
      * @example
      * ```ts
-     * DateTime.local(2017, 3, 12).valueOf() // Preserves local timezone
+     * DateTime.local(2017, 3, 12).valueOf()                                  // UTC-normalized ISO string
      * DateTime.fromISO('2026-02-07T09:03:44.123456Z').valueOf()              // '2026-02-07T09:03:44.123456Z'
      * ```
      */

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVks1uAiEURt/lrtE6P+LIspomTVPbJk27MC5w5tohMmCAsZkY372hbqi1HdwAIffjHOAewGjtLLBlQtOcTEcrAgY3EksntLLADjAd+VHxBoHBS4ummxuxR3PLLQKBrVAVsCQtCLRGAoNScmvR3lTr4Vn1sHaNBHKqAAbOVgMfH5w2CJS1kJVBBWyZZpPVkUCaTQL6Q2dRdsGpPfxf9dcYJBktvIKfA4dnbd2HQRtvcSHR4+Gp4yKkzmostzOtrDNcKPcmtOT+h/5DozHa2OFf0QgHOqKhg5Zto572aDZSf8aQfwRieGke8Obc8XtV6mbHnVhLfBeu9ntrbvFOoKwiFHrPuKojxkVB/KOQhOYZSShNvhuE5tmZ9mu3w9Pt/epR2Ia7so70vRyOeT6aBB4L7RatlNe0ynmkj3k8fgGG6267"
+window.hierarchyData = "eJyVkkFvwiAUx7/LO6OzaFvLcZolyzK3Jct2MB6wfa5ECgaoS2P87gvzwpxb8QKEvD+/H/AOYLR2FtgyyeiUFKMVAYMbiaUTWllgByhGflS8QWDw0qLp5kbs0dxyi0BgK1QFLKFTAq2RwKCU3Fq0N9V6eFY9rF0jgZwqgIGz1cDHB6cNAmUtZGVQAVvScb46EqDjPKA/dBZlF5zaw/9Vf41BMs6pV/Bz4PCsrfswaOMtLiR6PDw1LULqrMZyO9PKOsOFcm9CS+5/6D80GqONHf4VjXDIkvDvZ1q2jXrao9lI/RlD/hGI4dFpwJtzx+9VqZsdd2It8V242u+tucU7gbKKUOg946qOSAtK/KOQJJvkJMmy9LtBskl+pv3a7fB0e796FLbhrqwjfS+HY54vSwOPhXaLVsprWuU80sc8Hr8AarputQ=="