@zerotal/orm 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -8,11 +8,58 @@ follows the Zerotal monorepo's unified versioning.
 
 ## [Unreleased]
 
+## [1.3.0] — 2026-08-09
+
+### Changed — BREAKING
+
+- **`BaseModelWith(...)` is replaced by the `Model.using(...)` static.** Mixin composition is now
+  a property of the base class rather than a helper shipped alongside it, so there is one idiom to
+  learn and nothing extra to import.
+
+  ```ts
+  // before
+  import { BaseModelWith } from "@zerotal/orm";
+  class User extends BaseModelWith(Authenticatable, Permissions, Roles) {}
+
+  // after
+  import { Model } from "@zerotal/orm";
+  class User extends Model.using(Authenticatable, Permissions, Roles) {}
+  ```
+
+  Run `bun run scripts/codemod-mixin-composition.ts` to rewrite call sites and imports.
+
+  How mixins are **authored** is unchanged — `<T extends Constructor>(Base: T) => class extends Base`
+  still works exactly as before, and every shipped mixin (`SoftDeletes`, `State`, `Authenticatable`,
+  `Roles`, `Permissions`, `Notifiable`, `Tenantable`, `Auditable`, …) keeps its signature. The
+  `Constructor` and `Mixin` types are still exported; `Compose` (the type of `Model.using`) joins
+  them. Mixin authors declaring columns still call `registerColumn` imperatively.
+
+  `with` was deliberately **not** used for this. It is reserved for the eager-load static
+  (`User.with("posts")`), the one conspicuous gap in the model's existing query-forwarder family
+  (`where`, `whereIn`, `orderBy`, `latest`, `first`, `paginate`, `find`, `all`, `count`, …).
+
+### Changed
+
+- **`Model` is now the canonical name for the base class; `BaseModel` is the alias.** They are the
+  same class object and both remain exported, so no code breaks — but `class User extends Model {}`
+  is the documented form from here, mirroring Flow's `class PostsPage extends Component {}`.
+  `BaseModel` was previously the canonical name and `Model` an unused compat alias added in 1.0.2.
+
+### Added
+
+- **`using` composes onto any class in the chain, not just the root.** An app-level base model can
+  now carry mixins without being flattened out of the prototype chain — `AppModel.using(SoftDeletes)`
+  keeps `AppModel` and its statics in the lineage. `BaseModelWith` hardcoded `BaseModel`, so this
+  previously required hand-nesting.
+- **Composition chains.** The composed class carries `using` itself, so
+  `Model.using(a, b).using(c, d)` works past the 8-mixin overload set — which is why the overload
+  set shrank from 20 hand-written arities to 8 without losing any capability.
+
 ## [1.1.0] — 2026-08-08
 
 ### Fixed
 
-- **A `json` column returns the type it was given.** Writing skipped `JSON.stringify` for values that were already strings, so a string went into the column as bare characters — `62812345678`, not `"62812345678"` — and the read side's `JSON.parse` turned it back into a number. A `json`-cast setting holding an account number came back as a number, and only for *some* values, since a string that fails to parse fell through unchanged. Encoding is now symmetric in both directions, and `where()` against a `json` column encodes the same way, so a query finds what a write stores. **Upgrade note:** rows written by an older version hold bare scalars, so a string column may still read back as a number, and a `where()` on a string will not match those older rows — they are stored unquoted. Only affects bare scalars in `json`/`array` columns; objects and arrays were always encoded and are untouched.
+- **A `json` column returns the type it was given.** Writing skipped `JSON.stringify` for values that were already strings, so a string went into the column as bare characters — `62812345678`, not `"62812345678"` — and the read side's `JSON.parse` turned it back into a number. A `json`-cast setting holding an account number came back as a number, and only for _some_ values, since a string that fails to parse fell through unchanged. Encoding is now symmetric in both directions, and `where()` against a `json` column encodes the same way, so a query finds what a write stores. **Upgrade note:** rows written by an older version hold bare scalars, so a string column may still read back as a number, and a `where()` on a string will not match those older rows — they are stored unquoted. Only affects bare scalars in `json`/`array` columns; objects and arrays were always encoded and are untouched.
 - **`bun zt make:model` generates a file that parses.** The stub emitted `@table('posts').withTimestamps()`, which is not valid decorator syntax — the grammar allows a call at the end of the chain, not in the middle — so every generated model failed with `Expected "class" but found "."`. The stub now emits plain `@table('posts')`; timestamps are on by default and the chained form needs outer parentheses, `@(table("x").withoutTimestamps())`. The same broken form is corrected in the `BaseModel` docblocks, and every generated stub is now parsed by a test rather than checked for substrings.
 - **A column `default` is applied on insert.** A declared field that was never assigned was written as an explicit `NULL`, so the INSERT named the column, the database never applied its own default, and a `NOT NULL` column failed outright — on a model and migration that both declared `default: 0`. `undefined` now means "I didn't say": the declared default is used, or the column is omitted so the database decides. An explicit `null` still stores `NULL`.
 - **A `Date` compared against a timestamp column matches again.** Bound values are serialised through the column's cast metadata, but the framework-managed `created_at` / `updated_at` / `deleted_at` carry no `@column` registration — so a `Date` was bound raw and matched nothing. `where("created_at", ">=", monthStart)` is the commonest reporting query there is, and it silently returned zero rows: a dashboard reading "0 this month" looks like a quiet month, not a broken query.

