@bunyad/orm 0.1.0-alpha.0

package/dist/model-query.js

@@ -0,0 +1,3170 @@
+import { DatabaseManager as Db, CursorPaginator, LengthAwarePaginator, Paginator, dateTimeForStorage, hasQueryListeners, resolvePaginatorPage, wrapSqlName, } from "@bunyad/database";
+import { Collection } from "@bunyad/common";
+import { OrmCollection } from "./orm-collection.js";
+import { bootIfNotBooted, fireModelEvent, hasModelEventListeners, } from "./model-events.js";
+import { getGlobalScopes, hasGlobalScopes, } from "./scopes.js";
+import { resolveModelBuilder } from "./decorators.js";
+import { deletedAtColumn, normalizeWithRelations, nowForConnection, parseRelationAlias, singular, usesSoftDeletes, } from "./model-helpers.js";
+import { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, MorphMany, MorphOne, MorphTo, MorphToMany, morphTypeFor, resolveRelation, } from "./relations.js";
+import { eagerLoadAggregates, eagerLoadModels } from "./eager.js";
+import {} from "./casts.js";
+import { Model, ModelNotFoundException, attributesNeedModelCasts, filterFillable, resolveConnection, } from "./model.js";
+/**
+ * Local-scope Proxy exposes this so callers can reach the real `ModelQuery`
+ * (private fields are not accessible through a Proxy).
+ */
+export const MODEL_QUERY_TARGET = Symbol.for("bunyad.orm.ModelQuery.target");
+/** Unwrap a local-scope Proxy to the underlying `ModelQuery` instance. */
+export function unwrapModelQuery(query) {
+    const target = query[MODEL_QUERY_TARGET];
+    return target ?? query;
+}
+/** Shared empty array — copy-on-write before mutate (ModelQuery ctor hot path). */
+const MQ_EMPTY = Object.freeze([]);
+const MQ_EMPTY_OBJ = Object.freeze({});
+/** Copy-on-write: return a mutable array (clone shared MQ_EMPTY). */
+function mqMut(arr) {
+    return arr === MQ_EMPTY ? [] : arr;
+}
+function mqMutObj(obj) {
+    return obj === MQ_EMPTY_OBJ ? {} : obj;
+}
+/** Compiled simple-SELECT SQL keyed by constraint fingerprint (per model). */
+const simpleSelectSqlCache = new WeakMap();
+/** Compiled parent+EXISTS SELECT SQL (whereHas fast path). */
+const hasExistsSelectSqlCache = new WeakMap();
+const SIMPLE_WHERE_OPS = new Set([
+    "=",
+    "!=",
+    "<>",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "like",
+    "LIKE",
+    "not like",
+    "NOT LIKE",
+    "__null__",
+    "__notnull__",
+]);
+function wheresAreSimple(wheres) {
+    for (const where of wheres) {
+        if (!SIMPLE_WHERE_OPS.has(where.op))
+            return false;
+    }
+    return true;
+}
+/** `id`, `name`, `categories.id`, or `*`. Expressions stay on the full builder. */
+function plainColumnList(columns) {
+    if (columns.length === 0)
+        return "*";
+    for (const column of columns) {
+        if (column !== "*" &&
+            !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)?$/.test(column)) {
+            return null;
+        }
+    }
+    return columns.join(", ");
+}
+export class ModelQuery {
+    model;
+    #wheres = MQ_EMPTY;
+    #whereIns = MQ_EMPTY;
+    #whereNulls = MQ_EMPTY;
+    #whereBetweens = MQ_EMPTY;
+    #whereColumns = MQ_EMPTY;
+    #whereRaws = MQ_EMPTY;
+    #whereLikes = MQ_EMPTY;
+    #dateWheres = MQ_EMPTY;
+    #orders = MQ_EMPTY;
+    #selectColumns = null;
+    #addSelectColumns = MQ_EMPTY;
+    #selectRaws = MQ_EMPTY;
+    #distinct = false;
+    #limitValue;
+    #offsetValue;
+    #groupByColumns = MQ_EMPTY;
+    #havings = MQ_EMPTY;
+    #havingRaws = MQ_EMPTY;
+    #lock = false;
+    #hasConstraints = MQ_EMPTY;
+    #withCounts = MQ_EMPTY;
+    #withAggregates = MQ_EMPTY;
+    #morphHasConstraints = MQ_EMPTY;
+    #builderExtras = MQ_EMPTY;
+    #nestedGroups = MQ_EMPTY;
+    #joins = MQ_EMPTY;
+    #withTrashed;
+    #onlyTrashed;
+    /**
+     * True when this query is only applied inside a WHERE nested group
+     * (`where(callback)`). BelongsTo whereHas must not expand to JOIN.
+     */
+    #nestedWhereGroup;
+    /** Pending attrs from `withAttributes` — merged into create + optional wheres. */
+    #pendingAttributes = MQ_EMPTY_OBJ;
+    #eagerLoad;
+    #casts = MQ_EMPTY_OBJ;
+    /** True once `withCasts` adds any query-time cast (avoid per-row key scan). */
+    #hasQueryCasts = false;
+    /**
+     * False once a constraint needs the full QueryBuilder
+     * (joins, nested wheres, raws, has/whereRelation, …).
+     */
+    #simple = true;
+    /** Cached `retrieved` listener presence (hydrate hot path). */
+    #hasRetrievedListeners = false;
+    #withoutGlobalScopes;
+    #connection;
+    /** When true, `get()` returns plain row objects instead of models. */
+    #asRows = false;
+    constructor(model, options = {}) {
+        this.model = model;
+        bootIfNotBooted(model);
+        this.#hasRetrievedListeners = hasModelEventListeners(model, "retrieved");
+        this.#withTrashed = options.withTrashed ?? false;
+        this.#onlyTrashed = options.onlyTrashed ?? false;
+        this.#nestedWhereGroup = options.nestedWhereGroup ?? false;
+        this.#eagerLoad = options.eagerLoad ?? MQ_EMPTY;
+        this.#connection = options.connection;
+        if (options.withoutGlobalScopes === true) {
+            this.#withoutGlobalScopes = true;
+        }
+        else if (Array.isArray(options.withoutGlobalScopes)) {
+            this.#withoutGlobalScopes = new Set(options.withoutGlobalScopes);
+        }
+    }
+    /** Query builder bound to this query's connection (or the model default). */
+    #baseTable() {
+        if (this.#connection !== undefined) {
+            return new Db(resolveConnection(this.#connection)).table(this.model.table);
+        }
+        return this.model.db().table(this.model.table);
+    }
+    /** `get()` returns plain row objects. Models are not built. */
+    rows() {
+        this.#asRows = true;
+        return this;
+    }
+    /** Laravel `withoutGlobalScopes`. */
+    withoutGlobalScopes(names) {
+        if (!names)
+            this.#withoutGlobalScopes = true;
+        else {
+            const set = this.#withoutGlobalScopes === true || this.#withoutGlobalScopes == null
+                ? new Set()
+                : this.#withoutGlobalScopes;
+            for (const name of names)
+                set.add(name);
+            this.#withoutGlobalScopes = set;
+        }
+        return this;
+    }
+    /** Laravel `withoutGlobalScope`. */
+    withoutGlobalScope(name) {
+        return this.withoutGlobalScopes([name]);
+    }
+    /** Laravel `withTrashed()`. */
+    withTrashed() {
+        this.#withTrashed = true;
+        this.#onlyTrashed = false;
+        return this;
+    }
+    /** Laravel `onlyTrashed()`. */
+    onlyTrashed() {
+        this.#onlyTrashed = true;
+        this.#withTrashed = false;
+        return this;
+    }
+    /** Laravel `withoutTrashed()`. */
+    withoutTrashed() {
+        this.#withTrashed = false;
+        this.#onlyTrashed = false;
+        return this;
+    }
+    /**
+     * Laravel `Builder::withAttributes` — pending attrs for `create()`, and
+     * matching `where` conditions when `asConditions` is true (default).
+     */
+    withAttributes(attributes, valueOrAsConditions, asConditions = true) {
+        let attrs;
+        let applyAsConditions = asConditions;
+        if (typeof attributes === "string") {
+            attrs = { [attributes]: valueOrAsConditions };
+        }
+        else {
+            attrs = { ...attributes };
+            // `withAttributes({ hidden: 1 }, false)` — second arg is asConditions
+            if (typeof valueOrAsConditions === "boolean") {
+                applyAsConditions = valueOrAsConditions;
+            }
+        }
+        this.#pendingAttributes = mqMutObj(this.#pendingAttributes);
+        Object.assign(this.#pendingAttributes, attrs);
+        if (applyAsConditions) {
+            for (const [column, v] of Object.entries(attrs)) {
+                this.where(column, v);
+            }
+        }
+        return this;
+    }
+    /** Laravel `withCasts` — merge query-time casts for hydration. */
+    withCasts(casts) {
+        this.#casts = mqMutObj(this.#casts);
+        Object.assign(this.#casts, casts);
+        for (const _ in casts) {
+            this.#hasQueryCasts = true;
+            break;
+        }
+        return this;
+    }
+    /** Laravel `has`. */
+    has(relation) {
+        return this.whereHas(relation);
+    }
+    /** Laravel `doesntHave`. */
+    doesntHave(relation) {
+        return this.whereDoesntHave(relation);
+    }
+    /** Laravel `whereHas`. */
+    whereHas(relation, callback) {
+        this.#simple = false;
+        // BelongsTo AND: expand to INNER JOIN once (same SQL as join()), avoid re-resolve per get().
+        // Nested where groups only emit WHERE SQL — JOIN expand would reference related columns
+        // without a FROM entry ("missing FROM-clause entry for table …").
+        const meta = resolveRelation(this.model, relation);
+        if (meta?.kind === "belongsTo" && !this.#nestedWhereGroup) {
+            this.#expandBelongsToHasJoin(meta, callback, relation);
+            return this;
+        }
+        return this.#pushHasConstraint(relation, false, false, callback, meta);
+    }
+    /** Laravel `orWhereHas`. */
+    orWhereHas(relation, callback) {
+        this.#simple = false;
+        return this.#pushHasConstraint(relation, false, true, callback);
+    }
+    /** Laravel `whereDoesntHave`. */
+    whereDoesntHave(relation, callback) {
+        this.#simple = false;
+        return this.#pushHasConstraint(relation, true, false, callback);
+    }
+    /** Laravel `orWhereDoesntHave`. */
+    orWhereDoesntHave(relation, callback) {
+        this.#simple = false;
+        return this.#pushHasConstraint(relation, true, true, callback);
+    }
+    /**
+     * Laravel `whereRelation($relation, $column, $operator = null, $value = null)`.
+     * Convenience wrapper around `whereHas` with a column constraint.
+     */
+    whereRelation(relation, column, opOrValue, value) {
+        this.#simple = false;
+        const meta = resolveRelation(this.model, relation);
+        // BelongsTo: join + qualified where — same build path as ORM join(), no related ModelQuery.
+        // Nested where groups cannot emit JOINs — fall through to has-constraint IN path.
+        if (meta?.kind === "belongsTo" && !this.#nestedWhereGroup) {
+            const alias = this.#expandBelongsToHasJoin(meta, undefined, relation);
+            const col = column.includes(".") ? column : `${alias}.${column}`;
+            if (value === undefined)
+                this.where(col, opOrValue);
+            else
+                this.where(col, String(opOrValue), value);
+            return this;
+        }
+        // HasMany / BelongsToMany: bake a single related where into EXISTS (no ModelQuery).
+        if (meta &&
+            (meta.kind === "has" ||
+                meta.kind === "belongsToMany" ||
+                meta.kind === "morphToMany")) {
+            const op = value === undefined ? "=" : String(opOrValue);
+            const val = value === undefined ? opOrValue : value;
+            return this.#pushHasConstraintWithRelatedApply(relation, false, false, meta, (sub) => {
+                sub.where(column, op, val);
+            });
+        }
+        return this.whereHas(relation, (q) => {
+            if (value === undefined)
+                q.where(column, opOrValue);
+            else
+                q.where(column, String(opOrValue), value);
+        });
+    }
+    /** Laravel `orWhereRelation`. */
+    orWhereRelation(relation, column, opOrValue, value) {
+        this.#simple = false;
+        const meta = resolveRelation(this.model, relation);
+        if (meta &&
+            (meta.kind === "has" ||
+                meta.kind === "belongsToMany" ||
+                meta.kind === "morphToMany")) {
+            const op = value === undefined ? "=" : String(opOrValue);
+            const val = value === undefined ? opOrValue : value;
+            return this.#pushHasConstraintWithRelatedApply(relation, false, true, meta, (sub) => {
+                sub.where(column, op, val);
+            });
+        }
+        return this.orWhereHas(relation, (q) => {
+            if (value === undefined)
+                q.where(column, opOrValue);
+            else
+                q.where(column, String(opOrValue), value);
+        });
+    }
+    /** Laravel `orHas`. */
+    orHas(relation) {
+        return this.orWhereHas(relation);
+    }
+    /** Laravel `orDoesntHave`. */
+    orDoesntHave(relation) {
+        return this.orWhereDoesntHave(relation);
+    }
+    /**
+     * Laravel `whereBelongsTo($model, $relationshipName = null)`.
+     * Constrains by the foreign key of a belongsTo relation.
+     */
+    whereBelongsTo(related, relationName) {
+        return this.#belongsToConstraint(related, relationName, false);
+    }
+    /** Laravel `orWhereBelongsTo`. */
+    orWhereBelongsTo(related, relationName) {
+        return this.#belongsToConstraint(related, relationName, true);
+    }
+    #belongsToConstraint(related, relationName, or) {
+        const RelatedCtor = related.constructor;
+        const rel = relationName ?? singular(RelatedCtor.table);
+        const meta = resolveRelation(this.model, rel);
+        const pkName = meta?.kind === "belongsTo" ? meta.ownerKey : RelatedCtor.primaryKey;
+        const fk = meta?.kind === "belongsTo"
+            ? meta.foreignKey
+            : `${singular(RelatedCtor.table)}_id`;
+        const pk = related[pkName];
+        if (or)
+            this.orWhere(fk, pk);
+        else
+            this.where(fk, pk);
+        return this;
+    }
+    /**
+     * Laravel `whereMorphedTo($relation, $model)`.
+     */
+    whereMorphedTo(relation, model) {
+        return this.#morphToConstraint(relation, model, false, false);
+    }
+    orWhereMorphedTo(relation, model) {
+        return this.#morphToConstraint(relation, model, false, true);
+    }
+    whereNotMorphedTo(relation, model) {
+        return this.#morphToConstraint(relation, model, true, false);
+    }
+    orWhereNotMorphedTo(relation, model) {
+        return this.#morphToConstraint(relation, model, true, true);
+    }
+    #morphToConstraint(relation, model, not, or) {
+        const instance = new this.model();
+        let rel;
+        try {
+            rel = instance.related(relation);
+        }
+        catch {
+            throw new Error(`Unknown morphTo relation [${relation}].`);
+        }
+        if (!(rel instanceof MorphTo)) {
+            throw new Error(`[${relation}] is not a morphTo relation.`);
+        }
+        const Related = model.constructor;
+        const type = morphTypeFor(Related);
+        const key = rel.getOwnerKeyName() ?? Related.primaryKey;
+        const id = model[key];
+        const typeCol = rel.getTypeColumn();
+        const idCol = rel.getIdColumn();
+        if (not) {
+            // NOT (type = X AND id = Y) → type <> X OR id <> Y
+            if (or) {
+                // orWhereNot — approximate with orWhereNested not
+                this.orWhere(typeCol, "!=", type);
+                return this;
+            }
+            return this.whereNot((q) => {
+                q.where(typeCol, type).where(idCol, id);
+            });
+        }
+        if (or) {
+            this.orWhere(typeCol, type);
+            this.where(idCol, id);
+            return this;
+        }
+        this.where(typeCol, type);
+        this.where(idCol, id);
+        return this;
+    }
+    /**
+     * Laravel `whereMorphRelation($relation, $types, $column, …)` — simplified:
+     * `whereMorphRelation('commentable', TypeModel, column, op?, value?)`.
+     */
+    whereMorphRelation(relation, type, column, opOrValue, value) {
+        return this.whereHasMorph(relation, type, (q) => {
+            if (value === undefined)
+                q.where(column, opOrValue);
+            else
+                q.where(column, String(opOrValue), value);
+        });
+    }
+    orWhereMorphRelation(relation, type, column, opOrValue, value) {
+        return this.orWhereHasMorph(relation, type, (q) => {
+            if (value === undefined)
+                q.where(column, opOrValue);
+            else
+                q.where(column, String(opOrValue), value);
+        });
+    }
+    /**
+     * Laravel `whereHasMorph($relation, $types, $callback?)`.
+     * `$types` may be a single model class or an array.
+     */
+    whereHasMorph(relation, types, callback) {
+        return this.#hasMorphConstraint(relation, types, false, false, callback);
+    }
+    orWhereHasMorph(relation, types, callback) {
+        return this.#hasMorphConstraint(relation, types, false, true, callback);
+    }
+    whereDoesntHaveMorph(relation, types, callback) {
+        return this.#hasMorphConstraint(relation, types, true, false, callback);
+    }
+    orWhereDoesntHaveMorph(relation, types, callback) {
+        return this.#hasMorphConstraint(relation, types, true, true, callback);
+    }
+    hasMorph(relation, types) {
+        return this.whereHasMorph(relation, types);
+    }
+    doesntHaveMorph(relation, types) {
+        return this.whereDoesntHaveMorph(relation, types);
+    }
+    #hasMorphConstraint(relation, types, not, or, callback) {
+        const list = Array.isArray(types) ? types : [types];
+        const instance = new this.model();
+        let rel;
+        try {
+            rel = instance.related(relation);
+        }
+        catch {
+            throw new Error(`Unknown morphTo relation [${relation}].`);
+        }
+        if (!(rel instanceof MorphTo)) {
+            throw new Error(`[${relation}] is not a morphTo relation.`);
+        }
+        this.#simple = false;
+        (this.#morphHasConstraints = mqMut(this.#morphHasConstraints)).push({
+            typeColumn: rel.getTypeColumn(),
+            idColumn: rel.getIdColumn(),
+            types: list,
+            not,
+            or,
+            callback,
+        });
+        return this;
+    }
+    /**
+     * Laravel `withWhereHas($relation, $callback?)` — whereHas + eager with same constraint.
+     */
+    withWhereHas(relation, callback) {
+        this.whereHas(relation, callback);
+        this.with(relation);
+        return this;
+    }
+    /** Laravel `whereAny` (forwarded to query builder). */
+    whereAny(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.whereAny(columns, opOrValue, value));
+        return this;
+    }
+    orWhereAny(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.orWhereAny(columns, opOrValue, value));
+        return this;
+    }
+    whereAll(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.whereAll(columns, opOrValue, value));
+        return this;
+    }
+    orWhereAll(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.orWhereAll(columns, opOrValue, value));
+        return this;
+    }
+    whereNone(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.whereNone(columns, opOrValue, value));
+        return this;
+    }
+    orWhereNone(columns, opOrValue, value) {
+        this.#simple = false;
+        (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => q.orWhereNone(columns, opOrValue, value));
+        return this;
+    }
+    /** Laravel `whereKey($id)` / `whereKey([$ids])`. */
+    whereKey(id) {
+        const key = this.model.primaryKey;
+        if (Array.isArray(id))
+            return this.whereIn(key, id);
+        return this.where(key, id);
+    }
+    /** Laravel `whereKeyNot`. */
+    whereKeyNot(id) {
+        const key = this.model.primaryKey;
+        if (Array.isArray(id))
+            return this.whereNotIn(key, id);
+        return this.where(key, "!=", id);
+    }
+    /** Laravel `whereUuid($column, $uuid)`. */
+    whereUuid(column, value) {
+        return this.where(column, value);
+    }
+    /** Laravel `whereUlid($column, $ulid)`. */
+    whereUlid(column, value) {
+        return this.where(column, value);
+    }
+    /** Laravel `whereNot(closure)` nested group. */
+    whereNot(callback) {
+        this.#simple = false;
+        (this.#nestedGroups = mqMut(this.#nestedGroups)).push({ boolean: "and", not: true, callback });
+        return this;
+    }
+    orWhereNot(callback) {
+        this.#simple = false;
+        (this.#nestedGroups = mqMut(this.#nestedGroups)).push({ boolean: "or", not: true, callback });
+        return this;
+    }
+    firstWhere(column, opOrValue, value) {
+        if (value === undefined)
+            this.where(column, opOrValue);
+        else
+            this.where(column, String(opOrValue), value);
+        return this.first();
+    }
+    /** Laravel `findMany`. */
+    findMany(ids) {
+        return this.whereIn(this.model.primaryKey, ids).#fetchModels();
+    }
+    /** Laravel `findOr($id, $callback)`. */
+    async findOr(id, callback) {
+        const model = await this.where(this.model.primaryKey, id).first();
+        if (model)
+            return model;
+        return callback();
+    }
+    /** Laravel `findOrNew`. */
+    async findOrNew(id) {
+        const model = await this.where(this.model.primaryKey, id).first();
+        if (model)
+            return model;
+        const fresh = new this.model();
+        fresh[this.model.primaryKey] = id;
+        return fresh;
+    }
+    /** Laravel `firstOr($callback)`. */
+    async firstOr(callback) {
+        const model = await this.first();
+        if (model)
+            return model;
+        return callback();
+    }
+    /** Laravel `valueOrFail`. */
+    async valueOrFail(column) {
+        const model = await this.firstOrFail();
+        return model[column];
+    }
+    /** Laravel `soleValue`. */
+    async soleValue(column) {
+        const model = await this.sole();
+        return model[column];
+    }
+    /** `withCount` — `'posts'`, `'posts as post_total'`, a string list, or `{ products: { as: 'productsCount' } }`. */
+    withCount(...relations) {
+        for (const arg of relations) {
+            if (Array.isArray(arg)) {
+                this.withCount(...arg);
+                continue;
+            }
+            if (typeof arg === "string") {
+                const parsed = parseRelationAlias(arg);
+                this.#simple = false;
+                (this.#withAggregates = mqMut(this.#withAggregates)).push({
+                    relation: parsed.relation,
+                    alias: parsed.alias ?? `${parsed.relation}_count`,
+                    fn: "count",
+                });
+                (this.#withCounts = mqMut(this.#withCounts)).push(arg);
+                continue;
+            }
+            for (const [relation, value] of Object.entries(arg)) {
+                let alias = `${relation}_count`;
+                if (value === true) {
+                    // default alias
+                }
+                else if (typeof value === "string") {
+                    alias = value;
+                }
+                else if (typeof value === "function") {
+                    // constrained count — store as aggregate without callback support yet (count all)
+                }
+                else if (value && typeof value === "object" && "as" in value && value.as) {
+                    alias = value.as;
+                }
+                this.#simple = false;
+                (this.#withAggregates = mqMut(this.#withAggregates)).push({ relation, alias, fn: "count" });
+                (this.#withCounts = mqMut(this.#withCounts)).push(relation);
+            }
+        }
+        return this;
+    }
+    /** Laravel `withSum($relation, $column)`. */
+    withSum(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const base = parsed.relation;
+        this.#simple = false;
+        (this.#withAggregates = mqMut(this.#withAggregates)).push({
+            relation: base,
+            alias: parsed.alias ?? `${base}_sum_${column}`,
+            fn: "sum",
+            column,
+        });
+        return this;
+    }
+    withAvg(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const base = parsed.relation;
+        this.#simple = false;
+        (this.#withAggregates = mqMut(this.#withAggregates)).push({
+            relation: base,
+            alias: parsed.alias ?? `${base}_avg_${column}`,
+            fn: "avg",
+            column,
+        });
+        return this;
+    }
+    withMin(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const base = parsed.relation;
+        this.#simple = false;
+        (this.#withAggregates = mqMut(this.#withAggregates)).push({
+            relation: base,
+            alias: parsed.alias ?? `${base}_min_${column}`,
+            fn: "min",
+            column,
+        });
+        return this;
+    }
+    withMax(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const base = parsed.relation;
+        this.#simple = false;
+        (this.#withAggregates = mqMut(this.#withAggregates)).push({
+            relation: base,
+            alias: parsed.alias ?? `${base}_max_${column}`,
+            fn: "max",
+            column,
+        });
+        return this;
+    }
+    /** Laravel `withExists($relation)`. */
+    withExists(...relations) {
+        for (const raw of relations.flat()) {
+            const parsed = parseRelationAlias(raw);
+            this.#simple = false;
+            (this.#withAggregates = mqMut(this.#withAggregates)).push({
+                relation: parsed.relation,
+                alias: parsed.alias ?? `${parsed.relation}_exists`,
+                fn: "exists",
+            });
+        }
+        return this;
+    }
+    /** Laravel `withAggregate($relation, $column, $function)`. */
+    withAggregate(relation, column, fn) {
+        const parsed = parseRelationAlias(relation);
+        const base = parsed.relation;
+        this.#simple = false;
+        (this.#withAggregates = mqMut(this.#withAggregates)).push({
+            relation: base,
+            alias: parsed.alias ?? `${base}_${fn}_${column}`,
+            fn,
+            column: fn === "count" ? undefined : column,
+        });
+        return this;
+    }
+    /** Laravel Eloquent `join` (hydrated models still from the base table). */
+    join(table, first, op, second) {
+        this.#simple = false;
+        (this.#joins = mqMut(this.#joins)).push({ type: "inner", table, first, op, second });
+        return this;
+    }
+    /** Laravel `leftJoin`. */
+    leftJoin(table, first, op, second) {
+        this.#simple = false;
+        (this.#joins = mqMut(this.#joins)).push({ type: "left", table, first, op, second });
+        return this;
+    }
+    /** Laravel `rightJoin`. */
+    rightJoin(table, first, op, second) {
+        this.#simple = false;
+        (this.#joins = mqMut(this.#joins)).push({ type: "right", table, first, op, second });
+        return this;
+    }
+    where(columnOrCallback, opOrValue, value) {
+        if (typeof columnOrCallback === "function") {
+            this.#simple = false;
+            (this.#nestedGroups = mqMut(this.#nestedGroups)).push({
+                boolean: "and",
+                not: false,
+                callback: columnOrCallback,
+            });
+            return this;
+        }
+        if (value === undefined) {
+            (this.#wheres = mqMut(this.#wheres)).push({
+                column: columnOrCallback,
+                op: "=",
+                value: opOrValue,
+                boolean: "and",
+            });
+        }
+        else {
+            const op = String(opOrValue);
+            if (op !== "=" &&
+                op !== "!=" &&
+                op !== "<>" &&
+                op !== "<" &&
+                op !== "<=" &&
+                op !== ">" &&
+                op !== ">=" &&
+                op !== "like" &&
+                op !== "LIKE" &&
+                op !== "not like" &&
+                op !== "NOT LIKE") {
+                this.#simple = false;
+            }
+            (this.#wheres = mqMut(this.#wheres)).push({
+                column: columnOrCallback,
+                op,
+                value,
+                boolean: "and",
+            });
+        }
+        return this;
+    }
+    orWhere(columnOrCallback, opOrValue, value) {
+        if (typeof columnOrCallback === "function") {
+            this.#simple = false;
+            (this.#nestedGroups = mqMut(this.#nestedGroups)).push({
+                boolean: "or",
+                not: false,
+                callback: columnOrCallback,
+            });
+            return this;
+        }
+        if (value === undefined) {
+            (this.#wheres = mqMut(this.#wheres)).push({
+                column: columnOrCallback,
+                op: "=",
+                value: opOrValue,
+                boolean: "or",
+            });
+        }
+        else {
+            const op = String(opOrValue);
+            if (op !== "=" &&
+                op !== "!=" &&
+                op !== "<>" &&
+                op !== "<" &&
+                op !== "<=" &&
+                op !== ">" &&
+                op !== ">=" &&
+                op !== "like" &&
+                op !== "LIKE" &&
+                op !== "not like" &&
+                op !== "NOT LIKE") {
+                this.#simple = false;
+            }
+            (this.#wheres = mqMut(this.#wheres)).push({
+                column: columnOrCallback,
+                op,
+                value,
+                boolean: "or",
+            });
+        }
+        return this;
+    }
+    whereIn(column, values) {
+        this.#simple = false;
+        (this.#whereIns = mqMut(this.#whereIns)).push({ column, values, not: false, boolean: "and" });
+        return this;
+    }
+    orWhereIn(column, values) {
+        this.#simple = false;
+        (this.#whereIns = mqMut(this.#whereIns)).push({ column, values, not: false, boolean: "or" });
+        return this;
+    }
+    whereNotIn(column, values) {
+        this.#simple = false;
+        (this.#whereIns = mqMut(this.#whereIns)).push({ column, values, not: true, boolean: "and" });
+        return this;
+    }
+    orWhereNotIn(column, values) {
+        this.#simple = false;
+        (this.#whereIns = mqMut(this.#whereIns)).push({ column, values, not: true, boolean: "or" });
+        return this;
+    }
+    whereNull(column) {
+        (this.#wheres = mqMut(this.#wheres)).push({
+            column,
+            op: "__null__",
+            value: null,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereNull(column) {
+        (this.#wheres = mqMut(this.#wheres)).push({
+            column,
+            op: "__null__",
+            value: null,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereNotNull(column) {
+        (this.#wheres = mqMut(this.#wheres)).push({
+            column,
+            op: "__notnull__",
+            value: null,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereNotNull(column) {
+        (this.#wheres = mqMut(this.#wheres)).push({
+            column,
+            op: "__notnull__",
+            value: null,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereBetween(column, values) {
+        this.#simple = false;
+        (this.#whereBetweens = mqMut(this.#whereBetweens)).push({
+            column,
+            values,
+            not: false,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereBetween(column, values) {
+        this.#simple = false;
+        (this.#whereBetweens = mqMut(this.#whereBetweens)).push({
+            column,
+            values,
+            not: false,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereNotBetween(column, values) {
+        this.#simple = false;
+        (this.#whereBetweens = mqMut(this.#whereBetweens)).push({
+            column,
+            values,
+            not: true,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereNotBetween(column, values) {
+        this.#simple = false;
+        (this.#whereBetweens = mqMut(this.#whereBetweens)).push({
+            column,
+            values,
+            not: true,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereColumn(first, opOrSecond, second) {
+        if (second === undefined) {
+            this.#simple = false;
+            (this.#whereColumns = mqMut(this.#whereColumns)).push({
+                first,
+                op: "=",
+                second: opOrSecond,
+                boolean: "and",
+            });
+        }
+        else {
+            this.#simple = false;
+            (this.#whereColumns = mqMut(this.#whereColumns)).push({
+                first,
+                op: opOrSecond,
+                second,
+                boolean: "and",
+            });
+        }
+        return this;
+    }
+    orWhereColumn(first, opOrSecond, second) {
+        if (second === undefined) {
+            this.#simple = false;
+            (this.#whereColumns = mqMut(this.#whereColumns)).push({
+                first,
+                op: "=",
+                second: opOrSecond,
+                boolean: "or",
+            });
+        }
+        else {
+            this.#simple = false;
+            (this.#whereColumns = mqMut(this.#whereColumns)).push({
+                first,
+                op: opOrSecond,
+                second,
+                boolean: "or",
+            });
+        }
+        return this;
+    }
+    whereRaw(sql, bindings = []) {
+        this.#simple = false;
+        (this.#whereRaws = mqMut(this.#whereRaws)).push({ sql, bindings, boolean: "and" });
+        return this;
+    }
+    orWhereRaw(sql, bindings = []) {
+        this.#simple = false;
+        (this.#whereRaws = mqMut(this.#whereRaws)).push({ sql, bindings, boolean: "or" });
+        return this;
+    }
+    whereLike(column, value, caseSensitive = false) {
+        this.#simple = false;
+        (this.#whereLikes = mqMut(this.#whereLikes)).push({
+            column,
+            value,
+            not: false,
+            caseSensitive,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereLike(column, value, caseSensitive = false) {
+        this.#simple = false;
+        (this.#whereLikes = mqMut(this.#whereLikes)).push({
+            column,
+            value,
+            not: false,
+            caseSensitive,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereNotLike(column, value, caseSensitive = false) {
+        this.#simple = false;
+        (this.#whereLikes = mqMut(this.#whereLikes)).push({
+            column,
+            value,
+            not: true,
+            caseSensitive,
+            boolean: "and",
+        });
+        return this;
+    }
+    orWhereNotLike(column, value, caseSensitive = false) {
+        this.#simple = false;
+        (this.#whereLikes = mqMut(this.#whereLikes)).push({
+            column,
+            value,
+            not: true,
+            caseSensitive,
+            boolean: "or",
+        });
+        return this;
+    }
+    whereDate(column, opOrValue, value) {
+        const op = value === undefined ? "=" : String(opOrValue);
+        const raw = (value === undefined ? opOrValue : value);
+        this.#simple = false;
+        (this.#dateWheres = mqMut(this.#dateWheres)).push({ column, op, value: raw, kind: "date" });
+        return this;
+    }
+    whereYear(column, value) {
+        this.#simple = false;
+        (this.#dateWheres = mqMut(this.#dateWheres)).push({
+            column,
+            op: "=",
+            value: String(value),
+            kind: "year",
+        });
+        return this;
+    }
+    whereMonth(column, value) {
+        this.#simple = false;
+        (this.#dateWheres = mqMut(this.#dateWheres)).push({
+            column,
+            op: "=",
+            value: String(value),
+            kind: "month",
+        });
+        return this;
+    }
+    whereDay(column, value) {
+        this.#simple = false;
+        (this.#dateWheres = mqMut(this.#dateWheres)).push({
+            column,
+            op: "=",
+            value: String(value),
+            kind: "day",
+        });
+        return this;
+    }
+    select(...columns) {
+        this.#simple = false;
+        this.#selectColumns = columns.flat();
+        return this;
+    }
+    addSelect(...columns) {
+        this.#simple = false;
+        (this.#addSelectColumns = mqMut(this.#addSelectColumns)).push(...columns.flat());
+        return this;
+    }
+    selectRaw(expression, bindings = []) {
+        this.#simple = false;
+        (this.#selectRaws = mqMut(this.#selectRaws)).push({ expression, bindings });
+        return this;
+    }
+    distinct(value = true) {
+        if (value)
+            this.#simple = false;
+        this.#distinct = value;
+        return this;
+    }
+    orderBy(column, direction = "asc") {
+        (this.#orders = mqMut(this.#orders)).push({ column, direction });
+        return this;
+    }
+    orderByDesc(column) {
+        return this.orderBy(column, "desc");
+    }
+    orderByRaw(sql) {
+        this.#simple = false;
+        (this.#orders = mqMut(this.#orders)).push({ raw: sql });
+        return this;
+    }
+    /** Karobar / dialect alias for `orderByRaw`. */
+    orderBySql(sql) {
+        return this.orderByRaw(sql);
+    }
+    reorder(column, direction = "asc") {
+        this.#orders = [];
+        if (column !== undefined)
+            this.orderBy(column, direction);
+        return this;
+    }
+    inRandomOrder() {
+        this.#simple = false;
+        (this.#orders = mqMut(this.#orders)).push({ raw: "__inRandomOrder__" });
+        return this;
+    }
+    latest(column = "created_at") {
+        return this.orderBy(column, "desc");
+    }
+    oldest(column = "created_at") {
+        return this.orderBy(column, "asc");
+    }
+    groupBy(...columns) {
+        this.#simple = false;
+        (this.#groupByColumns = mqMut(this.#groupByColumns)).push(...columns.flat());
+        return this;
+    }
+    having(column, op, value) {
+        this.#simple = false;
+        (this.#havings = mqMut(this.#havings)).push({ column, op, value });
+        return this;
+    }
+    havingRaw(sql, bindings = []) {
+        this.#simple = false;
+        (this.#havingRaws = mqMut(this.#havingRaws)).push({ sql, bindings });
+        return this;
+    }
+    limit(value) {
+        this.#limitValue = value;
+        return this;
+    }
+    take(value) {
+        return this.limit(value);
+    }
+    offset(value) {
+        this.#offsetValue = value;
+        return this;
+    }
+    skip(value) {
+        return this.offset(value);
+    }
+    forPage(page, perPage = 15) {
+        const p = Math.max(1, Math.floor(page) || 1);
+        const size = Math.max(1, Math.floor(perPage) || 15);
+        return this.limit(size).offset((p - 1) * size);
+    }
+    lockForUpdate() {
+        this.#simple = false;
+        this.#lock = "update";
+        return this;
+    }
+    sharedLock() {
+        this.#simple = false;
+        this.#lock = "share";
+        return this;
+    }
+    when(condition, callback, defaultCallback) {
+        if (condition)
+            callback(this);
+        else if (defaultCallback)
+            defaultCallback(this);
+        return this;
+    }
+    /**
+     * OR `LIKE %term%` across columns (Karobar list `search`).
+     * Empty/whitespace term is a no-op.
+     */
+    search(columns, term) {
+        const needle = String(term ?? "").trim();
+        if (!needle || columns.length === 0)
+            return this;
+        const pattern = `%${needle}%`;
+        return this.where((q) => {
+            for (let i = 0; i < columns.length; i++) {
+                const col = columns[i];
+                if (i === 0)
+                    q.where(col, "like", pattern);
+                else
+                    q.orWhere(col, "like", pattern);
+            }
+        });
+    }
+    unless(condition, callback, defaultCallback) {
+        return this.when(!condition, callback, defaultCallback);
+    }
+    tap(callback) {
+        callback(this);
+        return this;
+    }
+    clone() {
+        const copy = new ModelQuery(this.model, {
+            withTrashed: this.#withTrashed,
+            onlyTrashed: this.#onlyTrashed,
+            eagerLoad: this.#eagerLoad.map((e) => ({ ...e })),
+            withoutGlobalScopes: this.#withoutGlobalScopes === true
+                ? true
+                : this.#withoutGlobalScopes
+                    ? [...this.#withoutGlobalScopes]
+                    : undefined,
+            connection: this.#connection,
+        });
+        copy.#wheres = this.#wheres.map((w) => ({ ...w }));
+        copy.#pendingAttributes = { ...this.#pendingAttributes };
+        copy.#whereIns = this.#whereIns.map((w) => ({
+            ...w,
+            values: [...w.values],
+        }));
+        copy.#whereNulls = this.#whereNulls.map((w) => ({ ...w }));
+        copy.#whereBetweens = this.#whereBetweens.map((w) => ({
+            ...w,
+            values: [...w.values],
+        }));
+        copy.#whereColumns = this.#whereColumns.map((w) => ({ ...w }));
+        copy.#whereRaws = this.#whereRaws.map((w) => ({
+            ...w,
+            bindings: [...w.bindings],
+        }));
+        copy.#whereLikes = this.#whereLikes.map((w) => ({ ...w }));
+        copy.#dateWheres = this.#dateWheres.map((w) => ({ ...w }));
+        copy.#orders = this.#orders.map((o) => ({ ...o }));
+        copy.#selectColumns = this.#selectColumns
+            ? [...this.#selectColumns]
+            : null;
+        copy.#addSelectColumns = [...this.#addSelectColumns];
+        copy.#selectRaws = this.#selectRaws.map((s) => ({
+            ...s,
+            bindings: [...s.bindings],
+        }));
+        copy.#distinct = this.#distinct;
+        copy.#limitValue = this.#limitValue;
+        copy.#offsetValue = this.#offsetValue;
+        copy.#groupByColumns = [...this.#groupByColumns];
+        copy.#havings = this.#havings.map((h) => ({ ...h }));
+        copy.#havingRaws = this.#havingRaws.map((h) => ({
+            ...h,
+            bindings: [...h.bindings],
+        }));
+        copy.#lock = this.#lock;
+        copy.#hasConstraints = this.#hasConstraints.map((c) => ({
+            ...c,
+            existsBindings: c.existsBindings ? [...c.existsBindings] : undefined,
+        }));
+        copy.#withCounts = [...this.#withCounts];
+        copy.#withAggregates = this.#withAggregates.map((a) => ({ ...a }));
+        copy.#morphHasConstraints = this.#morphHasConstraints.map((m) => ({
+            ...m,
+            types: [...m.types],
+        }));
+        copy.#builderExtras = [...this.#builderExtras];
+        copy.#nestedGroups = this.#nestedGroups.map((g) => ({ ...g }));
+        copy.#joins = this.#joins.map((j) => ({ ...j }));
+        copy.#nestedWhereGroup = this.#nestedWhereGroup;
+        copy.#casts = { ...this.#casts };
+        copy.#hasQueryCasts = this.#hasQueryCasts;
+        copy.#simple = this.#simple;
+        copy.#hasRetrievedListeners = this.#hasRetrievedListeners;
+        copy.#asRows = this.#asRows;
+        return copy;
+    }
+    with(...relations) {
+        (this.#eagerLoad = mqMut(this.#eagerLoad)).push(...normalizeWithRelations(relations));
+        return this;
+    }
+    /** Underlying query builder (fresh compile each call). */
+    toBase() {
+        return this.#buildQuery();
+    }
+    /** Compiled SQL (bindings via `getBindings()`). */
+    toSql() {
+        return this.#buildQuery().toSql();
+    }
+    /** SQL with bindings interpolated for debugging. */
+    toRawSql() {
+        return this.#buildQuery().toRawSql();
+    }
+    getBindings() {
+        return this.#buildQuery().getBindings();
+    }
+    dump() {
+        console.log(this.toRawSql());
+        return this;
+    }
+    dd() {
+        console.log(this.toRawSql());
+        process.exit(1);
+    }
+    #applySoftDeletes(q) {
+        if (!usesSoftDeletes(this.model))
+            return q;
+        const col = this.#qualifyParentColumn(deletedAtColumn(this.model));
+        if (this.#onlyTrashed)
+            return q.whereNotNull(col);
+        if (!this.#withTrashed)
+            return q.whereNull(col);
+        return q;
+    }
+    /**
+     * True when this query can compile without a full QueryBuilder
+     * (basic wheres + order + limit/offset, optional plain column list).
+     * Global scopes that only add basic wheres stay on this path.
+     */
+    #simplePlan() {
+        if (this.#exoticConstraints())
+            return undefined;
+        let columns = "*";
+        if (!this.#simple) {
+            // `select('id', 'name')` is the usual reason a flat query leaves this path.
+            if (this.#selectColumns == null)
+                return undefined;
+            const plain = plainColumnList(this.#selectColumns);
+            if (plain == null || !wheresAreSimple(this.#wheres))
+                return undefined;
+            columns = plain;
+        }
+        const scopeWheres = this.#scopeWheres();
+        if (scopeWheres == null)
+            return undefined;
+        return { columns, scopeWheres };
+    }
+    /** Joins, raws, groups, and other shapes the simple compiler does not emit. */
+    #exoticConstraints() {
+        return (this.#joins.length > 0 ||
+            this.#morphHasConstraints.length > 0 ||
+            this.#nestedGroups.length > 0 ||
+            this.#builderExtras.length > 0 ||
+            this.#withCounts.length > 0 ||
+            this.#withAggregates.length > 0 ||
+            this.#addSelectColumns.length > 0 ||
+            this.#selectRaws.length > 0 ||
+            this.#distinct ||
+            this.#groupByColumns.length > 0 ||
+            this.#havings.length > 0 ||
+            this.#havingRaws.length > 0 ||
+            this.#lock !== false ||
+            this.#whereIns.length > 0 ||
+            this.#whereNulls.length > 0 ||
+            this.#whereBetweens.length > 0 ||
+            this.#whereColumns.length > 0 ||
+            this.#whereRaws.length > 0 ||
+            this.#whereLikes.length > 0 ||
+            this.#dateWheres.length > 0 ||
+            this.#hasConstraints.length > 0);
+    }
+    /**
+     * Basic wheres added by global scopes, or null when a scope needs the full builder.
+     * An empty list means every scope was a no-op (for example no current tenant).
+     */
+    #scopeWheres() {
+        if (this.#withoutGlobalScopes === true)
+            return [];
+        if (!hasGlobalScopes(this.model))
+            return [];
+        const wheres = [];
+        for (const [name, scope] of getGlobalScopes(this.model)) {
+            if (this.#withoutGlobalScopes?.has(name))
+                continue;
+            const temp = new ModelQuery(this.model, {
+                withoutGlobalScopes: true,
+                withTrashed: this.#withTrashed,
+                onlyTrashed: this.#onlyTrashed,
+            });
+            scope(temp);
+            if (!temp.#simple || temp.#exoticConstraints() || !wheresAreSimple(temp.#wheres)) {
+                return null;
+            }
+            for (const where of temp.#wheres)
+                wheres.push(where);
+        }
+        return wheres;
+    }
+    /** Compile a simple SELECT matching QueryBuilder's default shape. */
+    #compileSimpleSelect(conn = this.#queryConnection(), plan = { columns: "*", scopeWheres: [] }) {
+        const dialect = conn.dialect;
+        const params = [];
+        // Fingerprint (no values) — reuse quoted SQL for repeated list shapes.
+        let key = this.#withTrashed ? "T" : this.#onlyTrashed ? "O" : "N";
+        key += `\u001e${this.model.table}\u001e${plan.columns}`;
+        for (const w of plan.scopeWheres) {
+            key += `\u001eG\u001e${w.boolean}\u001e${w.column}\u001e${w.op}`;
+            if (w.op !== "__null__" && w.op !== "__notnull__")
+                params.push(w.value);
+        }
+        for (const w of this.#wheres) {
+            key += `\u001e${w.boolean}\u001e${w.column}\u001e${w.op}`;
+            if (w.op !== "__null__" && w.op !== "__notnull__")
+                params.push(w.value);
+        }
+        for (const o of this.#orders) {
+            if ("raw" in o)
+                key += `\u001eR\u001e${o.raw}`;
+            else
+                key += `\u001eO\u001e${o.column}\u001e${o.direction}`;
+        }
+        if (this.#limitValue !== undefined)
+            key += `\u001eL\u001e${this.#limitValue}`;
+        if (this.#offsetValue !== undefined)
+            key += `\u001eF\u001e${this.#offsetValue}`;
+        if (usesSoftDeletes(this.model))
+            key += "\u001eS";
+        let byModel = simpleSelectSqlCache.get(this.model);
+        if (!byModel) {
+            byModel = new Map();
+            simpleSelectSqlCache.set(this.model, byModel);
+        }
+        let sql = byModel.get(key);
+        if (sql !== undefined)
+            return { sql, params };
+        const wrap = (name) => wrapSqlName(dialect, name);
+        const whereParts = [];
+        const pushBool = (boolean) => {
+            if (whereParts.length === 0)
+                return "";
+            return boolean === "or" ? " OR " : " AND ";
+        };
+        if (usesSoftDeletes(this.model)) {
+            const col = wrap(deletedAtColumn(this.model));
+            if (this.#onlyTrashed) {
+                whereParts.push(`${col} IS NOT NULL`);
+            }
+            else if (!this.#withTrashed) {
+                whereParts.push(`${col} IS NULL`);
+            }
+        }
+        const appendWhere = (w) => {
+            const bool = pushBool(w.boolean);
+            const col = wrap(w.column);
+            if (w.op === "__null__") {
+                whereParts.push(`${bool}${col} IS NULL`);
+                return;
+            }
+            if (w.op === "__notnull__") {
+                whereParts.push(`${bool}${col} IS NOT NULL`);
+                return;
+            }
+            whereParts.push(`${bool}${col} ${w.op} ?`);
+        };
+        // Scope predicates first, then the query's own wheres (matches builder order).
+        for (const w of plan.scopeWheres)
+            appendWhere(w);
+        for (const w of this.#wheres)
+            appendWhere(w);
+        sql = `SELECT ${plan.columns} FROM ${this.model.table}`;
+        if (whereParts.length > 0) {
+            sql += ` WHERE ${whereParts.join("")}`;
+        }
+        if (this.#orders.length > 0) {
+            sql += ` ORDER BY ${this.#orders
+                .map((o) => {
+                if ("raw" in o)
+                    return o.raw;
+                return `${wrap(o.column)} ${o.direction.toUpperCase()}`;
+            })
+                .join(", ")}`;
+        }
+        if (this.#limitValue !== undefined) {
+            sql += ` LIMIT ${this.#limitValue}`;
+        }
+        if (this.#offsetValue !== undefined) {
+            sql += ` OFFSET ${this.#offsetValue}`;
+        }
+        byModel.set(key, sql);
+        return { sql, params };
+    }
+    /**
+     * Fetch rows without allocating a QueryBuilder when the shape is simple
+     * or a call-time-compiled whereHas EXISTS (SQLite hot path).
+     * Returns undefined to fall back to the full builder path.
+     */
+    #trySimpleRows() {
+        const conn = this.#queryConnection();
+        let compiled;
+        const plan = this.#simplePlan();
+        if (plan) {
+            compiled = this.#compileSimpleSelect(conn, plan);
+        }
+        else if (this.#canHasExistsSelect()) {
+            compiled = this.#compileHasExistsSelect(conn);
+        }
+        else {
+            return undefined;
+        }
+        const { sql, params } = compiled;
+        if (conn.allSync) {
+            return conn.allSync(sql, params);
+        }
+        if (conn.driver === "postgres" &&
+            params.length === 0 &&
+            !hasQueryListeners()) {
+            const raw = conn.raw;
+            if (raw && typeof raw.unsafe === "function") {
+                return raw.unsafe(sql);
+            }
+        }
+        return conn.all(sql, params);
+    }
+    #trySimpleFirst() {
+        const plan = this.#simplePlan();
+        const useHas = !plan && this.#canHasExistsSelect();
+        if (!plan && !useHas)
+            return undefined;
+        // Match Builder.first(): LIMIT 1 (preserve explicit smaller limit).
+        const prev = this.#limitValue;
+        if (prev === undefined || prev > 1)
+            this.#limitValue = 1;
+        try {
+            const conn = this.#queryConnection();
+            const { sql, params } = plan
+                ? this.#compileSimpleSelect(conn, plan)
+                : this.#compileHasExistsSelect(conn);
+            if (conn.getSync) {
+                return conn.getSync(sql, params) ?? null;
+            }
+            if (conn.allSync) {
+                const rows = conn.allSync(sql, params);
+                return rows[0] ?? null;
+            }
+            return conn.all(sql, params).then((rows) => rows[0] ?? null);
+        }
+        finally {
+            this.#limitValue = prev;
+        }
+    }
+    /**
+     * whereHas/whereDoesntHave with call-time EXISTS SQL + flat parent wheres only.
+     * Skips QueryBuilder on SQLite get/getSync (same idea as #canSimpleSelect).
+     */
+    #canHasExistsSelect() {
+        if (this.#hasConstraints.length === 0)
+            return false;
+        for (const c of this.#hasConstraints) {
+            if (c.existsSql === undefined)
+                return false;
+        }
+        if (hasGlobalScopes(this.model) && this.#withoutGlobalScopes !== true) {
+            return false;
+        }
+        if (this.#joins.length > 0)
+            return false;
+        if (this.#morphHasConstraints.length > 0)
+            return false;
+        if (this.#nestedGroups.length > 0)
+            return false;
+        if (this.#builderExtras.length > 0)
+            return false;
+        if (this.#withCounts.length > 0 || this.#withAggregates.length > 0)
+            return false;
+        if (this.#selectColumns || this.#addSelectColumns.length > 0)
+            return false;
+        if (this.#selectRaws.length > 0 || this.#distinct)
+            return false;
+        if (this.#groupByColumns.length > 0)
+            return false;
+        if (this.#havings.length > 0 || this.#havingRaws.length > 0)
+            return false;
+        if (this.#lock)
+            return false;
+        if (this.#whereIns.length > 0 || this.#whereNulls.length > 0)
+            return false;
+        if (this.#whereBetweens.length > 0 || this.#whereColumns.length > 0)
+            return false;
+        if (this.#whereRaws.length > 0 || this.#whereLikes.length > 0)
+            return false;
+        if (this.#dateWheres.length > 0)
+            return false;
+        return true;
+    }
+    /** Compile SELECT … WHERE [parent] EXISTS (cached subquery) [LIMIT]. */
+    #compileHasExistsSelect(conn = this.#queryConnection()) {
+        const dialect = conn.dialect;
+        const params = [];
+        let key = this.#withTrashed ? "T" : this.#onlyTrashed ? "O" : "N";
+        key += `\u001e${this.model.table}`;
+        for (const w of this.#wheres) {
+            key += `\u001e${w.boolean}\u001e${w.column}\u001e${w.op}`;
+            if (w.op !== "__null__" && w.op !== "__notnull__")
+                params.push(w.value);
+        }
+        for (const c of this.#hasConstraints) {
+            key += `\u001eH\u001e${c.not ? "1" : "0"}\u001e${c.or ? "1" : "0"}\u001e${c.inColumn ?? ""}\u001e${c.existsSql}`;
+            if (c.existsBindings?.length)
+                params.push(...c.existsBindings);
+        }
+        for (const o of this.#orders) {
+            if ("raw" in o)
+                key += `\u001eR\u001e${o.raw}`;
+            else
+                key += `\u001eO\u001e${o.column}\u001e${o.direction}`;
+        }
+        if (this.#limitValue !== undefined)
+            key += `\u001eL\u001e${this.#limitValue}`;
+        if (this.#offsetValue !== undefined)
+            key += `\u001eF\u001e${this.#offsetValue}`;
+        if (usesSoftDeletes(this.model))
+            key += "\u001eS";
+        let byModel = hasExistsSelectSqlCache.get(this.model);
+        if (!byModel) {
+            byModel = new Map();
+            hasExistsSelectSqlCache.set(this.model, byModel);
+        }
+        let sql = byModel.get(key);
+        if (sql !== undefined)
+            return { sql, params };
+        const wrap = (name) => wrapSqlName(dialect, name);
+        const whereParts = [];
+        const pushBool = (boolean) => {
+            if (whereParts.length === 0)
+                return "";
+            return boolean === "or" ? " OR " : " AND ";
+        };
+        if (usesSoftDeletes(this.model)) {
+            const col = wrap(deletedAtColumn(this.model));
+            if (this.#onlyTrashed) {
+                whereParts.push(`${col} IS NOT NULL`);
+            }
+            else if (!this.#withTrashed) {
+                whereParts.push(`${col} IS NULL`);
+            }
+        }
+        for (const w of this.#wheres) {
+            const bool = pushBool(w.boolean);
+            const col = wrap(w.column);
+            if (w.op === "__null__") {
+                whereParts.push(`${bool}${col} IS NULL`);
+                continue;
+            }
+            if (w.op === "__notnull__") {
+                whereParts.push(`${bool}${col} IS NOT NULL`);
+                continue;
+            }
+            whereParts.push(`${bool}${col} ${w.op} ?`);
+        }
+        for (const c of this.#hasConstraints) {
+            const bool = pushBool(c.or ? "or" : "and");
+            if (c.inColumn) {
+                whereParts.push(`${bool}${c.inColumn} ${c.not ? "NOT IN" : "IN"} (${c.existsSql})`);
+            }
+            else {
+                whereParts.push(`${bool}${c.not ? "NOT EXISTS" : "EXISTS"} (${c.existsSql})`);
+            }
+        }
+        sql = `SELECT * FROM ${this.model.table}`;
+        if (whereParts.length > 0) {
+            sql += ` WHERE ${whereParts.join("")}`;
+        }
+        if (this.#orders.length > 0) {
+            sql += ` ORDER BY ${this.#orders
+                .map((o) => {
+                if ("raw" in o)
+                    return o.raw;
+                return `${wrap(o.column)} ${o.direction.toUpperCase()}`;
+            })
+                .join(", ")}`;
+        }
+        if (this.#limitValue !== undefined) {
+            sql += ` LIMIT ${this.#limitValue}`;
+        }
+        if (this.#offsetValue !== undefined) {
+            sql += ` OFFSET ${this.#offsetValue}`;
+        }
+        byModel.set(key, sql);
+        return { sql, params };
+    }
+    #buildQuery() {
+        let q = this.#baseTable();
+        q = this.#applySoftDeletes(q);
+        q = this.#applyGlobalScopesTo(q);
+        this.#qualifyParentConstraintsForJoins();
+        q = this.applyConstraintsTo(q);
+        if (this.#joins.length > 0) {
+            if (!this.#selectColumns && this.#addSelectColumns.length === 0) {
+                q = q.select(`${this.model.table}.*`);
+            }
+            for (const j of this.#joins) {
+                if (j.type === "left") {
+                    q = q.leftJoin(j.table, j.first, j.op, j.second);
+                }
+                else if (j.type === "right") {
+                    q = q.rightJoin(j.table, j.first, j.op, j.second);
+                }
+                else {
+                    q = q.join(j.table, j.first, j.op, j.second);
+                }
+            }
+        }
+        if (this.#selectColumns) {
+            q = q.select(...this.#selectColumns);
+        }
+        if (this.#addSelectColumns.length > 0) {
+            q = q.addSelect(...this.#addSelectColumns);
+        }
+        for (const raw of this.#selectRaws) {
+            q = q.selectRaw(raw.expression, raw.bindings);
+        }
+        if (this.#distinct)
+            q = q.distinct();
+        for (const o of this.#orders) {
+            if ("raw" in o) {
+                q =
+                    o.raw === "__inRandomOrder__"
+                        ? q.inRandomOrder()
+                        : q.orderByRaw(o.raw);
+            }
+            else
+                q = q.orderBy(o.column, o.direction);
+        }
+        if (this.#groupByColumns.length > 0) {
+            q = q.groupBy(...this.#groupByColumns);
+        }
+        for (const h of this.#havings) {
+            q = q.having(h.column, h.op, h.value);
+        }
+        for (const h of this.#havingRaws) {
+            q = q.havingRaw(h.sql, h.bindings);
+        }
+        for (const extra of this.#builderExtras) {
+            extra(q);
+        }
+        const aggregates = this.#withAggregates.length > 0
+            ? this.#withAggregates
+            : this.#withCounts.map((relation) => ({
+                relation,
+                alias: `${relation}_count`,
+                fn: "count",
+                column: undefined,
+            }));
+        if (aggregates.length > 0) {
+            q = q.select(`${this.model.table}.*`);
+            for (const agg of aggregates) {
+                const meta = resolveRelation(this.model, agg.relation);
+                if (!meta)
+                    continue;
+                const expr = this.#aggregateSubquery(meta, agg.fn, agg.column);
+                if (!expr)
+                    continue;
+                const alias = wrapSqlName(this.model.getConnection().dialect, agg.alias);
+                q = q.selectRaw(`(${expr}) as ${alias}`);
+            }
+        }
+        if (this.#limitValue !== undefined)
+            q = q.limit(this.#limitValue);
+        if (this.#offsetValue !== undefined)
+            q = q.offset(this.#offsetValue);
+        if (this.#lock === "update")
+            q = q.lockForUpdate();
+        if (this.#lock === "share")
+            q = q.sharedLock();
+        return q;
+    }
+    #applyGlobalScopesTo(q) {
+        if (this.#withoutGlobalScopes === true)
+            return q;
+        if (!hasGlobalScopes(this.model))
+            return q;
+        for (const [name, scope] of getGlobalScopes(this.model)) {
+            if (this.#withoutGlobalScopes?.has(name))
+                continue;
+            const temp = new ModelQuery(this.model, {
+                withoutGlobalScopes: true,
+                withTrashed: this.#withTrashed,
+                onlyTrashed: this.#onlyTrashed,
+            });
+            scope(temp);
+            // Joined related tables often share column names (e.g. tenant_id).
+            if (this.#joins.length > 0) {
+                temp.qualifyColumns(this.model.table);
+            }
+            q = temp.applyConstraintsTo(q);
+        }
+        return q;
+    }
+    /** Parent-table prefix when BelongsTo whereHas (or other joins) are present. */
+    #qualifyParentColumn(column) {
+        if (this.#joins.length === 0 || column.includes("."))
+            return column;
+        return `${this.model.table}.${column}`;
+    }
+    /**
+     * Qualify unqualified parent wheres before JOIN so shared columns
+     * (tenant_id, …) are not ambiguous on Postgres.
+     */
+    #qualifyParentConstraintsForJoins() {
+        if (this.#joins.length === 0)
+            return;
+        this.qualifyColumns(this.model.table);
+    }
+    /**
+     * Prefix unqualified columns with `table.` (BelongsTo whereHas → JOIN path).
+     */
+    qualifyColumns(table) {
+        const qual = (column) => column.includes(".") ? column : `${table}.${column}`;
+        for (const w of this.#wheres)
+            w.column = qual(w.column);
+        for (const w of this.#whereIns)
+            w.column = qual(w.column);
+        for (const w of this.#whereNulls)
+            w.column = qual(w.column);
+        for (const w of this.#whereBetweens)
+            w.column = qual(w.column);
+        for (const w of this.#whereLikes)
+            w.column = qual(w.column);
+        for (const w of this.#dateWheres)
+            w.column = qual(w.column);
+        for (const w of this.#whereColumns) {
+            w.first = qual(w.first);
+            w.second = qual(w.second);
+        }
+        return this;
+    }
+    /** Apply this query's wheres onto a QueryBuilder (exists subqueries). */
+    applyConstraintsTo(q) {
+        for (const w of this.#wheres) {
+            if (w.op === "__null__") {
+                q =
+                    w.boolean === "or" ? q.orWhereNull(w.column) : q.whereNull(w.column);
+                continue;
+            }
+            if (w.op === "__notnull__") {
+                q =
+                    w.boolean === "or"
+                        ? q.orWhereNotNull(w.column)
+                        : q.whereNotNull(w.column);
+                continue;
+            }
+            q =
+                w.boolean === "or"
+                    ? q.orWhere(w.column, w.op, w.value)
+                    : q.where(w.column, w.op, w.value);
+        }
+        for (const w of this.#whereIns) {
+            if (w.boolean === "or") {
+                q = w.not
+                    ? q.orWhereNotIn(w.column, w.values)
+                    : q.orWhereIn(w.column, w.values);
+            }
+            else {
+                q = w.not
+                    ? q.whereNotIn(w.column, w.values)
+                    : q.whereIn(w.column, w.values);
+            }
+        }
+        for (const w of this.#whereNulls) {
+            if (w.boolean === "or") {
+                q = w.not ? q.orWhereNotNull(w.column) : q.orWhereNull(w.column);
+            }
+            else {
+                q = w.not ? q.whereNotNull(w.column) : q.whereNull(w.column);
+            }
+        }
+        for (const w of this.#whereBetweens) {
+            if (w.boolean === "or") {
+                q = w.not
+                    ? q.orWhereNotBetween(w.column, w.values)
+                    : q.orWhereBetween(w.column, w.values);
+            }
+            else {
+                q = w.not
+                    ? q.whereNotBetween(w.column, w.values)
+                    : q.whereBetween(w.column, w.values);
+            }
+        }
+        for (const w of this.#whereColumns) {
+            q =
+                w.boolean === "or"
+                    ? q.orWhereColumn(w.first, w.op, w.second)
+                    : q.whereColumn(w.first, w.op, w.second);
+        }
+        for (const w of this.#whereRaws) {
+            q =
+                w.boolean === "or"
+                    ? q.orWhereRaw(w.sql, w.bindings)
+                    : q.whereRaw(w.sql, w.bindings);
+        }
+        for (const w of this.#whereLikes) {
+            if (w.boolean === "or") {
+                q = w.not
+                    ? q.orWhereNotLike(w.column, w.value, w.caseSensitive)
+                    : q.orWhereLike(w.column, w.value, w.caseSensitive);
+            }
+            else {
+                q = w.not
+                    ? q.whereNotLike(w.column, w.value, w.caseSensitive)
+                    : q.whereLike(w.column, w.value, w.caseSensitive);
+            }
+        }
+        for (const w of this.#dateWheres) {
+            if (w.kind === "date")
+                q = q.whereDate(w.column, w.op, w.value);
+            else if (w.kind === "year")
+                q = q.whereYear(w.column, w.op, Number(w.value));
+            else if (w.kind === "month")
+                q = q.whereMonth(w.column, w.op, Number(w.value));
+            else
+                q = q.whereDay(w.column, w.op, Number(w.value));
+        }
+        for (const constraint of this.#hasConstraints) {
+            q = this.#applyHasConstraint(q, constraint);
+        }
+        for (const morph of this.#morphHasConstraints) {
+            q = this.#applyMorphHasConstraint(q, morph);
+        }
+        for (const group of this.#nestedGroups) {
+            const run = (subQ) => {
+                const nested = this.model.newQuery({
+                    withoutGlobalScopes: true,
+                    withTrashed: this.#withTrashed,
+                    onlyTrashed: this.#onlyTrashed,
+                    nestedWhereGroup: true,
+                });
+                group.callback(nested);
+                nested.applyConstraintsTo(subQ);
+            };
+            if (group.not) {
+                q = group.boolean === "or" ? q.orWhereNot(run) : q.whereNot(run);
+            }
+            else {
+                q =
+                    group.boolean === "or" ? q.orWhereNested(run) : q.whereNested(run);
+            }
+        }
+        return q;
+    }
+    /**
+     * HasMany / BelongsToMany / MorphToMany whereHas → correlated EXISTS.
+     * Resolve meta + run related callback once at call time (same freeze as BelongsTo join expand).
+     * Mergeable flat callbacks become a lightweight apply (no ModelQuery retained).
+     */
+    #pushHasConstraint(relation, not, or, callback, metaHint) {
+        const meta = metaHint === undefined ? resolveRelation(this.model, relation) : metaHint;
+        if (!meta) {
+            (this.#hasConstraints = mqMut(this.#hasConstraints)).push({
+                relation,
+                not,
+                or,
+                callback,
+            });
+            return this;
+        }
+        if (meta.kind === "has" ||
+            meta.kind === "belongsToMany" ||
+            meta.kind === "morphToMany") {
+            let applyRelated;
+            let relatedQuery;
+            if (callback) {
+                const rq = meta.related.newQuery({
+                    withoutGlobalScopes: true,
+                });
+                callback(rq);
+                if (this.#relatedConstraintsAreMergeable(rq)) {
+                    applyRelated = this.#bindFlatRelatedApply(rq);
+                }
+                else {
+                    relatedQuery = rq;
+                    applyRelated = (sub) => {
+                        rq.applyConstraintsTo(sub);
+                    };
+                }
+            }
+            this.#pushHasConstraintWithRelatedApply(relation, not, or, meta, applyRelated);
+            // Attach relatedQuery on the constraint we just pushed (belongsTo or/not reuse).
+            if (relatedQuery) {
+                const last = this.#hasConstraints[this.#hasConstraints.length - 1];
+                last.relatedQuery = relatedQuery;
+            }
+            return this;
+        }
+        // belongsTo or/not / unsupported: cache meta (+ optional relatedQuery) for #applyHasConstraint.
+        let relatedQuery;
+        if (callback) {
+            relatedQuery = meta.related.newQuery({
+                withoutGlobalScopes: true,
+            });
+            callback(relatedQuery);
+        }
+        (this.#hasConstraints = mqMut(this.#hasConstraints)).push({
+            relation,
+            not,
+            or,
+            meta,
+            relatedQuery,
+        });
+        return this;
+    }
+    /**
+     * HasMany / BelongsToMany / MorphToMany existence constraint.
+     * Call-time bake: HasMany → EXISTS (SELECT 1 … LIMIT 1); BelongsToMany →
+     * parent.pk IN (SELECT pivot.fk …) when not tenant-correlated (SQLite avoids
+     * correlated SCAN). Morph tenant correlation keeps EXISTS.
+     */
+    #pushHasConstraintWithRelatedApply(relation, not, or, meta, applyRelated) {
+        const parentTable = this.model.table;
+        let applyExists;
+        let inColumn;
+        if (meta.kind === "has") {
+            const relatedTable = meta.related.table;
+            const foreignKey = meta.foreignKey;
+            const localKey = meta.localKey;
+            const selfAlias = relatedTable === parentTable ? `${relatedTable}_has` : null;
+            applyExists = (sub) => {
+                if (selfAlias) {
+                    sub.from(`${relatedTable} as ${selfAlias}`);
+                    sub.whereColumn(`${selfAlias}.${foreignKey}`, `${parentTable}.${localKey}`);
+                }
+                else {
+                    sub.from(relatedTable);
+                    sub.whereColumn(`${relatedTable}.${foreignKey}`, `${parentTable}.${localKey}`);
+                }
+                applyRelated?.(sub);
+            };
+        }
+        else if (meta.kind === "belongsToMany" || meta.kind === "morphToMany") {
+            const relatedTable = meta.related.table;
+            const relatedPk = meta.related.primaryKey;
+            const pivotTable = meta.pivotTable;
+            const relatedPivotKey = meta.relatedPivotKey;
+            const foreignPivotKey = meta.foreignPivotKey;
+            const localKey = meta.localKey;
+            const morphTypeColumn = meta.kind === "morphToMany" ? meta.morphTypeColumn : null;
+            const morphTypes = meta.kind === "morphToMany" ? meta.morphTypes : null;
+            const pivotTenantKey = meta.kind === "morphToMany" ? meta.pivotTenantKey : null;
+            const parentTenantKey = meta.kind === "morphToMany" ? meta.parentTenantKey : null;
+            // Tenant correlation must stay EXISTS; otherwise use IN (same rows, much
+            // faster on SQLite without pivot indexes).
+            const tenantCorrelated = Boolean(pivotTenantKey && parentTenantKey);
+            if (!tenantCorrelated) {
+                inColumn = `${parentTable}.${localKey}`;
+                applyExists = (sub) => {
+                    sub.from(relatedTable);
+                    sub.join(pivotTable, `${pivotTable}.${relatedPivotKey}`, "=", `${relatedTable}.${relatedPk}`);
+                    if (morphTypeColumn && morphTypes) {
+                        sub.whereIn(`${pivotTable}.${morphTypeColumn}`, morphTypes);
+                    }
+                    applyRelated?.(sub);
+                    sub.select(`${pivotTable}.${foreignPivotKey}`);
+                };
+            }
+            else {
+                applyExists = (sub) => {
+                    sub.from(relatedTable);
+                    sub.join(pivotTable, `${pivotTable}.${relatedPivotKey}`, "=", `${relatedTable}.${relatedPk}`);
+                    sub.whereColumn(`${pivotTable}.${foreignPivotKey}`, `${parentTable}.${localKey}`);
+                    if (morphTypeColumn && morphTypes) {
+                        sub.whereIn(`${pivotTable}.${morphTypeColumn}`, morphTypes);
+                        sub.whereColumn(`${pivotTable}.${pivotTenantKey}`, `${parentTable}.${parentTenantKey}`);
+                    }
+                    applyRelated?.(sub);
+                };
+            }
+        }
+        let existsSql;
+        let existsBindings;
+        if (applyExists) {
+            const sub = this.#baseTable();
+            applyExists(sub);
+            // SQLite: correlated EXISTS without LIMIT 1 scans the full related table
+            // per parent row (~10–50× slower). Match withExists aggregate shape.
+            if (!inColumn) {
+                sub.select("1");
+                sub.limit(1);
+            }
+            existsSql = sub.toSql();
+            existsBindings = sub.getBindings();
+        }
+        (this.#hasConstraints = mqMut(this.#hasConstraints)).push({
+            relation,
+            not,
+            or,
+            meta,
+            applyExists,
+            existsSql,
+            existsBindings,
+            inColumn,
+        });
+        return this;
+    }
+    /**
+     * Snapshot flat related wheres into a closure (no ModelQuery on the hot apply path).
+     */
+    #bindFlatRelatedApply(from) {
+        from = unwrapModelQuery(from);
+        const wheres = from.#wheres.length ? from.#wheres.slice() : null;
+        const whereIns = from.#whereIns.length ? from.#whereIns.slice() : null;
+        const whereNulls = from.#whereNulls.length ? from.#whereNulls.slice() : null;
+        const whereBetweens = from.#whereBetweens.length
+            ? from.#whereBetweens.slice()
+            : null;
+        const whereColumns = from.#whereColumns.length
+            ? from.#whereColumns.slice()
+            : null;
+        const whereRaws = from.#whereRaws.length ? from.#whereRaws.slice() : null;
+        const whereLikes = from.#whereLikes.length ? from.#whereLikes.slice() : null;
+        const dateWheres = from.#dateWheres.length ? from.#dateWheres.slice() : null;
+        if (!wheres &&
+            !whereIns &&
+            !whereNulls &&
+            !whereBetweens &&
+            !whereColumns &&
+            !whereRaws &&
+            !whereLikes &&
+            !dateWheres) {
+            return () => { };
+        }
+        return (q) => {
+            if (wheres) {
+                for (const w of wheres) {
+                    if (w.op === "__null__") {
+                        q =
+                            w.boolean === "or" ? q.orWhereNull(w.column) : q.whereNull(w.column);
+                        continue;
+                    }
+                    if (w.op === "__notnull__") {
+                        q =
+                            w.boolean === "or"
+                                ? q.orWhereNotNull(w.column)
+                                : q.whereNotNull(w.column);
+                        continue;
+                    }
+                    q =
+                        w.boolean === "or"
+                            ? q.orWhere(w.column, w.op, w.value)
+                            : q.where(w.column, w.op, w.value);
+                }
+            }
+            if (whereIns) {
+                for (const w of whereIns) {
+                    if (w.boolean === "or") {
+                        q = w.not
+                            ? q.orWhereNotIn(w.column, w.values)
+                            : q.orWhereIn(w.column, w.values);
+                    }
+                    else {
+                        q = w.not
+                            ? q.whereNotIn(w.column, w.values)
+                            : q.whereIn(w.column, w.values);
+                    }
+                }
+            }
+            if (whereNulls) {
+                for (const w of whereNulls) {
+                    if (w.boolean === "or") {
+                        q = w.not ? q.orWhereNotNull(w.column) : q.orWhereNull(w.column);
+                    }
+                    else {
+                        q = w.not ? q.whereNotNull(w.column) : q.whereNull(w.column);
+                    }
+                }
+            }
+            if (whereBetweens) {
+                for (const w of whereBetweens) {
+                    if (w.boolean === "or") {
+                        q = w.not
+                            ? q.orWhereNotBetween(w.column, w.values)
+                            : q.orWhereBetween(w.column, w.values);
+                    }
+                    else {
+                        q = w.not
+                            ? q.whereNotBetween(w.column, w.values)
+                            : q.whereBetween(w.column, w.values);
+                    }
+                }
+            }
+            if (whereColumns) {
+                for (const w of whereColumns) {
+                    q =
+                        w.boolean === "or"
+                            ? q.orWhereColumn(w.first, w.op, w.second)
+                            : q.whereColumn(w.first, w.op, w.second);
+                }
+            }
+            if (whereRaws) {
+                for (const w of whereRaws) {
+                    q =
+                        w.boolean === "or"
+                            ? q.orWhereRaw(w.sql, w.bindings)
+                            : q.whereRaw(w.sql, w.bindings);
+                }
+            }
+            if (whereLikes) {
+                for (const w of whereLikes) {
+                    if (w.boolean === "or") {
+                        q = w.not
+                            ? q.orWhereNotLike(w.column, w.value, w.caseSensitive)
+                            : q.orWhereLike(w.column, w.value, w.caseSensitive);
+                    }
+                    else {
+                        q = w.not
+                            ? q.whereNotLike(w.column, w.value, w.caseSensitive)
+                            : q.whereLike(w.column, w.value, w.caseSensitive);
+                    }
+                }
+            }
+            if (dateWheres) {
+                for (const w of dateWheres) {
+                    if (w.kind === "date")
+                        q = q.whereDate(w.column, w.op, w.value);
+                    else if (w.kind === "year")
+                        q = q.whereYear(w.column, w.op, Number(w.value));
+                    else if (w.kind === "month")
+                        q = q.whereMonth(w.column, w.op, Number(w.value));
+                    else
+                        q = q.whereDay(w.column, w.op, Number(w.value));
+                }
+            }
+        };
+    }
+    /**
+     * BelongsTo whereHas/whereRelation → INNER JOIN on related PK (no parent duplication).
+     * Expands at call time so #buildQuery matches plain join() (no per-get resolve/newQuery).
+     * When the related table is already joined (two BelongsTo on the same table),
+     * uses `table as table_relation` so Postgres does not raise 42712.
+     * Returns related table alias used in the join.
+     */
+    #expandBelongsToHasJoin(meta, callback, relation = "") {
+        const parentTable = this.model.table;
+        const relatedTable = meta.related.table;
+        const relatedAlias = this.#uniqueBelongsToJoinAlias(relatedTable, relation);
+        const joinTable = relatedAlias === relatedTable
+            ? relatedTable
+            : `${relatedTable} as ${relatedAlias}`;
+        (this.#joins = mqMut(this.#joins)).push({
+            type: "inner",
+            table: joinTable,
+            first: `${parentTable}.${meta.foreignKey}`,
+            op: "=",
+            second: `${relatedAlias}.${meta.ownerKey}`,
+        });
+        if (usesSoftDeletes(meta.related)) {
+            const delCol = deletedAtColumn(meta.related);
+            (this.#wheres = mqMut(this.#wheres)).push({
+                column: `${relatedAlias}.${delCol}`,
+                op: "__null__",
+                value: null,
+                boolean: "and",
+            });
+        }
+        if (callback) {
+            const relatedQuery = meta.related.newQuery({
+                withoutGlobalScopes: true,
+            });
+            callback(relatedQuery);
+            relatedQuery.qualifyColumns(relatedAlias);
+            if (this.#relatedConstraintsAreMergeable(relatedQuery)) {
+                this.#mergeRelatedConstraints(relatedQuery);
+            }
+            else {
+                // Nested has / groups must keep related model identity → apply on QB each build.
+                (this.#builderExtras = mqMut(this.#builderExtras)).push((q) => {
+                    relatedQuery.applyConstraintsTo(q);
+                });
+            }
+        }
+        return relatedAlias;
+    }
+    /** Alias already used by a join table (`accounts` or `accounts as foo`). */
+    #joinedNames() {
+        const names = new Set();
+        for (const join of this.#joins) {
+            const parts = join.table.split(/\s+as\s+/i);
+            names.add(parts[0].trim());
+            names.add(parts[parts.length - 1].trim());
+        }
+        return names;
+    }
+    #uniqueBelongsToJoinAlias(relatedTable, relation) {
+        const taken = this.#joinedNames();
+        const parentTable = this.model.table;
+        if (relatedTable === parentTable) {
+            let alias = `${relatedTable}_bt`;
+            let n = 2;
+            while (taken.has(alias)) {
+                alias = `${relatedTable}_bt${n++}`;
+            }
+            return alias;
+        }
+        if (!taken.has(relatedTable)) {
+            return relatedTable;
+        }
+        const fromRelation = relation
+            .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+            .replace(/[^\w]+/g, "_")
+            .toLowerCase();
+        const base = fromRelation
+            ? `${relatedTable}_${fromRelation}`
+            : `${relatedTable}_bt`;
+        let alias = base;
+        let n = 2;
+        while (taken.has(alias)) {
+            alias = `${base}_${n++}`;
+        }
+        return alias;
+    }
+    /** True when related callback only added flat wheres (safe to merge onto parent). */
+    #relatedConstraintsAreMergeable(from) {
+        from = unwrapModelQuery(from);
+        return (from.#hasConstraints.length === 0 &&
+            from.#morphHasConstraints.length === 0 &&
+            from.#nestedGroups.length === 0 &&
+            from.#joins.length === 0 &&
+            from.#builderExtras.length === 0 &&
+            from.#withCounts.length === 0 &&
+            from.#withAggregates.length === 0);
+    }
+    /** Copy flat constraints from a related whereHas callback onto this query. */
+    #mergeRelatedConstraints(from) {
+        from = unwrapModelQuery(from);
+        if (from.#wheres.length > 0) {
+            (this.#wheres = mqMut(this.#wheres)).push(...from.#wheres);
+        }
+        if (from.#whereIns.length > 0) {
+            (this.#whereIns = mqMut(this.#whereIns)).push(...from.#whereIns);
+        }
+        if (from.#whereNulls.length > 0) {
+            (this.#whereNulls = mqMut(this.#whereNulls)).push(...from.#whereNulls);
+        }
+        if (from.#whereBetweens.length > 0) {
+            (this.#whereBetweens = mqMut(this.#whereBetweens)).push(...from.#whereBetweens);
+        }
+        if (from.#whereColumns.length > 0) {
+            (this.#whereColumns = mqMut(this.#whereColumns)).push(...from.#whereColumns);
+        }
+        if (from.#whereRaws.length > 0) {
+            (this.#whereRaws = mqMut(this.#whereRaws)).push(...from.#whereRaws);
+        }
+        if (from.#whereLikes.length > 0) {
+            (this.#whereLikes = mqMut(this.#whereLikes)).push(...from.#whereLikes);
+        }
+        if (from.#dateWheres.length > 0) {
+            (this.#dateWheres = mqMut(this.#dateWheres)).push(...from.#dateWheres);
+        }
+    }
+    #applyHasConstraint(q, constraint) {
+        // Fast path: call-time compiled EXISTS / IN (HasMany / BelongsToMany / MorphToMany).
+        if (constraint.existsSql !== undefined) {
+            const bindings = constraint.existsBindings ?? [];
+            const sql = constraint.inColumn
+                ? constraint.not
+                    ? `${constraint.inColumn} not in (${constraint.existsSql})`
+                    : `${constraint.inColumn} in (${constraint.existsSql})`
+                : constraint.not
+                    ? `not exists (${constraint.existsSql})`
+                    : `exists (${constraint.existsSql})`;
+            return constraint.or
+                ? q.orWhereRaw(sql, bindings)
+                : q.whereRaw(sql, bindings);
+        }
+        if (constraint.applyExists) {
+            if (constraint.or) {
+                return constraint.not
+                    ? q.orWhereNotExists(constraint.applyExists)
+                    : q.orWhereExists(constraint.applyExists);
+            }
+            return constraint.not
+                ? q.whereNotExists(constraint.applyExists)
+                : q.whereExists(constraint.applyExists);
+        }
+        const meta = constraint.meta ?? resolveRelation(this.model, constraint.relation);
+        if (!meta) {
+            throw new Error(`whereHas supports HasMany/HasOne/BelongsTo/BelongsToMany; [${constraint.relation}] is not supported.`);
+        }
+        // BelongsTo: INNER JOIN matches hand-written join and beats IN (SELECT) on SQLite.
+        // Safe: join is on related PK so parents cannot duplicate. not/or/nested keep IN subquery
+        // (nested where builders only serialize WHERE — JOINs would be dropped).
+        if (meta.kind === "belongsTo") {
+            const parentTable = this.model.table;
+            const relatedTable = meta.related.table;
+            const joinTable = relatedTable === parentTable
+                ? `${relatedTable} as ${relatedTable}_bt`
+                : relatedTable;
+            const relatedAlias = relatedTable === parentTable ? `${relatedTable}_bt` : relatedTable;
+            if (!constraint.not && !constraint.or && !this.#nestedWhereGroup) {
+                if (!this.#selectColumns && this.#addSelectColumns.length === 0) {
+                    q = q.select(`${parentTable}.*`);
+                }
+                q = q.join(joinTable, `${parentTable}.${meta.foreignKey}`, "=", `${relatedAlias}.${meta.ownerKey}`);
+                if (usesSoftDeletes(meta.related)) {
+                    const delCol = deletedAtColumn(meta.related);
+                    q = q.whereNull(`${relatedAlias}.${delCol}`);
+                }
+                if (constraint.relatedQuery) {
+                    constraint.relatedQuery.qualifyColumns(relatedAlias);
+                    constraint.relatedQuery.applyConstraintsTo(q);
+                }
+                else if (constraint.callback) {
+                    const relatedQuery = meta.related.newQuery({
+                        withoutGlobalScopes: true,
+                    });
+                    constraint.callback(relatedQuery);
+                    relatedQuery.qualifyColumns(relatedAlias);
+                    relatedQuery.applyConstraintsTo(q);
+                }
+                return q;
+            }
+            // or / not / nested where: IN (SELECT ownerKey ...) — reuse call-time relatedQuery when present.
+            let relatedQuery = constraint.relatedQuery;
+            if (!relatedQuery) {
+                relatedQuery = meta.related.newQuery({
+                    withoutGlobalScopes: true,
+                });
+                if (constraint.callback) {
+                    constraint.callback(relatedQuery);
+                }
+            }
+            // Select owner key for the IN subquery (clone-safe: mutate a dedicated select).
+            const sub = relatedQuery.clone();
+            sub.select(meta.ownerKey);
+            const subSql = sub.toSql();
+            const bindings = sub.getBindings();
+            const col = `${parentTable}.${meta.foreignKey}`;
+            const sql = constraint.not
+                ? `${col} not in (${subSql})`
+                : `${col} in (${subSql})`;
+            return constraint.or
+                ? q.orWhereRaw(sql, bindings)
+                : q.whereRaw(sql, bindings);
+        }
+        // Fallback (unknown kind / legacy constraint without applyExists).
+        const apply = (sub) => {
+            if (meta.kind === "has") {
+                const relatedTable = meta.related.table;
+                const parentTable = this.model.table;
+                if (relatedTable === parentTable) {
+                    const alias = `${relatedTable}_has`;
+                    sub.from(`${relatedTable} as ${alias}`);
+                    sub.whereColumn(`${alias}.${meta.foreignKey}`, `${parentTable}.${meta.localKey}`);
+                }
+                else {
+                    sub.from(relatedTable);
+                    sub.whereColumn(`${relatedTable}.${meta.foreignKey}`, `${parentTable}.${meta.localKey}`);
+                }
+            }
+            else if (meta.kind === "belongsToMany" ||
+                meta.kind === "morphToMany") {
+                sub.from(meta.related.table);
+                sub.join(meta.pivotTable, `${meta.pivotTable}.${meta.relatedPivotKey}`, "=", `${meta.related.table}.${meta.related.primaryKey}`);
+                sub.whereColumn(`${meta.pivotTable}.${meta.foreignPivotKey}`, `${this.model.table}.${meta.localKey}`);
+                if (meta.kind === "morphToMany") {
+                    sub.whereIn(`${meta.pivotTable}.${meta.morphTypeColumn}`, meta.morphTypes);
+                    if (meta.pivotTenantKey && meta.parentTenantKey) {
+                        sub.whereColumn(`${meta.pivotTable}.${meta.pivotTenantKey}`, `${this.model.table}.${meta.parentTenantKey}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`whereHas supports HasMany/HasOne/BelongsTo/BelongsToMany; [${constraint.relation}] is not supported.`);
+            }
+            if (constraint.relatedQuery) {
+                constraint.relatedQuery.applyConstraintsTo(sub);
+            }
+            else if (constraint.callback) {
+                const relatedQuery = meta.related.newQuery({
+                    withoutGlobalScopes: true,
+                });
+                constraint.callback(relatedQuery);
+                relatedQuery.applyConstraintsTo(sub);
+            }
+        };
+        if (constraint.or) {
+            return constraint.not
+                ? q.orWhereNotExists(apply)
+                : q.orWhereExists(apply);
+        }
+        return constraint.not ? q.whereNotExists(apply) : q.whereExists(apply);
+    }
+    #applyMorphHasConstraint(q, constraint) {
+        const apply = (sub) => {
+            // EXISTS related row matching morph type+id; OR across types.
+            sub.whereNested((inner) => {
+                for (let i = 0; i < constraint.types.length; i++) {
+                    const Related = constraint.types[i];
+                    const type = morphTypeFor(Related);
+                    const branch = (b) => {
+                        b.where(`${this.model.table}.${constraint.typeColumn}`, type);
+                        b.whereExists((ex) => {
+                            ex.from(Related.table);
+                            ex.whereColumn(`${Related.table}.${Related.primaryKey}`, `${this.model.table}.${constraint.idColumn}`);
+                            if (constraint.callback) {
+                                const rq = Related.newQuery({ withoutGlobalScopes: true });
+                                constraint.callback(rq);
+                                rq.applyConstraintsTo(ex);
+                            }
+                        });
+                    };
+                    if (i === 0)
+                        inner.whereNested(branch);
+                    else
+                        inner.orWhereNested(branch);
+                }
+            });
+        };
+        // Morph existence is on the parent row's type/id pointing at related — use whereExists
+        // that correlates type + related table.
+        const morphExists = (sub) => {
+            sub.from(this.model.table);
+            // Re-bind: for each type, related.id = parent.idCol AND parent.typeCol = type
+            // Simpler: OR of (type=? AND EXISTS related)
+            sub.whereRaw("1=1");
+        };
+        void morphExists;
+        // Correct approach: whereExists per type combined
+        const combined = (sub) => {
+            for (let i = 0; i < constraint.types.length; i++) {
+                const Related = constraint.types[i];
+                const type = morphTypeFor(Related);
+                const one = (ex) => {
+                    ex.from(Related.table);
+                    ex.whereColumn(`${Related.table}.${Related.primaryKey}`, `${this.model.table}.${constraint.idColumn}`);
+                    ex.where(`${this.model.table}.${constraint.typeColumn}`, type);
+                    if (constraint.callback) {
+                        const rq = Related.newQuery({ withoutGlobalScopes: true });
+                        constraint.callback(rq);
+                        rq.applyConstraintsTo(ex);
+                    }
+                };
+                if (i === 0) {
+                    if (constraint.types.length === 1) {
+                        one(sub);
+                    }
+                    else {
+                        sub.whereExists(one);
+                    }
+                }
+                else {
+                    sub.orWhereExists(one);
+                }
+            }
+            if (constraint.types.length === 1) {
+                // already applied directly onto sub when length===1 — but whereExists wrapper needed
+            }
+        };
+        // Always wrap in whereExists for single type too
+        const wrap = (sub) => {
+            if (constraint.types.length === 1) {
+                const Related = constraint.types[0];
+                const type = morphTypeFor(Related);
+                sub.from(Related.table);
+                sub.whereColumn(`${Related.table}.${Related.primaryKey}`, `${this.model.table}.${constraint.idColumn}`);
+                // type filter on parent — use whereRaw correlated
+                sub.whereRaw(`${this.model.table}.${constraint.typeColumn} = ?`, [type]);
+                if (constraint.callback) {
+                    const rq = Related.newQuery({ withoutGlobalScopes: true });
+                    constraint.callback(rq);
+                    rq.applyConstraintsTo(sub);
+                }
+                return;
+            }
+            combined(sub);
+        };
+        void apply;
+        if (constraint.or) {
+            return constraint.not
+                ? q.orWhereNotExists(wrap)
+                : q.orWhereExists(wrap);
+        }
+        return constraint.not ? q.whereNotExists(wrap) : q.whereExists(wrap);
+    }
+    #aggregateSubquery(meta, fn, column) {
+        const agg = fn === "exists"
+            ? "1"
+            : fn === "count"
+                ? "COUNT(*)"
+                : `${fn.toUpperCase()}(${column ?? "*"})`;
+        if (meta.kind === "has") {
+            const relatedTable = meta.related.table;
+            const parentTable = this.model.table;
+            if (relatedTable === parentTable) {
+                const alias = `${relatedTable}_has`;
+                const where = `${alias}.${meta.foreignKey} = ${parentTable}.${meta.localKey}`;
+                if (fn === "exists") {
+                    return `SELECT 1 FROM ${relatedTable} as ${alias} WHERE ${where} LIMIT 1`;
+                }
+                return `SELECT ${agg} FROM ${relatedTable} as ${alias} WHERE ${where}`;
+            }
+            const where = `${relatedTable}.${meta.foreignKey} = ${parentTable}.${meta.localKey}`;
+            if (fn === "exists") {
+                return `SELECT 1 FROM ${relatedTable} WHERE ${where} LIMIT 1`;
+            }
+            return `SELECT ${agg} FROM ${relatedTable} WHERE ${where}`;
+        }
+        if (meta.kind === "belongsTo") {
+            const where = `${meta.related.table}.${meta.ownerKey} = ${this.model.table}.${meta.foreignKey}`;
+            if (fn === "exists") {
+                return `SELECT 1 FROM ${meta.related.table} WHERE ${where} LIMIT 1`;
+            }
+            return `SELECT ${agg} FROM ${meta.related.table} WHERE ${where}`;
+        }
+        if (meta.kind !== "belongsToMany" && meta.kind !== "morphToMany") {
+            return null;
+        }
+        const join = `INNER JOIN ${meta.pivotTable} ON ${meta.pivotTable}.${meta.relatedPivotKey} = ${meta.related.table}.${meta.related.primaryKey}`;
+        const where = `${meta.pivotTable}.${meta.foreignPivotKey} = ${this.model.table}.${meta.localKey}`;
+        if (fn === "exists") {
+            return `SELECT 1 FROM ${meta.related.table} ${join} WHERE ${where} LIMIT 1`;
+        }
+        return `SELECT ${agg} FROM ${meta.related.table} ${join} WHERE ${where}`;
+    }
+    first() {
+        const fast = this.#trySimpleFirst();
+        if (fast !== undefined) {
+            if (fast instanceof Promise) {
+                return fast.then((row) => this.#hydrateFirst(row));
+            }
+            return this.#hydrateFirst(fast);
+        }
+        const rowOrPromise = this.#buildQuery().first();
+        if (rowOrPromise instanceof Promise) {
+            return rowOrPromise.then((row) => this.#hydrateFirst(row));
+        }
+        return this.#hydrateFirst(rowOrPromise);
+    }
+    #hydrateFirst(row) {
+        if (!row)
+            return null;
+        const model = this.#makeModel(row);
+        const retrieved = this.#hasRetrievedListeners;
+        const eager = this.#eagerLoad.length > 0;
+        if (!retrieved && !eager)
+            return model;
+        return (async () => {
+            if (retrieved)
+                await fireModelEvent(model, "retrieved");
+            if (eager)
+                await this.#loadEager([model]);
+            return model;
+        })();
+    }
+    /** Laravel `firstOrFail`. */
+    async firstOrFail() {
+        const model = await this.first();
+        if (!model)
+            throw new ModelNotFoundException();
+        return model;
+    }
+    /**
+     * Fetch matching models as an {@link OrmCollection}.
+     * After {@link rows}, returns plain row objects and does not build models.
+     * For synchronous SQLite reads, use {@link getSync}.
+     */
+    get() {
+        if (this.#asRows) {
+            return this.#collectRows();
+        }
+        return this.#fetchModels();
+    }
+    #fetchModels() {
+        const fast = this.#trySimpleRows();
+        if (fast !== undefined) {
+            if (fast instanceof Promise) {
+                return fast.then((rows) => this.#hydrateGet(rows));
+            }
+            return this.#hydrateGet(fast);
+        }
+        const rowsOrPromise = this.#buildQuery().getRows();
+        if (rowsOrPromise instanceof Promise) {
+            return rowsOrPromise.then((rows) => this.#hydrateGet(rows));
+        }
+        return this.#hydrateGet(rowsOrPromise);
+    }
+    #collectRows() {
+        const fast = this.#trySimpleRows();
+        if (fast !== undefined) {
+            if (fast instanceof Promise) {
+                return fast.then((rows) => this.#materializeRows(rows));
+            }
+            return this.#materializeRows(fast);
+        }
+        const rowsOrPromise = this.#buildQuery().getRows();
+        if (rowsOrPromise instanceof Promise) {
+            return rowsOrPromise.then((rows) => this.#materializeRows(rows));
+        }
+        return this.#materializeRows(rowsOrPromise);
+    }
+    #hydrateGet(rows) {
+        const modelsOrPromise = this.#hydrateRows(rows);
+        if (modelsOrPromise instanceof Promise) {
+            return modelsOrPromise.then(async (models) => {
+                if (this.#eagerLoad.length > 0) {
+                    await eagerLoadModels(models, this.#eagerLoad);
+                }
+                return new OrmCollection(models, { owned: true });
+            });
+        }
+        if (this.#eagerLoad.length > 0) {
+            const models = modelsOrPromise;
+            const eager = eagerLoadModels(models, this.#eagerLoad);
+            if (eager instanceof Promise) {
+                return eager.then(() => new OrmCollection(models, { owned: true }));
+            }
+            return new OrmCollection(models, { owned: true });
+        }
+        return new OrmCollection(modelsOrPromise, { owned: true });
+    }
+    /** Row objects for {@link rows}. Falls back to model JSON when the row shortcut cannot apply. */
+    #materializeRows(rows) {
+        if (Array.isArray(rows)) {
+            const prepared = this.#prepareJsonRows(rows);
+            if (prepared)
+                return prepared;
+        }
+        const modelsOrPromise = this.#hydrateRows(rows);
+        const toRows = (models) => {
+            if (this.#eagerLoad.length === 0) {
+                return models.map((model) => model.toArray());
+            }
+            const eager = eagerLoadModels(models, this.#eagerLoad);
+            const map = () => models.map((model) => model.toArray());
+            if (eager instanceof Promise)
+                return eager.then(map);
+            return map();
+        };
+        if (modelsOrPromise instanceof Promise) {
+            return modelsOrPromise.then(toRows);
+        }
+        return toRows(modelsOrPromise);
+    }
+    /**
+     * Plain row objects for JSON when every value matches model JSON
+     * (no casts, hidden, or appends) and each eager belongsTo is null
+     * because its foreign key was not selected or is null.
+     * Returns null to keep the model hydrate path.
+     */
+    #prepareJsonRows(rows) {
+        if (this.#hasRetrievedListeners ||
+            this.#hasQueryCasts ||
+            this.#connection !== undefined) {
+            return null;
+        }
+        const ctor = this.model;
+        const hidden = ctor.hidden;
+        const appends = ctor.appends;
+        if ((hidden != null && hidden.length > 0) ||
+            (appends != null && appends.length > 0)) {
+            return null;
+        }
+        if (rows.length > 0 && attributesNeedModelCasts(ctor, rows[0])) {
+            return null;
+        }
+        const stamps = [];
+        for (const entry of this.#eagerLoad) {
+            const relation = entry.name;
+            if (entry.constraint ||
+                typeof relation !== "string" ||
+                relation.includes(".") ||
+                relation.includes(" ")) {
+                return null;
+            }
+            const meta = resolveRelation(ctor, relation);
+            if (!meta || meta.kind !== "belongsTo")
+                return null;
+            const foreignKey = meta.foreignKey;
+            for (const row of rows) {
+                if (row[foreignKey] != null)
+                    return null;
+            }
+            stamps.push(relation);
+        }
+        const idKey = ctor.primaryKey;
+        const numericId = ctor.incrementing !== false && ctor.keyType !== "string";
+        const list = rows.constructor === Array
+            ? rows
+            : Array.prototype.slice.call(rows);
+        for (let i = 0; i < list.length; i++) {
+            const row = list[i];
+            if (numericId) {
+                const value = row[idKey];
+                if (typeof value === "string" || typeof value === "bigint") {
+                    const n = Number(value);
+                    if (Number.isSafeInteger(n))
+                        row[idKey] = n;
+                }
+                else if (typeof value === "number" && Number.isFinite(value)) {
+                    row[idKey] = Math.trunc(value);
+                }
+            }
+            for (let s = 0; s < stamps.length; s++)
+                row[stamps[s]] = null;
+        }
+        return list;
+    }
+    #queryConnection() {
+        if (this.#connection !== undefined) {
+            return resolveConnection(this.#connection);
+        }
+        return this.model.getConnection();
+    }
+    #assertSyncReadable(method) {
+        const conn = this.#queryConnection();
+        if (!conn.allSync || !conn.getSync) {
+            throw new Error(`${method}() requires SQLite (Connection.allSync / getSync). Use async get()/first() on Postgres.`);
+        }
+        if (this.#eagerLoad.length > 0) {
+            throw new Error(`${method}() does not support with() — use async get()/first() for eager loads.`);
+        }
+        if (this.#hasRetrievedListeners) {
+            throw new Error(`${method}() does not support retrieved listeners — use async get()/first().`);
+        }
+    }
+    /**
+     * SQLite-only synchronous `get()`.
+     * No `with()` / retrieved events — for desktop hot paths that cannot await.
+     */
+    getSync() {
+        this.#assertSyncReadable("getSync");
+        const fast = this.#trySimpleRows();
+        const rows = fast !== undefined ? fast : this.#buildQuery().getRows();
+        if (rows instanceof Promise) {
+            throw new Error("getSync() expected synchronous rows from SQLite");
+        }
+        if (this.#asRows) {
+            const plain = this.#materializeRows(rows);
+            if (plain instanceof Promise) {
+                throw new Error("getSync() expected synchronous rows from SQLite");
+            }
+            return plain;
+        }
+        const models = this.#hydrateRows(rows);
+        if (models instanceof Promise) {
+            throw new Error("getSync() cannot hydrate with retrieved listeners");
+        }
+        return new OrmCollection(models, { owned: true });
+    }
+    /** SQLite-only synchronous `first()`. */
+    firstSync() {
+        this.#assertSyncReadable("firstSync");
+        const fast = this.#trySimpleFirst();
+        const row = fast !== undefined ? fast : this.#buildQuery().first();
+        if (row instanceof Promise) {
+            throw new Error("firstSync() expected synchronous row from SQLite");
+        }
+        if (!row)
+            return null;
+        return this.#makeModel(row);
+    }
+    /** SQLite-only synchronous `find($id)`. */
+    findSync(id) {
+        return this.clone().where(this.model.primaryKey, id).firstSync();
+    }
+    async #loadEager(models) {
+        await eagerLoadModels(models, this.#eagerLoad);
+    }
+    #makeModel(row) {
+        let model;
+        if (!this.#hasQueryCasts) {
+            model = this.model.newFromBuilder(row);
+        }
+        else {
+            const ctor = this.model;
+            const original = ctor.casts;
+            ctor.casts = { ...ctor.getCasts(), ...this.#casts };
+            try {
+                model = ctor.newFromBuilder(row);
+            }
+            finally {
+                ctor.casts = original;
+            }
+        }
+        if (this.#connection !== undefined) {
+            model.setConnection(this.#connection);
+        }
+        return model;
+    }
+    #hydrateRows(rows) {
+        if (this.#hasRetrievedListeners) {
+            return (async () => {
+                const models = [];
+                for (const row of rows) {
+                    const model = this.#makeModel(row);
+                    await fireModelEvent(model, "retrieved");
+                    models.push(model);
+                }
+                return models;
+            })();
+        }
+        // Fast path: known array length from SQLite sync results
+        if (Array.isArray(rows)) {
+            const models = new Array(rows.length);
+            // Plain list hydrate: skip #makeModel branch when no query casts / conn override.
+            if (!this.#hasQueryCasts && this.#connection === undefined) {
+                const Ctor = this.model;
+                for (let i = 0; i < rows.length; i++) {
+                    models[i] = Ctor.newFromBuilder(rows[i]);
+                }
+            }
+            else {
+                for (let i = 0; i < rows.length; i++) {
+                    models[i] = this.#makeModel(rows[i]);
+                }
+            }
+            return models;
+        }
+        const models = [];
+        for (const row of rows) {
+            models.push(this.#makeModel(row));
+        }
+        return models;
+    }
+    /** Laravel `Builder::create` — insert on this query's connection. */
+    async create(attributes) {
+        const merged = { ...this.#pendingAttributes, ...attributes };
+        const useAttrs = filterFillable(this.model, merged);
+        const model = new this.model();
+        if (this.#connection !== undefined) {
+            model.setConnection(this.#connection);
+        }
+        Object.assign(model, useAttrs);
+        await model.save();
+        return model;
+    }
+    async paginate(perPage = 15, page, options = {}) {
+        const total = await this.#countQuery().count();
+        const currentPage = resolvePaginatorPage(page, options.pageName);
+        const size = Math.max(1, Math.floor(Number(perPage)) || 15);
+        const offset = (currentPage - 1) * size;
+        const rows = await this.#buildQuery().limit(size).offset(offset).getRows();
+        const items = await this.#hydrateRows(rows);
+        if (this.#eagerLoad.length > 0) {
+            await eagerLoadModels(items, this.#eagerLoad);
+        }
+        return new LengthAwarePaginator(items, total, size, currentPage, options);
+    }
+    /** No total count; extra row is used to detect a next page. */
+    async simplePaginate(perPage = 15, page, options = {}) {
+        const currentPage = resolvePaginatorPage(page, options.pageName);
+        const size = Math.max(1, Math.floor(Number(perPage)) || 15);
+        const offset = (currentPage - 1) * size;
+        const rows = await this.#buildQuery()
+            .limit(size + 1)
+            .offset(offset)
+            .getRows();
+        const items = await this.#hydrateRows(rows);
+        if (this.#eagerLoad.length > 0) {
+            await eagerLoadModels(items, this.#eagerLoad);
+        }
+        return new Paginator(items, size, currentPage, options);
+    }
+    /** Laravel `chunk($count, $callback)`. */
+    async chunk(count, callback) {
+        let page = 1;
+        for (;;) {
+            const offset = (page - 1) * count;
+            const rows = await this.#buildQuery()
+                .limit(count)
+                .offset(offset)
+                .getRows();
+            if (rows.length === 0)
+                break;
+            const models = await this.#hydrateRows(rows);
+            if (this.#eagerLoad.length > 0) {
+                await eagerLoadModels(models, this.#eagerLoad);
+            }
+            await callback(new OrmCollection(models, { owned: true }));
+            if (rows.length < count)
+                break;
+            page += 1;
+        }
+    }
+    /** Laravel `lazy($chunkSize)`. */
+    async *lazy(chunkSize = 1000) {
+        let page = 1;
+        const fireRetrieved = hasModelEventListeners(this.model, "retrieved");
+        for (;;) {
+            const offset = (page - 1) * chunkSize;
+            const rows = await this.#buildQuery()
+                .limit(chunkSize)
+                .offset(offset)
+                .getRows();
+            if (rows.length === 0)
+                break;
+            for (const row of rows) {
+                const model = this.#makeModel(row);
+                if (fireRetrieved) {
+                    await fireModelEvent(model, "retrieved");
+                }
+                if (this.#eagerLoad.length > 0) {
+                    await this.#loadEager([model]);
+                }
+                yield model;
+            }
+            if (rows.length < chunkSize)
+                break;
+            page += 1;
+        }
+    }
+    /** Laravel `chunkById`. */
+    async chunkById(count, callback, column) {
+        return this.#chunkById(count, callback, column ?? this.model.primaryKey, "asc");
+    }
+    async chunkByIdDesc(count, callback, column) {
+        return this.#chunkById(count, callback, column ?? this.model.primaryKey, "desc");
+    }
+    async #chunkById(count, callback, column, direction) {
+        const size = Math.max(1, Math.floor(count));
+        let lastId = null;
+        for (;;) {
+            const q = this.clone().reorder(column, direction).limit(size);
+            if (lastId !== null) {
+                q.where(column, direction === "asc" ? ">" : "<", lastId);
+            }
+            const models = await q.#fetchModels();
+            if (models.isEmpty())
+                return true;
+            const result = await callback(models);
+            if (result === false)
+                return false;
+            lastId = models.last()?.[column];
+            if (models.count() < size)
+                return true;
+        }
+    }
+    /** Laravel `lazyById`. */
+    async *lazyById(chunkSize = 1000, column) {
+        yield* this.#lazyById(chunkSize, column ?? this.model.primaryKey, "asc");
+    }
+    async *lazyByIdDesc(chunkSize = 1000, column) {
+        yield* this.#lazyById(chunkSize, column ?? this.model.primaryKey, "desc");
+    }
+    async *#lazyById(chunkSize, column, direction) {
+        const size = Math.max(1, Math.floor(chunkSize));
+        let lastId = null;
+        for (;;) {
+            const q = this.clone().reorder(column, direction).limit(size);
+            if (lastId !== null) {
+                q.where(column, direction === "asc" ? ">" : "<", lastId);
+            }
+            const models = await q.#fetchModels();
+            if (models.isEmpty())
+                return;
+            for (const model of models) {
+                yield model;
+            }
+            lastId = models.last()?.[column];
+            if (models.count() < size)
+                return;
+        }
+    }
+    async increment(column, amount = 1) {
+        await this.#buildQuery().increment(column, amount);
+    }
+    async decrement(column, amount = 1) {
+        await this.#buildQuery().decrement(column, amount);
+    }
+    /** Laravel `cursorPaginate`. */
+    async cursorPaginate(perPage = 15, cursor = null, options = {}) {
+        const page = await this.#buildQuery().cursorPaginate(perPage, cursor, options);
+        const items = await this.#hydrateRows(page.items);
+        if (this.#eagerLoad.length > 0) {
+            await eagerLoadModels(items, this.#eagerLoad);
+        }
+        return new CursorPaginator(items, page.perPage, page.options);
+    }
+    /** Laravel `Builder::count($columns = '*')` — honors `distinct()` for non-`*`. */
+    async count(column = "*") {
+        let countQ = this.#countQuery();
+        if (this.#distinct) {
+            countQ = countQ.distinct();
+        }
+        return countQ.count(column);
+    }
+    #countQuery() {
+        let countQ = this.#baseTable();
+        countQ = this.#applySoftDeletes(countQ);
+        countQ = this.#applyGlobalScopesTo(countQ);
+        // BelongsTo whereHas expands to JOIN + qualified related wheres on the parent.
+        // Count must include those joins (and builderExtras) or Postgres fails with
+        // "missing FROM-clause entry for table …".
+        this.#qualifyParentConstraintsForJoins();
+        countQ = this.applyConstraintsTo(countQ);
+        if (this.#joins.length > 0) {
+            for (const j of this.#joins) {
+                if (j.type === "left") {
+                    countQ = countQ.leftJoin(j.table, j.first, j.op, j.second);
+                }
+                else if (j.type === "right") {
+                    countQ = countQ.rightJoin(j.table, j.first, j.op, j.second);
+                }
+                else {
+                    countQ = countQ.join(j.table, j.first, j.op, j.second);
+                }
+            }
+        }
+        for (const extra of this.#builderExtras) {
+            extra(countQ);
+        }
+        return countQ;
+    }
+    async exists() {
+        return (await this.#countQuery().first()) != null;
+    }
+    async doesntExist() {
+        return !(await this.exists());
+    }
+    /** Find by primary key within this query. */
+    async find(id) {
+        return this.clone()
+            .where(this.model.primaryKey, id)
+            .first();
+    }
+    async findOrFail(id) {
+        const model = await this.find(id);
+        if (!model)
+            throw new ModelNotFoundException();
+        return model;
+    }
+    /** Exactly one matching model, or throw. */
+    async sole() {
+        const rows = await this.clone().limit(2).#fetchModels();
+        if (rows.isEmpty())
+            throw new ModelNotFoundException();
+        if (rows.length > 1) {
+            throw new ModelNotFoundException("Query returned more than one model.");
+        }
+        return rows.first();
+    }
+    async value(column) {
+        const model = await this.clone().select(column).first();
+        if (!model)
+            return null;
+        return model[column] ?? null;
+    }
+    async pluck(column, key) {
+        const cols = key !== undefined && key !== column ? [column, key] : [column];
+        const models = await this.clone().select(...cols).#fetchModels();
+        if (key === undefined)
+            return models.pluck(column);
+        return models.pluck(column, key);
+    }
+    async sum(column) {
+        return this.#buildQuery().sum(column);
+    }
+    async avg(column) {
+        return this.#buildQuery().avg(column);
+    }
+    async min(column) {
+        return this.#buildQuery().min(column);
+    }
+    async max(column) {
+        return this.#buildQuery().max(column);
+    }
+    /**
+     * Bulk insert. When the model uses timestamps, stamps `created_at`/`updated_at`
+     * (row values win). Does not fire creating/created events.
+     */
+    async insert(values) {
+        const rows = Array.isArray(values) ? values : [values];
+        if (rows.length === 0)
+            return true;
+        let finalRows = rows;
+        if (this.model.timestamps !== false) {
+            const now = nowForConnection(resolveConnection(this.#connection));
+            finalRows = rows.map((row) => ({
+                created_at: now,
+                updated_at: now,
+                ...row,
+            }));
+        }
+        return this.#baseTable().insert(finalRows);
+    }
+    /**
+     * Laravel `Builder::upsert` — insert or update on unique conflict.
+     * When the model uses timestamps, stamps `created_at`/`updated_at` like Eloquent
+     * (row values win; `updated_at` is always included in the update column list).
+     */
+    async upsert(values, uniqueBy, update = null) {
+        const rows = Array.isArray(values) ? values : [values];
+        if (rows.length === 0)
+            return 0;
+        let finalRows = rows;
+        let finalUpdate = update;
+        if (this.model.timestamps !== false) {
+            const now = nowForConnection(resolveConnection(this.#connection));
+            finalRows = rows.map((row) => ({
+                created_at: now,
+                updated_at: now,
+                ...row,
+            }));
+            if (finalUpdate == null) {
+                const columns = Object.keys(finalRows[0]);
+                const uniqueCols = Array.isArray(uniqueBy) ? uniqueBy : [uniqueBy];
+                finalUpdate = columns.filter((c) => !uniqueCols.includes(c));
+            }
+            else if (!finalUpdate.includes("updated_at")) {
+                finalUpdate = [...finalUpdate, "updated_at"];
+            }
+        }
+        return this.#baseTable().upsert(finalRows, uniqueBy, finalUpdate);
+    }
+    async update(values) {
+        return this.#buildQuery().update(values);
+    }
+    async delete() {
+        if (usesSoftDeletes(this.model) && !this.#withTrashed && !this.#onlyTrashed) {
+            const col = deletedAtColumn(this.model);
+            return this.#buildQuery().update({
+                [col]: nowForConnection(resolveConnection(this.#connection)),
+            });
+        }
+        return this.#buildQuery().delete();
+    }
+    async forceDelete() {
+        return this.#buildQuery().delete();
+    }
+}