package/README.md

@@ -43,11 +43,11 @@ export default DatabaseConfig({
 ### Define a model
 
 ```ts
-import { BaseModel, column, table, belongsTo, hasMany } from "@zerotal/orm";
+import { Model, column, table, belongsTo, hasMany } from "@zerotal/orm";
 import type { Columns } from "@zerotal/orm";
 
 @(table("posts").withTimestamps().withSoftDeletes())
-export class Post extends BaseModel {
+export class Post extends Model {
   static fillable: Columns<Post>[] = ["title", "body", "status", "userId"];
 
   @column("string") title!: string;
@@ -144,7 +144,7 @@ This package exposes two subpath entry points:
 
 Main exports from the default entry point:
 
-- **Models** — `BaseModel` / `Model`, `ModelQueryBuilder`, `DB`, `QueryBuilder`
+- **Models** — `Model` (aka `BaseModel`), `ModelQueryBuilder`, `DB`, `QueryBuilder`
 - **Decorators** — `column`, `table`, `belongsTo`, `hasMany`, `hasOne`, `manyToMany`, `morphTo`, `morphMany`, `morphOne`, `hasManyThrough`, `hasOneThrough`, `morphToMany`, `morphedByMany`
 - **Schema / migrations** — `Schema`, `Blueprint`, `Migration`, `MigrationRunner`, `SchemaInspector`, `ModelInspector`, `SchemaDiffer`, `synchronizeSchema`
 - **Seeding** — `Seeder`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerotal/orm",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "license": "MIT",
   "maturity": "stable",
   "private": false,
@@ -30,8 +30,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zerotal/core": "1.1.0",
-    "@zerotal/validator": "1.1.0"
+    "@zerotal/core": "1.3.0",
+    "@zerotal/validator": "1.3.0"
   },
   "devDependencies": {
     "typescript": "^5.8.0"

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * A Bun-native Active Record ORM built on `Bun.sql`.
  *
- * Models extend {@link BaseModel}: you declare columns with {@link column | `@column`},
+ * Models extend {@link Model}: you declare columns with {@link column | `@column`},
  * relationships with decorators like {@link hasMany | `@hasMany`} and
  * {@link belongsTo | `@belongsTo`}, and then query and persist through the model's
  * static and instance methods. Under the hood a {@link QueryBuilder} routes every
@@ -11,17 +11,17 @@
  * using the {@link Schema} facade and the {@link Blueprint} table builder.
  *
  * Mass assignment is **guarded by default** — a model with neither `fillable` nor
- * `guarded` declared rejects all attributes in {@link BaseModel.fill | `fill()`}.
+ * `guarded` declared rejects all attributes in {@link Model.fill | `fill()`}.
  * Soft deletes and state machines are opt-in mixins composed via
- * {@link BaseModelWith}. The ORM's CLI commands (`migrate`, `make:model`, …) live
+ * `Model.using(...)`. The ORM's CLI commands (`migrate`, `make:model`, …) live
  * under the `@zerotal/orm/commands` subpath.
  *
  * @example Define a model
  * ```ts
- * import { BaseModel, column, hasMany, type HasMany } from "@zerotal/orm";
+ * import { Model, column, hasMany, type HasMany } from "@zerotal/orm";
  * import { Post } from "./Post.ts";
  *
- * export class User extends BaseModel {
+ * export class User extends Model {
  *   @column({ primary: true }) id!: number;
  *   @column() email!: string;
  *   @column() name!: string;
@@ -70,12 +70,14 @@
 
 // @zerotal/orm — public API barrel
 
-export { BaseModel, Model } from "./model/BaseModel.ts";
-export { BaseModelWith } from "./model/mixins.ts";
-export type { Constructor, Mixin } from "./model/mixins.ts";
-// State-machine behaviour is an opt-in mixin — compose with `BaseModelWith(State)`.
+// `Model` is the canonical base class; `BaseModel` is the same class under its original name.
+export { Model, BaseModel } from "./model/BaseModel.ts";
+// Mixin authoring types. Compose them onto a model with the `Model.using(...)` static —
+// `class User extends Model.using(Authenticatable, Roles)`.
+export type { Constructor, Mixin, Compose } from "./model/mixins.ts";
+// State-machine behaviour is an opt-in mixin — compose with `Model.using(State)`.
 export { State } from "./model/State.ts";
-// Soft deletes are opt-in — compose with `BaseModelWith(SoftDeletes)`.
+// Soft deletes are opt-in — compose with `Model.using(SoftDeletes)`.
 export { SoftDeletes } from "./model/SoftDeletes.ts";
 export type {
   StateDefinition,
@@ -143,7 +145,7 @@ export { column, columnRegistry } from "./model/decorators/column.ts";
 export type { ColumnOptions, ColumnShorthand } from "./model/decorators/column.ts";
 export { registerModel, modelByName, modelsByName } from "./model/decorators/_metadata.ts";
 // Imperative column registration — for mixin authors composing model behaviour with
-// BaseModelWith (the @column decorator can't run inside a returned class expression).
+// Model.using (the @column decorator can't run inside a returned class expression).
 export { registerColumn, columnsFor } from "./model/decorators/_metadata.ts";
 export { table } from "./model/decorators/table.ts";
 export type { TableDecoratorBuilder, TableOptions } from "./model/decorators/table.ts";

package/src/model/BaseModel.ts

@@ -33,6 +33,8 @@ import {
 } from "../errors/index.ts";
 import { type ManyToMany } from "./relations/RelationRegistry.ts";
 import { installReactiveAccessors, type ColumnOptions } from "./decorators/column.ts";
+import { _compose } from "./mixins.ts";
+import type { Compose } from "./mixins.ts";
 import { columnsFor, relationsFor } from "./decorators/_metadata.ts";
 import { TransactionContext } from "../db/TransactionContext.ts";
 import type { InsertPayload, UpdatePayload, FillablePayload } from "./payload.ts";
@@ -567,6 +569,37 @@ export class BaseModel {
    */
   declare readonly __isZerotalModel: true;
 
+  /**
+   * Compose one or more model mixins onto this class, folding them left-to-right, so reusable
+   * model behaviour (auth contract, roles, permissions, soft deletes, tenancy, …) stacks flat
+   * instead of nesting.
+   *
+   * @remarks
+   * Each mixin receives the accumulated base and returns an extended class, so this class's full
+   * static surface (`query()`, `find()`, `create()`, scopes, …) and every mixin's instance and
+   * static members flow through to the composed class — fully type-checked. Prefer this over
+   * hand-nesting mixins (`Roles(Permissions(AuthUser))`), which reads inside-out and repeats the
+   * base.
+   *
+   * `using` composes onto whatever class it is called on, so it also works on an intermediate
+   * model base, and the composed class carries `using` itself, so `Model.using(a, b).using(c)`
+   * chains past the 8-mixin overload set.
+   *
+   * Mixin authors declaring columns must call {@link registerColumn} imperatively — the `@column`
+   * decorator cannot run inside a returned class expression.
+   *
+   * @param mixins - Mixin factories applied in order; each receives the class the previous one produced.
+   * @returns A model class extending this one with every mixin applied.
+   *
+   * @example
+   * ```ts
+   * class User extends Model.using(Authenticatable, Permissions, Roles) {}
+   * ```
+   *
+   * @category Composition
+   */
+  static using: Compose = _compose;
+
   /**
    * Database table this model maps to. Usually set for you by the `@table("…")`
    * decorator; assign directly to override.
@@ -2530,5 +2563,7 @@ function _applyRow(inst: BaseModel, row: Record<string, unknown>): void {
   (inst as unknown as { _original: Record<string, unknown> })._original = orig;
 }
 
-// Backward-compat alias (index.ts exports `Model`)
+// `Model` is the canonical name at the declaration site — `class User extends Model.using(…)`
+// mirrors Flow's `class PostsPage extends Component.using(…)`. `BaseModel` remains exported as
+// an alias (same class object) for code that references the base class by that name.
 export { BaseModel as Model };

package/src/model/SoftDeletes.ts

@@ -4,10 +4,10 @@
 // `deletedAt`, `forceDelete()`, `restore()`, `trashed()`, and the `withTrashed()` /
 // `onlyTrashed()` query scopes. A hard-delete model has none of these.
 //
-//   import { BaseModelWith, SoftDeletes } from "@zerotal/orm";
+//   import { Model, SoftDeletes } from "@zerotal/orm";
 //
 //   @table("posts")
-//   class Post extends BaseModelWith(SoftDeletes) {
+//   class Post extends Model.using(SoftDeletes) {
 //     @column() title!: string;
 //   }
 //
@@ -47,7 +47,7 @@ interface SoftDeleteModelClass<T extends BaseModel> {
  * @example
  * ```ts
  * @table("posts")
- * class Post extends BaseModelWith(SoftDeletes) {
+ * class Post extends Model.using(SoftDeletes) {
  *   @column() title!: string;
  * }
  *

package/src/model/State.ts

@@ -4,7 +4,7 @@
 // workflow carry the API — `transitionTo` / `forceState` / `onTransition` / the
 // `states` + `stateField` statics never appear on models that don't use them.
 //
-//   import { BaseModelWith } from "@zerotal/orm";
+//   import { Model, State } from "@zerotal/orm";
 //
 //   const States = {
 //     pending: { canTransitionTo: ["active", "cancelled"] as const },
@@ -14,7 +14,7 @@
 //     cancelled: { canTransitionTo: [] as const },
 //   } as const;
 //
-//   class Subscription extends BaseModelWith(State) {
+//   class Subscription extends Model.using(State) {
 //     static states = States;
 //     @column() status!: keyof typeof States;
 //   }
@@ -132,7 +132,7 @@ interface StateModelClass {
  *   cancelled: { canTransitionTo: [] as const },
  * } as const;
  *
- * class Subscription extends BaseModelWith(State) {
+ * class Subscription extends Model.using(State) {
  *   static states = States;
  *   @column() status!: keyof typeof States;
  * }

package/src/model/decorators/table.ts

@@ -46,7 +46,7 @@ interface TableConfig {
  * export class Post extends BaseModel { ... }
  *
  * Soft deletes are opt-in via the `SoftDeletes` mixin, not `@table`:
- * `class Post extends BaseModelWith(SoftDeletes) {}` — see /docs/orm/lifecycle.
+ * `class Post extends Model.using(SoftDeletes) {}` — see /docs/orm/lifecycle.
  */
 export interface TableDecoratorBuilder {
   /** Apply the decorator to a class constructor (called automatically by TS). */
@@ -77,7 +77,7 @@ export interface TableDecoratorBuilder {
  * ```
  *
  * Timestamps are **on by default** — use `.withoutTimestamps()` to opt out. Soft
- * deletes are **opt-in via the `SoftDeletes` mixin**: `extends BaseModelWith(SoftDeletes)`.
+ * deletes are **opt-in via the `SoftDeletes` mixin**: `extends Model.using(SoftDeletes)`.
  *
  * `@table` is the single, required way to configure a model: besides setting the
  * table name and options, it anchors the class's `@column`/relation registrations at

package/src/model/mixins.ts

@@ -1,22 +1,25 @@
 // ── Model mixins ──────────────────────────────────────────────────────────────
 //
-// `BaseModelWith(...)` composes any number of model mixins on top of `BaseModel`,
-// so packages can ship reusable model behaviour (auth contract, roles, permissions,
-// soft deletes, …) that apps stack without "wrapper hell":
+// Mixin composition machinery for the ORM. The entry point is `Model.using(...)`
+// (see BaseModel.ts) — this module owns the types it is built from, and the fold
+// itself. Nothing here imports `BaseModel`: the fold seeds from its receiver, so
+// this is a leaf module.
+//
+// `Model.using(...)` composes any number of model mixins, so packages can ship
+// reusable model behaviour (auth contract, roles, permissions, soft deletes, …)
+// that apps stack without "wrapper hell":
 //
 //   // before — nested, base repeated, order reads inside-out
 //   class User extends Roles(Permissions(AuthUser)) {}
 //
 //   // after — flat, left-to-right, base baked in
-//   class User extends BaseModelWith(Authenticatable, Permissions, Roles) {}
+//   class User extends Model.using(Authenticatable, Permissions, Roles) {}
 //
 // A mixin is the canonical generic form `(<T>(Base: T) => class extends Base { … })`.
-// Because each one returns `class extends Base`, BaseModel's full static surface
+// Because each one returns `class extends Base`, the base's full static surface
 // (`User.query()`, `find()`, `create()`, scopes, …) and every mixin's instance
 // members flow through to the final class — fully type-checked.
 
-import { BaseModel } from "./BaseModel.ts";
-
 /** A concrete class constructor. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- generic mixin base bound
 export type Constructor<T = object> = new (...args: any[]) => T;
@@ -32,505 +35,127 @@ export type Mixin<TIn extends Constructor = Constructor, TOut extends Constructo
   Base: TIn,
 ) => TOut;
 
-type Base = typeof BaseModel;
-
-// Typed overloads (1–8 mixins) thread the accumulated type through each step so the
-// result is `BaseModel`'s statics + every mixin's members. Need more? Nest a
-// `BaseModelWith(...)` call or add another overload.
-
 /**
- * Compose any number of model {@link Mixin | mixins} on top of {@link BaseModel},
- * folding them left-to-right so the resulting class carries `BaseModel`'s full
- * static surface (`query()`, `find()`, `create()`, scopes, …) plus every mixin's
- * instance and static members — all fully type-checked.
- *
- * Prefer this over hand-nesting mixins (`Roles(Permissions(AuthUser))`), which
- * reads inside-out and repeats the base. Each overload (1–20 mixins) threads the
- * accumulated type through every step; for more, nest a second `BaseModelWith(...)`.
+ * The call signatures behind `Model.using(...)`.
  *
- * @param mixins - Mixin factories applied in order; each receives the class the
- *   previous one produced.
- * @returns A model class extending `BaseModel` with every mixin applied.
+ * Each overload threads the accumulated type through every step, so the composed class carries
+ * the base's full static surface plus every mixin's instance and static members — fully
+ * type-checked. The `this: TBase` parameter is what makes the base polymorphic: `using` composes
+ * onto whatever class it is called on, not onto a hardcoded `BaseModel`.
  *
- * @example
- * ```ts
- * class User extends BaseModelWith(Authenticatable, Permissions, Roles) {}
- * ```
+ * Overloads cover 1–8 mixins. There is no ceiling: the composed class carries `using` too, so
+ * `Model.using(a, b).using(c, d)` chains.
  */
-export function BaseModelWith<A extends Constructor>(a: (base: Base) => A): A;
-export function BaseModelWith<A extends Constructor, B extends Constructor>(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-): B;
-export function BaseModelWith<A extends Constructor, B extends Constructor, C extends Constructor>(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-): C;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
->(a: (base: Base) => A, b: (base: A) => B, c: (base: B) => C, d: (base: C) => D): D;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-): E;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-): F;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-): G;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-): H;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-): I;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-): J;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-): K;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-): L;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-): M;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-): N;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-): O;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
-  P extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-  p: (base: O) => P,
-): P;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
-  P extends Constructor,
-  Q extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-  p: (base: O) => P,
-  q: (base: P) => Q,
-): Q;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
-  P extends Constructor,
-  Q extends Constructor,
-  R extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-  p: (base: O) => P,
-  q: (base: P) => Q,
-  r: (base: Q) => R,
-): R;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
-  P extends Constructor,
-  Q extends Constructor,
-  R extends Constructor,
-  S extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-  p: (base: O) => P,
-  q: (base: P) => Q,
-  r: (base: Q) => R,
-  s: (base: R) => S,
-): S;
-export function BaseModelWith<
-  A extends Constructor,
-  B extends Constructor,
-  C extends Constructor,
-  D extends Constructor,
-  E extends Constructor,
-  F extends Constructor,
-  G extends Constructor,
-  H extends Constructor,
-  I extends Constructor,
-  J extends Constructor,
-  K extends Constructor,
-  L extends Constructor,
-  M extends Constructor,
-  N extends Constructor,
-  O extends Constructor,
-  P extends Constructor,
-  Q extends Constructor,
-  R extends Constructor,
-  S extends Constructor,
-  T extends Constructor,
->(
-  a: (base: Base) => A,
-  b: (base: A) => B,
-  c: (base: B) => C,
-  d: (base: C) => D,
-  e: (base: D) => E,
-  f: (base: E) => F,
-  g: (base: F) => G,
-  h: (base: G) => H,
-  i: (base: H) => I,
-  j: (base: I) => J,
-  k: (base: J) => K,
-  l: (base: K) => L,
-  m: (base: L) => M,
-  n: (base: M) => N,
-  o: (base: N) => O,
-  p: (base: O) => P,
-  q: (base: P) => Q,
-  r: (base: Q) => R,
-  s: (base: R) => S,
-  t: (base: S) => T,
-): T;
+export interface Compose {
+  <TBase extends Constructor, A extends Constructor>(this: TBase, a: (base: TBase) => A): A;
+  <TBase extends Constructor, A extends Constructor, B extends Constructor>(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+  ): B;
+  <TBase extends Constructor, A extends Constructor, B extends Constructor, C extends Constructor>(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+  ): C;
+  <
+    TBase extends Constructor,
+    A extends Constructor,
+    B extends Constructor,
+    C extends Constructor,
+    D extends Constructor,
+  >(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+    d: (base: C) => D,
+  ): D;
+  <
+    TBase extends Constructor,
+    A extends Constructor,
+    B extends Constructor,
+    C extends Constructor,
+    D extends Constructor,
+    E extends Constructor,
+  >(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+    d: (base: C) => D,
+    e: (base: D) => E,
+  ): E;
+  <
+    TBase extends Constructor,
+    A extends Constructor,
+    B extends Constructor,
+    C extends Constructor,
+    D extends Constructor,
+    E extends Constructor,
+    F extends Constructor,
+  >(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+    d: (base: C) => D,
+    e: (base: D) => E,
+    f: (base: E) => F,
+  ): F;
+  <
+    TBase extends Constructor,
+    A extends Constructor,
+    B extends Constructor,
+    C extends Constructor,
+    D extends Constructor,
+    E extends Constructor,
+    F extends Constructor,
+    G extends Constructor,
+  >(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+    d: (base: C) => D,
+    e: (base: D) => E,
+    f: (base: E) => F,
+    g: (base: F) => G,
+  ): G;
+  <
+    TBase extends Constructor,
+    A extends Constructor,
+    B extends Constructor,
+    C extends Constructor,
+    D extends Constructor,
+    E extends Constructor,
+    F extends Constructor,
+    G extends Constructor,
+    H extends Constructor,
+  >(
+    this: TBase,
+    a: (base: TBase) => A,
+    b: (base: A) => B,
+    c: (base: B) => C,
+    d: (base: C) => D,
+    e: (base: D) => E,
+    f: (base: E) => F,
+    g: (base: F) => G,
+    h: (base: G) => H,
+  ): H;
+}
 
-// Implementation: fold the mixins over BaseModel, left to right. The base param is
-// `any` so each typed overload above (whose base is the narrower `typeof BaseModel`
-// or a prior mixin's result) stays assignable to this implementation signature.
-export function BaseModelWith(
+/**
+ * The fold behind {@link Compose}: apply each mixin left-to-right, seeding from `this` (the
+ * class `using` was called on). Assigned to `BaseModel.using` — not exported publicly.
+ *
+ * @internal
+ */
+export const _compose = function (
+  this: Constructor,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- variadic mixin folder
   ...mixins: Array<(base: any) => Constructor>
 ): Constructor {
-  return mixins.reduce<Constructor>(
-    (acc, mixin) => mixin(acc),
-    BaseModel as unknown as Constructor,
-  );
-}
+  return mixins.reduce<Constructor>((acc, mixin) => mixin(acc), this);
+} as Compose;