@bunyad/orm 0.1.0-alpha.0

package/dist/model.js

@@ -0,0 +1,1931 @@
+import { DatabaseManager as Db, setDefaultConnection, connections, LengthAwarePaginator, CursorPaginator, Paginator, dateTimeForStorage, withoutQueryWriteHook, wrapSqlName, } from "@bunyad/database";
+import { Collection } from "@bunyad/common";
+import { OrmCollection } from "./orm-collection.js";
+import { Attribute, castFromStorage, castToStorage, hashCastValue, isAlreadyHashed, enumFromStorage, enumToStorage, isAttribute, isCastType, isEnumCast, } from "./casts.js";
+import { bootIfNotBooted, fireModelEvent, hasAnyModelEventListeners, hasModelEventListeners, observeModel, registerModelEvent, withoutModelEvents, } from "./model-events.js";
+import { resolveModelBuilder } from "./decorators.js";
+import { addGlobalScope as registerGlobalScope, getGlobalScopes, hasGlobalScopes, installLocalScopeCallStatic, removeGlobalScope as unregisterGlobalScope, } from "./scopes.js";
+import { deletedAtColumn, normalizeWithRelations, nowForConnection, parseRelationAlias, singular, usesSoftDeletes, } from "./model-helpers.js";
+import { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, aggregateRelation, clearMorphMap, morphMap, morphTypeFor, } from "./relations.js";
+import { eagerLoadAggregates, eagerLoadModels, } from "./eager.js";
+import { ModelQuery, MODEL_QUERY_TARGET } from "./model-query.js";
+import { LazyLoadingViolationException, MassAssignmentException, MissingAttributeException, isIgnoringTouch, isInsideEagerLoad, modelsShouldPreventAccessingMissingAttributes, modelsShouldPreventLazyLoading, modelsShouldPreventSilentlyDiscardingAttributes, preventAccessingMissingAttributes as setPreventAccessingMissingAttributes, preventLazyLoading as setPreventLazyLoading, preventSilentlyDiscardingAttributes as setPreventSilentlyDiscardingAttributes, shouldBeStrict as setShouldBeStrict, withoutTouching as runWithoutTouching, } from "./model-strictness.js";
+export { Attribute, AsCollection, AsFluent, AsEnumCollection, } from "./casts.js";
+export { resetModelEventsForTests } from "./model-events.js";
+/** Thrown when a model query returns no results. */
+export class ModelNotFoundException extends Error {
+    constructor(message = "No query results for model.") {
+        super(message);
+        this.name = "ModelNotFoundException";
+    }
+}
+/** Resolve a connection name or handle to a live Connection. */
+export function resolveConnection(connection) {
+    if (connection == null) {
+        return defaultConnection ?? connections.connection();
+    }
+    if (typeof connection === "string") {
+        return connections.connection(connection);
+    }
+    return connection;
+}
+let defaultConnection;
+const fillableSetCache = new WeakMap();
+const syncInsertColsCache = new WeakMap();
+/** Reused bind list for multi-column sync inserts (single-threaded). */
+const persistValueScratch = [];
+function cachedSyncInsertColumns(ctor) {
+    const fillables = ctor.fillable ?? [];
+    if (fillables.length === 0)
+        return null;
+    const usesTimestamps = ctor.timestamps !== false;
+    const incrementing = ctor.incrementing !== false;
+    const key = ctor.primaryKey;
+    let cached = syncInsertColsCache.get(ctor);
+    if (cached &&
+        cached.timestamps === usesTimestamps &&
+        cached.incrementing === incrementing &&
+        cached.key === key) {
+        return cached.cols;
+    }
+    const cols = [];
+    for (let i = 0; i < fillables.length; i++) {
+        const col = fillables[i];
+        if (incrementing && col === key)
+            continue;
+        cols.push(col);
+    }
+    if (usesTimestamps) {
+        if (!cols.includes("created_at"))
+            cols.push("created_at");
+        if (!cols.includes("updated_at"))
+            cols.push("updated_at");
+    }
+    syncInsertColsCache.set(ctor, {
+        cols,
+        timestamps: usesTimestamps,
+        incrementing,
+        key,
+    });
+    return cols;
+}
+export function filterFillable(model, attributes) {
+    const fillables = model.fillable ?? [];
+    const guardeds = model.guarded ?? ["*"];
+    const strictDiscard = modelsShouldPreventSilentlyDiscardingAttributes();
+    if (fillables.length > 0) {
+        let cached = fillableSetCache.get(model);
+        if (!cached || cached.list !== fillables) {
+            cached = { list: fillables, set: new Set(fillables) };
+            fillableSetCache.set(model, cached);
+        }
+        const allowed = cached.set;
+        const discarded = [];
+        for (const key of Object.keys(attributes)) {
+            if (!allowed.has(key))
+                discarded.push(key);
+        }
+        if (discarded.length === 0)
+            return attributes;
+        if (strictDiscard) {
+            throw new MassAssignmentException(`Add [${discarded.join(", ")}] to fillable property to allow mass assignment on [${model.name ?? "Model"}].`);
+        }
+        const out = {};
+        for (const key of allowed) {
+            if (key in attributes)
+                out[key] = attributes[key];
+        }
+        return out;
+    }
+    if (!guardeds.includes("*")) {
+        const blocked = new Set(guardeds);
+        const discarded = [];
+        const out = {};
+        for (const [key, value] of Object.entries(attributes)) {
+            if (blocked.has(key))
+                discarded.push(key);
+            else
+                out[key] = value;
+        }
+        if (discarded.length > 0 && strictDiscard) {
+            throw new MassAssignmentException(`Add [${discarded.join(", ")}] to fillable property to allow mass assignment on [${model.name ?? "Model"}].`);
+        }
+        return out;
+    }
+    // Empty fillable + guarded ["*"] → allow all (make:model DX; set fillable in apps)
+    return { ...attributes };
+}
+/** Expose `scopeFoo` methods as `.foo()` on model queries. */
+/** Per-class: does this model define any `scopeFoo` local scopes? */
+const hasLocalScopesCache = new WeakMap();
+function modelHasLocalScopes(model) {
+    const cached = hasLocalScopesCache.get(model);
+    if (cached !== undefined)
+        return cached;
+    let has = false;
+    let proto = model;
+    while (proto && proto !== Function.prototype) {
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key.length > 5 &&
+                key.startsWith("scope") &&
+                typeof proto[key] === "function") {
+                has = true;
+                break;
+            }
+        }
+        if (has)
+            break;
+        proto = Object.getPrototypeOf(proto);
+    }
+    hasLocalScopesCache.set(model, has);
+    return has;
+}
+/**
+ * Expose `scopeFoo` methods as `.foo()` on model queries.
+ * Skip the Proxy entirely when the model has no local scopes (list/get hot path).
+ */
+function withLocalScopeProxy(query) {
+    const model = query.model;
+    if (!modelHasLocalScopes(model))
+        return query;
+    return new Proxy(query, {
+        get(target, prop, receiver) {
+            if (prop === MODEL_QUERY_TARGET) {
+                return target;
+            }
+            if (typeof prop === "symbol") {
+                return Reflect.get(target, prop, receiver);
+            }
+            if (prop in target) {
+                const value = Reflect.get(target, prop, receiver);
+                if (typeof value === "function") {
+                    return (...args) => {
+                        const result = value.apply(target, args);
+                        // Re-wrap ModelQuery results (e.g. clone) so scopes stay available.
+                        if (result instanceof ModelQuery && result !== target) {
+                            return withLocalScopeProxy(result);
+                        }
+                        return result === target ? receiver : result;
+                    };
+                }
+                return value;
+            }
+            const scopeModel = target.model;
+            const scopeName = `scope${String(prop).charAt(0).toUpperCase()}${String(prop).slice(1)}`;
+            const fn = scopeModel[scopeName];
+            if (typeof fn === "function") {
+                return (...args) => {
+                    fn.call(scopeModel, target, ...args);
+                    return receiver;
+                };
+            }
+            return undefined;
+        },
+    });
+}
+const noCastsCache = new WeakMap();
+const castsResultCache = new WeakMap();
+const hashedColumnsCache = new WeakMap();
+const castShapeCache = new WeakMap();
+/** Reuse DatabaseManager per Connection — avoids `new Db()` on every list build. */
+const dbManagerByConnection = new WeakMap();
+function classHasNoCasts(ctor) {
+    const cached = noCastsCache.get(ctor);
+    if (cached !== undefined)
+        return cached;
+    const casts = ctor.getCasts();
+    let empty = true;
+    for (const _ in casts) {
+        empty = false;
+        break;
+    }
+    noCastsCache.set(ctor, empty);
+    return empty;
+}
+/** True when this row must run get-casts (a cast column is present, or an accessor always runs). */
+function rowNeedsCasts(ctor, attributes) {
+    let shape = castShapeCache.get(ctor);
+    if (shape === undefined) {
+        const casts = ctor.getCasts();
+        const keys = [];
+        let force = false;
+        for (const key in casts) {
+            keys.push(key);
+            const definition = casts[key];
+            if (isAttribute(definition) && definition.get)
+                force = true;
+        }
+        shape = keys.length === 0 ? null : { keys, force };
+        castShapeCache.set(ctor, shape);
+    }
+    if (shape == null)
+        return false;
+    if (shape.force)
+        return true;
+    for (const key of shape.keys) {
+        if (attributes[key] !== undefined)
+            return true;
+    }
+    return false;
+}
+/** True when hydrating this row must run cast getters (partial selects often do not). */
+export function attributesNeedModelCasts(ctor, attributes) {
+    return rowNeedsCasts(ctor, attributes);
+}
+/**
+ * Incrementing integer keys (`keyType` `int`) become numbers.
+ * Postgres BIGINT often arrives as a string; UUID / `keyType` `string` is left as-is.
+ * An explicit `casts` entry for the primary key wins.
+ */
+function applyIncrementingKeyType(ctor, attrs, hasExplicitCasts) {
+    if (ctor.incrementing === false)
+        return;
+    const key = ctor.primaryKey;
+    if (!(key in attrs) || attrs[key] == null)
+        return;
+    if (hasExplicitCasts && ctor.getCasts()[key])
+        return;
+    const value = attrs[key];
+    if (ctor.keyType === "string") {
+        if (typeof value !== "string")
+            attrs[key] = String(value);
+        return;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        attrs[key] = Math.trunc(value);
+        return;
+    }
+    const n = typeof value === "bigint" ? Number(value) : Number(value);
+    if (Number.isSafeInteger(n)) {
+        attrs[key] = n;
+    }
+}
+/** Faster than Object.assign onto class instances with private fields (Bun). */
+function assignOwn(target, source) {
+    for (const key in source) {
+        target[key] = source[key];
+    }
+}
+const relationNamesCache = new WeakMap();
+function relationNames(ctor) {
+    const cached = relationNamesCache.get(ctor);
+    if (cached)
+        return cached;
+    const raw = ctor.relations;
+    const map = typeof raw === "function" ? raw.call(ctor) : raw;
+    const names = map != null ? new Set(Object.keys(map)) : new Set();
+    relationNamesCache.set(ctor, names);
+    return names;
+}
+function isModelInstance(value) {
+    return (value != null &&
+        typeof value === "object" &&
+        typeof value.getDirty === "function" &&
+        typeof value.save === "function");
+}
+function isRelationValue(value) {
+    if (value == null)
+        return false;
+    if (value instanceof Collection || isModelInstance(value))
+        return true;
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const item = value[i];
+            if (item instanceof Collection || isModelInstance(item))
+                return true;
+        }
+    }
+    return false;
+}
+/** Column attributes only — skip eager-loaded relations and related model bags. */
+function persistableAttributes(ctor, bag, omitKey) {
+    const relations = relationNames(ctor);
+    const casts = ctor.getCasts();
+    const out = {};
+    for (const key of Object.keys(bag)) {
+        if (omitKey != null && key === omitKey)
+            continue;
+        if (key === "pivot")
+            continue;
+        if (relations.has(key))
+            continue;
+        const value = bag[key];
+        // A cast column holds a Collection or object on purpose (`tags: "collection"`); only
+        // uncast values that look like loaded relations are skipped.
+        if (!(key in casts) && (typeof value === "function" || isRelationValue(value)))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+const findSqlCache = new WeakMap();
+export function canFastFind(ctor) {
+    if (usesSoftDeletes(ctor) || hasGlobalScopes(ctor))
+        return false;
+    if (hasModelEventListeners(ctor, "retrieved"))
+        return false;
+    const conn = ctor.getConnection();
+    return (typeof conn.getSync1 === "function" || typeof conn.getSync === "function");
+}
+function canPersistSync(ctor, conn) {
+    return (typeof conn.insertGetIdSync === "function" &&
+        typeof conn.runSync === "function" &&
+        !hasAnyModelEventListeners(ctor));
+}
+/**
+ * Active Record model — familiar query/relation APIs for app code.
+ */
+export class Model {
+    static table;
+    static primaryKey = "id";
+    /**
+     * `$incrementing` — false for UUID / ULID / assigned keys.
+     * When false, `save()` inserts the primary key instead of `insertGetId`.
+     */
+    static incrementing = true;
+    /** `$keyType` (`int` | `string`). */
+    static keyType = "int";
+    /** Connection name (`"secondary"`) or Connection handle. */
+    static connection;
+    /** SoftDeletes stand-in (`@SoftDeletes()` sets this). */
+    static softDeletes = false;
+    static deletedAt = "deleted_at";
+    /** Set by `@HasFactory(...)` — call `Model.factory().create()`. */
+    static factory;
+    /** When false, `save()` skips `created_at` / `updated_at`. */
+    static timestamps = true;
+    /**
+     * Laravel `$casts` property — prefer `static casts()` when adding enums / Attribute.
+     * May be a plain object or a method returning the map.
+     */
+    static casts = {};
+    /**
+     * Relation definitions. Prefer this over instance methods so you can
+     * `declare product: Product | null` and use `model.product` after eager load,
+     * with `model.related('product')` for the relation query.
+     */
+    static relations = {};
+    /**
+     * Laravel `$touches` — relation names whose related models get `touch()` after
+     * this model is saved (or soft-deleted). Honor `withoutTouching`.
+     */
+    static touches = [];
+    /** Laravel `$hidden`. */
+    static hidden = [];
+    /** Laravel `$visible` allow-list (empty = all non-hidden). */
+    static visible = [];
+    /** Laravel `$appends` — accessors included in `toArray()`. */
+    static appends = [];
+    /** Laravel `$fillable`. */
+    static fillable = [];
+    /** Laravel `$guarded` — default guard all until fillable is set. */
+    static guarded = ["*"];
+    /** Set in constructor / hydrate — avoid empty `{}` alloc before assign. */
+    #original;
+    /** Lazy: allocated on first mutation tracking. */
+    #changes;
+    #wasRecentlyCreated = false;
+    /**
+     * Whether this instance is persisted (`$exists`).
+     * Not derived from primary key — non-incrementing models assign UUIDs before insert.
+     */
+    #exists = false;
+    #appends = null;
+    #hidden = null;
+    #visible = null;
+    /** Per-instance connection override (`$model->setConnection()`). */
+    #connection;
+    /** Laravel `$exists` — true after retrieve / successful insert. */
+    get exists() {
+        return this.#exists;
+    }
+    set exists(value) {
+        this.#exists = Boolean(value);
+    }
+    constructor(attributes = {}) {
+        const ctor = this.constructor;
+        const self = this;
+        // Hot path: no casts, or this row omitted every cast column (partial select).
+        if (classHasNoCasts(ctor) ||
+            !rowNeedsCasts(ctor, attributes)) {
+            applyIncrementingKeyType(ctor, attributes, false);
+            assignOwn(self, attributes);
+            this.#original = attributes;
+            return;
+        }
+        const casted = ctor.castAttributes(attributes, "get");
+        applyIncrementingKeyType(ctor, casted, true);
+        assignOwn(self, casted);
+        // Avoid a second own-key scan via syncOriginal()/getAttributes() on hydrate.
+        this.#original = { ...casted };
+    }
+    /**
+     * `newFromBuilder` — hydrate a persisted row (sets `$exists`).
+     * Used by ModelQuery list/find paths.
+     */
+    static newFromBuilder(attributes) {
+        const model = new this(attributes);
+        model.#exists = true;
+        return model;
+    }
+    /** Snapshot current attributes as the original set. */
+    syncOriginal() {
+        this.#original = this.getAttributes();
+        return this;
+    }
+    /** Current attribute bag (non-function own properties). */
+    getAttributes() {
+        const out = {};
+        for (const key of Object.keys(this)) {
+            const value = this[key];
+            if (typeof value !== "function")
+                out[key] = value;
+        }
+        return out;
+    }
+    /**
+     * Laravel `getAttribute` — throws when `preventAccessingMissingAttributes` is on
+     * and the key was not retrieved / does not exist (relations exempt).
+     */
+    getAttribute(key) {
+        const self = this;
+        if (Object.prototype.hasOwnProperty.call(self, key)) {
+            return self[key];
+        }
+        const original = this.#original ?? {};
+        if (Object.prototype.hasOwnProperty.call(original, key)) {
+            return original[key];
+        }
+        if (modelsShouldPreventAccessingMissingAttributes()) {
+            const ctor = this.constructor;
+            const raw = ctor.relations;
+            const map = typeof raw === "function" ? raw.call(ctor) : raw;
+            let isRelation = map != null && typeof map[key] === "function";
+            if (!isRelation) {
+                let proto = Object.getPrototypeOf(this);
+                while (proto && proto !== Object.prototype) {
+                    const desc = Object.getOwnPropertyDescriptor(proto, key);
+                    if (desc && typeof desc.value === "function") {
+                        isRelation = true;
+                        break;
+                    }
+                    proto = Object.getPrototypeOf(proto);
+                }
+            }
+            if (!isRelation) {
+                throw new MissingAttributeException(ctor.name ?? "Model", key);
+            }
+        }
+        return undefined;
+    }
+    /** Laravel `isDirty`. */
+    isDirty(...attributes) {
+        const dirty = this.getDirty();
+        if (attributes.length === 0)
+            return Object.keys(dirty).length > 0;
+        return attributes.some((key) => Object.prototype.hasOwnProperty.call(dirty, key));
+    }
+    /** Laravel `isClean`. */
+    isClean(...attributes) {
+        return !this.isDirty(...attributes);
+    }
+    /** Laravel `getDirty`. */
+    getDirty() {
+        const dirty = {};
+        const original = this.#original ?? {};
+        for (const [key, value] of Object.entries(this.getAttributes())) {
+            if (!Object.is(value, original[key]))
+                dirty[key] = value;
+        }
+        return dirty;
+    }
+    getOriginal(key) {
+        const original = this.#original ?? {};
+        if (key === undefined)
+            return { ...original };
+        return original[key];
+    }
+    /** Laravel `getChanges` — attributes changed by the last save. */
+    getChanges() {
+        return this.#changes ? { ...this.#changes } : {};
+    }
+    /** Laravel `wasChanged`. */
+    wasChanged(...attributes) {
+        const changes = this.#changes;
+        if (!changes)
+            return false;
+        if (attributes.length === 0)
+            return Object.keys(changes).length > 0;
+        return attributes.some((key) => Object.prototype.hasOwnProperty.call(changes, key));
+    }
+    /** Laravel `wasRecentlyCreated`. */
+    wasRecentlyCreated() {
+        return this.#wasRecentlyCreated;
+    }
+    /** Laravel `append`. */
+    append(...attributes) {
+        const current = this.getAppends();
+        this.#appends = [...new Set([...current, ...attributes.flat()])];
+        return this;
+    }
+    /** Laravel `setAppends`. */
+    setAppends(attributes) {
+        this.#appends = [...attributes];
+        return this;
+    }
+    /** Laravel `getAppends`. */
+    getAppends() {
+        if (this.#appends)
+            return [...this.#appends];
+        return [...(this.constructor.appends ?? [])];
+    }
+    /** Laravel `getHidden`. */
+    getHidden() {
+        if (this.#hidden)
+            return [...this.#hidden];
+        return [...(this.constructor.hidden ?? [])];
+    }
+    /** Laravel `getVisible`. */
+    getVisible() {
+        if (this.#visible)
+            return [...this.#visible];
+        return [...(this.constructor.visible ?? [])];
+    }
+    /** Laravel `setHidden`. */
+    setHidden(attributes) {
+        this.#hidden = [...attributes];
+        return this;
+    }
+    /** Laravel `setVisible`. */
+    setVisible(attributes) {
+        this.#visible = [...attributes];
+        return this;
+    }
+    /** Laravel `makeVisible` — show attributes for this instance. */
+    makeVisible(...attributes) {
+        const attrs = attributes.flat();
+        const hidden = new Set(this.getHidden());
+        for (const key of attrs)
+            hidden.delete(key);
+        this.#hidden = [...hidden];
+        const visible = this.getVisible();
+        if (visible.length > 0) {
+            this.#visible = [...new Set([...visible, ...attrs])];
+        }
+        return this;
+    }
+    /** Laravel `makeHidden` — hide attributes for this instance. */
+    makeHidden(...attributes) {
+        const attrs = attributes.flat();
+        this.#hidden = [...new Set([...this.getHidden(), ...attrs])];
+        const visible = this.getVisible();
+        if (visible.length > 0) {
+            const hide = new Set(attrs);
+            this.#visible = visible.filter((key) => !hide.has(key));
+        }
+        return this;
+    }
+    /**
+     * Run a callback without touching timestamps (Laravel `Model::withoutTimestamps`).
+     */
+    static async withoutTimestamps(callback) {
+        const previous = this.timestamps;
+        this.timestamps = false;
+        try {
+            return await callback();
+        }
+        finally {
+            this.timestamps = previous;
+        }
+    }
+    static withoutTouching(modelsOrCallback, callback) {
+        return runWithoutTouching(modelsOrCallback, callback);
+    }
+    /** Whether touch is currently suppressed for this model class. */
+    static isIgnoringTouch() {
+        return isIgnoringTouch(this);
+    }
+    /** Laravel `Model::preventLazyLoading`. */
+    static preventLazyLoading(prevent = true) {
+        setPreventLazyLoading(prevent);
+    }
+    /** Laravel `Model::preventSilentlyDiscardingAttributes`. */
+    static preventSilentlyDiscardingAttributes(prevent = true) {
+        setPreventSilentlyDiscardingAttributes(prevent);
+    }
+    /** Laravel `Model::preventAccessingMissingAttributes`. */
+    static preventAccessingMissingAttributes(prevent = true) {
+        setPreventAccessingMissingAttributes(prevent);
+    }
+    /** Laravel `Model::shouldBeStrict` — enable/disable the strictness trio. */
+    static shouldBeStrict(should = true) {
+        setShouldBeStrict(should);
+    }
+    /** Laravel `Model::addGlobalScope`. */
+    static addGlobalScope(nameOrScope, scope) {
+        if (typeof nameOrScope === "function") {
+            registerGlobalScope(this, nameOrScope.name || `scope_${Date.now()}`, nameOrScope);
+            return;
+        }
+        if (!scope)
+            throw new Error("addGlobalScope requires a callback.");
+        registerGlobalScope(this, nameOrScope, scope);
+    }
+    /** Laravel `Model::addGlobalScope` removal helper. */
+    static removeGlobalScope(name) {
+        unregisterGlobalScope(this, name);
+    }
+    /**
+     * Laravel `boot` — runs once per model class before first use.
+     * Prefer registering listeners in `booted()`.
+     */
+    static boot() { }
+    /**
+     * Laravel `booted` — runs once after `boot`. Typical place for `static::created(...)`.
+     */
+    static booted() { }
+    /** Ensure this model class has been booted. */
+    static bootIfNotBooted() {
+        bootIfNotBooted(this);
+    }
+    /** Laravel `Model::observe`. */
+    static observe(observer) {
+        observeModel(this, observer);
+    }
+    /** Laravel `Model::withoutEvents`. */
+    static withoutEvents(callback) {
+        return withoutModelEvents(this, callback);
+    }
+    static retrieved(callback) {
+        registerModelEvent(this, "retrieved", callback);
+    }
+    static creating(callback) {
+        registerModelEvent(this, "creating", callback);
+    }
+    static created(callback) {
+        registerModelEvent(this, "created", callback);
+    }
+    static updating(callback) {
+        registerModelEvent(this, "updating", callback);
+    }
+    static updated(callback) {
+        registerModelEvent(this, "updated", callback);
+    }
+    static saving(callback) {
+        registerModelEvent(this, "saving", callback);
+    }
+    static saved(callback) {
+        registerModelEvent(this, "saved", callback);
+    }
+    static deleting(callback) {
+        registerModelEvent(this, "deleting", callback);
+    }
+    static deleted(callback) {
+        registerModelEvent(this, "deleted", callback);
+    }
+    static trashed(callback) {
+        registerModelEvent(this, "trashed", callback);
+    }
+    static forceDeleting(callback) {
+        registerModelEvent(this, "forceDeleting", callback);
+    }
+    static forceDeleted(callback) {
+        registerModelEvent(this, "forceDeleted", callback);
+    }
+    static restoring(callback) {
+        registerModelEvent(this, "restoring", callback);
+    }
+    static restored(callback) {
+        registerModelEvent(this, "restored", callback);
+    }
+    static replicating(callback) {
+        registerModelEvent(this, "replicating", callback);
+    }
+    /** Fire a lifecycle event on this instance. */
+    fireModelEvent(event) {
+        return fireModelEvent(this, event);
+    }
+    /** Resolve casts from `casts()` method or `$casts` property. */
+    static getCasts() {
+        const cached = castsResultCache.get(this);
+        if (cached)
+            return cached;
+        const field = this.casts;
+        const value = typeof field === "function" ? (field.call(this) ?? {}) : (field ?? {});
+        castsResultCache.set(this, value);
+        return value;
+    }
+    static castAttributes(attributes, direction) {
+        const casts = this.getCasts();
+        let hasCast = false;
+        for (const _ in casts) {
+            hasCast = true;
+            break;
+        }
+        if (!hasCast) {
+            return attributes;
+        }
+        const driver = (this.connection != null
+            ? resolveConnection(this.connection)
+            : defaultConnection)?.driver;
+        let out = { ...attributes };
+        for (const [key, definition] of Object.entries(casts)) {
+            if (isAttribute(definition)) {
+                if (direction === "get") {
+                    if (!(key in out) && definition.get === undefined)
+                        continue;
+                    if (definition.get) {
+                        out[key] = definition.get(out[key], out);
+                    }
+                }
+                else if (definition.set && key in out) {
+                    const result = definition.set(out[key], out);
+                    delete out[key];
+                    if (result !== null &&
+                        typeof result === "object" &&
+                        !Array.isArray(result) &&
+                        !(result instanceof Date)) {
+                        out = { ...out, ...result };
+                    }
+                    else {
+                        out[key] = result;
+                    }
+                }
+                continue;
+            }
+            if (!(key in out) || out[key] === undefined)
+                continue;
+            if (isCastType(definition)) {
+                out[key] =
+                    direction === "get"
+                        ? castFromStorage(out[key], definition)
+                        : castToStorage(out[key], definition, driver);
+                continue;
+            }
+            if (isEnumCast(definition)) {
+                out[key] =
+                    direction === "get"
+                        ? enumFromStorage(out[key], definition)
+                        : enumToStorage(out[key], definition);
+            }
+        }
+        return out;
+    }
+    static setConnection(connection) {
+        defaultConnection = connection;
+        const name = connection.getName() || "default";
+        setDefaultConnection(connection, name);
+    }
+    static getConnection() {
+        return resolveConnection(this.connection);
+    }
+    /** Laravel `$model->setConnection($name)`. */
+    setConnection(connection) {
+        this.#connection = connection;
+        return this;
+    }
+    /** Active connection for this instance (instance override → model → default). */
+    getConnection() {
+        const ctor = this.constructor;
+        return resolveConnection(this.#connection ?? ctor.connection);
+    }
+    static db() {
+        const conn = this.getConnection();
+        let manager = dbManagerByConnection.get(conn);
+        if (!manager) {
+            manager = new Db(conn);
+            dbManagerByConnection.set(conn, manager);
+        }
+        return manager;
+    }
+    /**
+     * Laravel `Model::on($connection)` — same model, different named connection.
+     */
+    static on(connection) {
+        return this.newQuery({ connection });
+    }
+    /**
+     * Create a model query (honors `@UseBuilder` when present).
+     * Local scopes (`scopeActive` → `.active()`) are available via proxy.
+     */
+    static newQuery(options) {
+        this.bootIfNotBooted();
+        const Ctor = (resolveModelBuilder(this) ?? ModelQuery);
+        const query = new Ctor(this, options);
+        return withLocalScopeProxy(query);
+    }
+    /** Laravel `withoutGlobalScopes()`. */
+    static withoutGlobalScopes(names) {
+        return this.newQuery({
+            withoutGlobalScopes: names ?? true,
+        });
+    }
+    /** Laravel `withoutGlobalScope($name)`. */
+    static withoutGlobalScope(name) {
+        return this.newQuery({ withoutGlobalScopes: [name] });
+    }
+    /** Laravel `Model::query()` — scoped `ModelQuery` (not a raw table builder). */
+    static query(options) {
+        return this.newQuery(options);
+    }
+    /** Laravel `Model::find`. */
+    static find(id) {
+        this.bootIfNotBooted();
+        if (canFastFind(this)) {
+            // `.call` is required so subclasses can use Model's #fastFind; assert InstanceType<T>.
+            return Model.#fastFind.call(this, id);
+        }
+        return this.newQuery()
+            .where(this.primaryKey, id)
+            .first();
+    }
+    /** Laravel `getRouteKeyName()` — column used for implicit route binding. */
+    static getRouteKeyName() {
+        return this.primaryKey;
+    }
+    /**
+     * Laravel `resolveRouteBinding` — find by PK or custom `{param:column}` field.
+     */
+    static resolveRouteBinding(value, field) {
+        const column = field ?? this.getRouteKeyName();
+        if (column === this.primaryKey) {
+            return this.find(value);
+        }
+        this.bootIfNotBooted();
+        return this.newQuery().where(column, value).first();
+    }
+    /**
+     * Laravel SoftDeletes `resolveSoftDeletableRouteBinding` — same as
+     * `resolveRouteBinding` but includes soft-deleted rows (`withTrashed()`).
+     * Used by the router when the route opts in via `withTrashed()`.
+     */
+    static resolveSoftDeletableRouteBinding(value, field) {
+        const column = field ?? this.getRouteKeyName();
+        this.bootIfNotBooted();
+        return this.newQuery({ withTrashed: true }).where(column, value).first();
+    }
+    static #fastFind(id) {
+        const conn = this.getConnection();
+        let cached = findSqlCache.get(this);
+        if (!cached || cached.conn !== conn) {
+            const table = wrapSqlName(conn.dialect, this.table);
+            const pk = wrapSqlName(conn.dialect, this.primaryKey);
+            cached = {
+                sql: `SELECT * FROM ${table} WHERE ${pk} = ? LIMIT 1`,
+                conn,
+            };
+            findSqlCache.set(this, cached);
+        }
+        const row = conn.getSync1
+            ? conn.getSync1(cached.sql, id)
+            : conn.getSync(cached.sql, [id]);
+        if (!row)
+            return null;
+        const model = new this(row);
+        model.#exists = true;
+        return model;
+    }
+    /** Laravel `Model::findOrFail`. */
+    static async findOrFail(id) {
+        const model = await this.find(id);
+        if (!model)
+            throw new ModelNotFoundException();
+        return model;
+    }
+    /** Laravel `Model::all`. */
+    static async all() {
+        this.bootIfNotBooted();
+        return this.newQuery().get();
+    }
+    /**
+     * Laravel `Model::get` — same as `query().get()` / `all()`.
+     * Typed helper for autocomplete; Proxy also forwards other terminals.
+     */
+    static get() {
+        this.bootIfNotBooted();
+        return this.newQuery().get();
+    }
+    static pluck(column, key) {
+        this.bootIfNotBooted();
+        if (key === undefined)
+            return this.newQuery().pluck(column);
+        return this.newQuery().pluck(column, key);
+    }
+    /** SQLite-only sync `all()` — see `ModelQuery.getSync`. */
+    static allSync() {
+        this.bootIfNotBooted();
+        return this.newQuery().getSync();
+    }
+    /** SQLite-only sync `find` — see `ModelQuery.firstSync`. */
+    static findSync(id) {
+        this.bootIfNotBooted();
+        return this.newQuery().findSync(id);
+    }
+    static where(columnOrCallback, opOrValue, value) {
+        const q = this.newQuery();
+        if (typeof columnOrCallback === "function") {
+            return q.where(columnOrCallback);
+        }
+        if (value === undefined)
+            return q.where(columnOrCallback, opOrValue);
+        return q.where(columnOrCallback, String(opOrValue), value);
+    }
+    /** Karobar-style multi-column LIKE search. */
+    static search(columns, term) {
+        this.bootIfNotBooted();
+        return this.newQuery().search(columns, term);
+    }
+    static orWhere(column, opOrValue, value) {
+        this.bootIfNotBooted();
+        const q = this.newQuery();
+        if (value === undefined)
+            return q.orWhere(column, opOrValue);
+        return q.orWhere(column, String(opOrValue), value);
+    }
+    static whereIn(column, values) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereIn(column, values);
+    }
+    static whereNull(column) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereNull(column);
+    }
+    static whereNotNull(column) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereNotNull(column);
+    }
+    static orderBy(column, direction = "asc") {
+        this.bootIfNotBooted();
+        return this.newQuery().orderBy(column, direction);
+    }
+    static orderByDesc(column) {
+        return this.orderBy(column, "desc");
+    }
+    static orderByRaw(sql) {
+        this.bootIfNotBooted();
+        return this.newQuery().orderByRaw(sql);
+    }
+    /** Karobar alias for `orderByRaw`. */
+    static orderBySql(sql) {
+        return this.orderByRaw(sql);
+    }
+    static latest(column = "created_at") {
+        this.bootIfNotBooted();
+        return this.newQuery().latest(column);
+    }
+    static oldest(column = "created_at") {
+        this.bootIfNotBooted();
+        return this.newQuery().oldest(column);
+    }
+    static limit(value) {
+        this.bootIfNotBooted();
+        return this.newQuery().limit(value);
+    }
+    static take(value) {
+        return this.limit(value);
+    }
+    static select(...columns) {
+        this.bootIfNotBooted();
+        return this.newQuery().select(...columns);
+    }
+    static whereDate(column, opOrValue, value) {
+        this.bootIfNotBooted();
+        const q = this.newQuery();
+        if (value === undefined)
+            return q.whereDate(column, opOrValue);
+        return q.whereDate(column, String(opOrValue), value);
+    }
+    /** Laravel `Model::whereNot(closure)`. */
+    static whereNot(callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereNot(callback);
+    }
+    /** Laravel `Model::orWhereNot(closure)`. */
+    static orWhereNot(callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().orWhereNot(callback);
+    }
+    /** Laravel `withTrashed()`. */
+    static withTrashed() {
+        this.bootIfNotBooted();
+        return this.newQuery({
+            withTrashed: true,
+        });
+    }
+    /** Laravel `onlyTrashed()`. */
+    static onlyTrashed() {
+        return this.newQuery({
+            onlyTrashed: true,
+        });
+    }
+    /** Laravel `withoutTrashed()`. */
+    static withoutTrashed() {
+        return this.newQuery({
+            withTrashed: false,
+            onlyTrashed: false,
+        });
+    }
+    /** `get()` returns plain row objects. Models are not built. */
+    static rows() {
+        return this.newQuery().rows();
+    }
+    /** Eager-load relations (`with('posts')`, `with({ posts: (q) => q.where(…) })`). */
+    static with(...relations) {
+        return this.newQuery({
+            eagerLoad: normalizeWithRelations(relations),
+        });
+    }
+    /** Laravel `Model::whereHas`. */
+    static whereHas(relation, callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereHas(relation, callback);
+    }
+    /** Laravel `Model::whereDoesntHave`. */
+    static whereDoesntHave(relation, callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereDoesntHave(relation, callback);
+    }
+    /** Laravel `Model::orWhereHas`. */
+    static orWhereHas(relation, callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().orWhereHas(relation, callback);
+    }
+    /** Laravel `Model::whereRelation`. */
+    static whereRelation(relation, column, opOrValue, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereRelation(relation, column, opOrValue, value);
+    }
+    /** Laravel `Model::orWhereRelation`. */
+    static orWhereRelation(relation, column, opOrValue, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().orWhereRelation(relation, column, opOrValue, value);
+    }
+    /** `withCount` — `'posts'`, `'posts as post_total'`, a string list, or `{ products: { as: 'productsCount' } }`. */
+    static withCount(...relations) {
+        this.bootIfNotBooted();
+        return this.newQuery().withCount(...relations);
+    }
+    /** Laravel `Model::withSum`. */
+    static withSum(relation, column) {
+        this.bootIfNotBooted();
+        return this.newQuery().withSum(relation, column);
+    }
+    static withAvg(relation, column) {
+        this.bootIfNotBooted();
+        return this.newQuery().withAvg(relation, column);
+    }
+    static withMin(relation, column) {
+        this.bootIfNotBooted();
+        return this.newQuery().withMin(relation, column);
+    }
+    static withMax(relation, column) {
+        this.bootIfNotBooted();
+        return this.newQuery().withMax(relation, column);
+    }
+    static withExists(...relations) {
+        this.bootIfNotBooted();
+        return this.newQuery().withExists(...relations);
+    }
+    static withWhereHas(relation, callback) {
+        this.bootIfNotBooted();
+        return this.newQuery().withWhereHas(relation, callback);
+    }
+    static whereBelongsTo(related, relationName) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereBelongsTo(related, relationName);
+    }
+    static whereAny(columns, opOrValue, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereAny(columns, opOrValue, value);
+    }
+    static whereAll(columns, opOrValue, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereAll(columns, opOrValue, value);
+    }
+    static whereNone(columns, opOrValue, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereNone(columns, opOrValue, value);
+    }
+    static whereKey(id) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereKey(id);
+    }
+    /** Laravel `Model::whereUuid`. */
+    static whereUuid(column, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereUuid(column, value);
+    }
+    /** Laravel `Model::whereUlid`. */
+    static whereUlid(column, value) {
+        this.bootIfNotBooted();
+        return this.newQuery().whereUlid(column, value);
+    }
+    /** Laravel `Model::join`. */
+    static join(table, first, op, second) {
+        this.bootIfNotBooted();
+        return this.newQuery().join(table, first, op, second);
+    }
+    /** Laravel `Model::leftJoin`. */
+    static leftJoin(table, first, op, second) {
+        this.bootIfNotBooted();
+        return this.newQuery().leftJoin(table, first, op, second);
+    }
+    /** Laravel `Model::paginate`. */
+    static async paginate(perPage = 15, page, options = {}) {
+        return this.newQuery().paginate(perPage, page, options);
+    }
+    /** Laravel `Model::cursorPaginate`. */
+    static async cursorPaginate(perPage = 15, cursor = null, options = {}) {
+        return this.newQuery().cursorPaginate(perPage, cursor, options);
+    }
+    /** Laravel `Model::create` (respects `$fillable` / `$guarded`). */
+    static create(attributes) {
+        this.bootIfNotBooted();
+        return this.forceCreate(filterFillable(this, attributes));
+    }
+    /** Laravel `Model::forceCreate` — insert every given attribute, ignoring `$fillable`. */
+    static forceCreate(useAttrs) {
+        this.bootIfNotBooted();
+        // Assign raw attributes (skip get-casts) so mutators like Attribute.set can run on save.
+        const model = classHasNoCasts(this)
+            ? new this(useAttrs)
+            : Object.assign(new this(), useAttrs);
+        const saved = model.save();
+        const after = (row) => {
+            if (classHasNoCasts(this)) {
+                return row;
+            }
+            const key = this.primaryKey;
+            const id = row[key];
+            // Re-hydrate get-casts from storage (same end state as insert + find).
+            const fresh = this.withoutEvents(() => this.find(id));
+            const use = (found) => {
+                if (found) {
+                    found.#wasRecentlyCreated = true;
+                    return found;
+                }
+                return row;
+            };
+            if (fresh instanceof Promise) {
+                return fresh.then(use);
+            }
+            return use(fresh);
+        };
+        if (saved instanceof Promise) {
+            return saved.then(after);
+        }
+        return after(saved);
+    }
+    /** Laravel `firstOrNew`. */
+    static async firstOrNew(attributes, values = {}) {
+        let q = this.newQuery();
+        for (const [column, value] of Object.entries(attributes)) {
+            q = q.where(column, value);
+        }
+        const existing = await q.first();
+        if (existing)
+            return existing;
+        return new this({ ...attributes, ...values });
+    }
+    /** Laravel `firstOrCreate`. */
+    static async firstOrCreate(attributes, values = {}) {
+        let q = this.newQuery();
+        for (const [column, value] of Object.entries(attributes)) {
+            q = q.where(column, value);
+        }
+        const existing = await q.first();
+        if (existing)
+            return existing;
+        return this.create({ ...attributes, ...values });
+    }
+    /** Laravel `updateOrCreate`. */
+    static async updateOrCreate(attributes, values = {}) {
+        let q = this.newQuery();
+        for (const [column, value] of Object.entries(attributes)) {
+            q = q.where(column, value);
+        }
+        const existing = await q.first();
+        if (existing) {
+            await existing.update(values);
+            return existing;
+        }
+        return this.create({ ...attributes, ...values });
+    }
+    /**
+     * Bulk insert. Delegates to `ModelQuery.insert` (timestamps stamped when enabled).
+     * Does not fire creating/created events — set tenant/client ids on the rows.
+     */
+    static async insert(values) {
+        this.bootIfNotBooted();
+        return this.newQuery().insert(values);
+    }
+    /**
+     * Laravel `Model::upsert` — bulk insert-or-update on unique conflict.
+     * Delegates to `ModelQuery.upsert` (timestamps stamped when enabled).
+     */
+    static async upsert(values, uniqueBy, update = null) {
+        this.bootIfNotBooted();
+        return this.newQuery().upsert(values, uniqueBy, update);
+    }
+    /** Laravel `$model->fill($attributes)`. */
+    fill(attributes) {
+        const ctor = this.constructor;
+        const finalAttrs = filterFillable(ctor, attributes);
+        assignOwn(this, ctor.castAttributes(finalAttrs, "get"));
+        return this;
+    }
+    /** Laravel `$model->update($attributes)`. */
+    async update(attributes) {
+        this.fill(attributes);
+        await this.save();
+        return this;
+    }
+    save() {
+        const ctor = this.constructor;
+        ctor.bootIfNotBooted();
+        if (!classHasNoCasts(ctor)) {
+            const pending = this.#pendingHashes(ctor);
+            if (pending.length > 0)
+                return this.#hashThenSave(pending);
+        }
+        const conn = this.getConnection();
+        if (canPersistSync(ctor, conn)) {
+            return this.#persistSync(conn);
+        }
+        return this.#persistAsync();
+    }
+    /** `hashed` cast columns that hold a plain string, so `save()` can hash them off the event loop. */
+    #pendingHashes(ctor) {
+        let columns = hashedColumnsCache.get(ctor);
+        if (!columns) {
+            const casts = ctor.getCasts();
+            columns = Object.keys(casts).filter((key) => casts[key] === "hashed");
+            hashedColumnsCache.set(ctor, columns);
+        }
+        if (columns.length === 0)
+            return columns;
+        const row = this;
+        return columns.filter((key) => {
+            const value = row[key];
+            return typeof value === "string" && value !== "" && !isAlreadyHashed(value);
+        });
+    }
+    async #hashThenSave(columns) {
+        const row = this;
+        const hashes = await Promise.all(columns.map((key) => hashCastValue(String(row[key]))));
+        columns.forEach((key, i) => {
+            row[key] = hashes[i];
+        });
+        return this.save();
+    }
+    #persistSync(conn) {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const row = this;
+        const id = row[key];
+        const exists = this.#exists;
+        const dialect = conn.dialect;
+        const table = ctor.table;
+        const incrementing = ctor.incrementing !== false;
+        const usesTimestamps = ctor.timestamps !== false;
+        if (usesTimestamps) {
+            const now = nowForConnection(conn);
+            row.updated_at = now;
+            if (!exists) {
+                row.created_at = row.created_at ?? now;
+            }
+        }
+        if (!exists) {
+            const noCasts = classHasNoCasts(ctor);
+            const cachedCols = noCasts
+                ? cachedSyncInsertColumns(ctor)
+                : null;
+            let writeColumns;
+            let writeValues;
+            if (cachedCols) {
+                writeColumns = cachedCols;
+                const n = cachedCols.length;
+                if (n === 1) {
+                    writeValues = persistValueScratch;
+                    persistValueScratch[0] = row[cachedCols[0]];
+                    persistValueScratch.length = 1;
+                }
+                else {
+                    writeValues = persistValueScratch;
+                    persistValueScratch.length = n;
+                    for (let i = 0; i < n; i++) {
+                        persistValueScratch[i] = row[cachedCols[i]];
+                    }
+                }
+            }
+            else {
+                const persistBag = persistableAttributes(ctor, row, incrementing || row[key] == null ? key : undefined);
+                writeColumns = Object.keys(persistBag);
+                writeValues = Object.values(persistBag);
+                if (!noCasts) {
+                    const payload = ctor.castAttributes(persistBag, "set");
+                    writeColumns = Object.keys(payload);
+                    writeValues = Object.values(payload);
+                }
+            }
+            const inserted = withoutQueryWriteHook(() => {
+                if (incrementing) {
+                    if (writeColumns.length === 1 && conn.insertGetIdSync1) {
+                        return conn.insertGetIdSync1(table, writeColumns[0], writeValues[0]);
+                    }
+                    return conn.insertGetIdSync(table, writeColumns, writeValues);
+                }
+                const placeholders = writeColumns.map(() => "?").join(", ");
+                const wrapped = writeColumns.map((c) => wrapSqlName(dialect, c));
+                conn.runSync(`INSERT INTO ${table} (${wrapped.join(", ")}) VALUES (${placeholders})`, writeValues);
+                return null;
+            });
+            if (incrementing) {
+                row[key] = inserted;
+                applyIncrementingKeyType(ctor, row, !noCasts);
+            }
+            this.#exists = true;
+            this.#wasRecentlyCreated = true;
+            const original = {};
+            if (cachedCols) {
+                for (let i = 0; i < cachedCols.length; i++) {
+                    const col = cachedCols[i];
+                    original[col] = row[col];
+                }
+                if (incrementing)
+                    original[key] = row[key];
+            }
+            else {
+                for (const attr of Object.keys(row)) {
+                    const value = row[attr];
+                    if (typeof value !== "function")
+                        original[attr] = value;
+                }
+            }
+            this.#original = original;
+            this.#changes = original;
+            this.#touchOwnersSync();
+            return this;
+        }
+        const dirty = this.getDirty();
+        const attributes = persistableAttributes(ctor, dirty, key);
+        const payload = ctor.castAttributes(attributes, "set");
+        const columns = Object.keys(payload);
+        if (columns.length > 0) {
+            const sets = columns
+                .map((c) => `${wrapSqlName(dialect, c)} = ?`)
+                .join(", ");
+            withoutQueryWriteHook(() => conn.runSync(`UPDATE ${table} SET ${sets} WHERE ${wrapSqlName(dialect, key)} = ?`, [...Object.values(payload), id]));
+        }
+        this.#wasRecentlyCreated = false;
+        this.#changes = dirty;
+        this.syncOriginal();
+        this.#touchOwnersSync();
+        return this;
+    }
+    async #persistAsync() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const row = this;
+        const id = row[key];
+        const exists = this.#exists;
+        if ((await fireModelEvent(this, "saving")) === false)
+            return this;
+        const usesTimestamps = ctor.timestamps !== false;
+        if (usesTimestamps) {
+            const now = nowForConnection(this.getConnection());
+            row.updated_at = now;
+            if (!exists) {
+                row.created_at = row.created_at ?? now;
+            }
+        }
+        const dirty = this.getDirty();
+        const persistCtor = ctor;
+        const table = new Db(this.getConnection()).table(ctor.table);
+        if (!exists) {
+            if ((await fireModelEvent(this, "creating")) === false)
+                return this;
+            const attributes = persistableAttributes(persistCtor, row, ctor.incrementing !== false || row[key] == null ? key : undefined);
+            if (ctor.incrementing !== false) {
+                const newId = await withoutQueryWriteHook(() => table.insertGetId(ctor.castAttributes(attributes, "set")));
+                row[key] = newId;
+                applyIncrementingKeyType(ctor, row, !classHasNoCasts(ctor));
+            }
+            else {
+                if (row[key] != null && attributes[key] == null) {
+                    attributes[key] = row[key];
+                }
+                await withoutQueryWriteHook(() => table.insert(ctor.castAttributes(attributes, "set")));
+            }
+            this.#exists = true;
+            this.#wasRecentlyCreated = true;
+            await fireModelEvent(this, "created");
+        }
+        else {
+            if ((await fireModelEvent(this, "updating")) === false)
+                return this;
+            const attributes = persistableAttributes(persistCtor, dirty, key);
+            if (Object.keys(attributes).length > 0) {
+                await withoutQueryWriteHook(() => table.where(key, id).update(ctor.castAttributes(attributes, "set")));
+            }
+            this.#wasRecentlyCreated = false;
+            await fireModelEvent(this, "updated");
+        }
+        this.#changes = { ...dirty };
+        if (usesTimestamps) {
+            if ("updated_at" in row)
+                this.#changes.updated_at = row.updated_at;
+            if (!exists && "created_at" in row) {
+                this.#changes.created_at = row.created_at;
+            }
+        }
+        this.syncOriginal();
+        await fireModelEvent(this, "saved");
+        // Laravel finishSave → touchOwners (Relation.touch honors withoutTouching on related).
+        await this.touchOwners();
+        return this;
+    }
+    /** Laravel `$model->saveQuietly()`. */
+    async saveQuietly() {
+        const ctor = this.constructor;
+        return ctor.withoutEvents(() => this.save());
+    }
+    /** Laravel `$model->refresh()`. */
+    async refresh() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const id = this[key];
+        const fresh = await ctor.find(id);
+        if (fresh) {
+            Object.assign(this, fresh.getAttributes());
+            this.#original = { ...fresh.#original };
+            this.#exists = true;
+        }
+        return this;
+    }
+    /**
+     * Laravel-style refresh under row lock (`lockForUpdate`).
+     * Reloads this instance from a locked select of the same primary key.
+     */
+    async refreshForUpdate() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const id = this[key];
+        const fresh = await ctor
+            .newQuery()
+            .lockForUpdate()
+            .find(id);
+        if (fresh) {
+            Object.assign(this, fresh.getAttributes());
+            this.#original = { ...fresh.#original };
+            this.#exists = true;
+        }
+        return this;
+    }
+    /** Laravel `$model->fresh()`. */
+    async fresh() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const id = this[key];
+        return (await ctor.find(id));
+    }
+    /** Eager-load relations onto this model (`load('posts')` / constrained maps). */
+    async load(...relations) {
+        await eagerLoadModels([this], normalizeWithRelations(relations));
+        return this;
+    }
+    /** Load only relations that are not already present. */
+    async loadMissing(...relations) {
+        const normalized = normalizeWithRelations(relations);
+        const missing = normalized.filter((entry) => !this.relationLoaded(entry.name));
+        if (missing.length > 0)
+            await eagerLoadModels([this], missing);
+        return this;
+    }
+    /** Laravel `$model->relationLoaded($key)`. */
+    relationLoaded(key) {
+        return Object.prototype.hasOwnProperty.call(this, key);
+    }
+    /**
+     * Sync-save path: touch `$touches` via BelongsTo.touchSync when available.
+     */
+    #touchOwnersSync() {
+        const ctor = this.constructor;
+        const names = ctor.touches ?? [];
+        if (names.length === 0)
+            return;
+        for (const name of names) {
+            const rel = this.related(name);
+            if (typeof rel.touchSync === "function") {
+                rel.touchSync();
+                continue;
+            }
+            if (typeof rel.touch === "function") {
+                void rel.touch();
+            }
+        }
+    }
+    /**
+     * Laravel `$model->touches($relation)` — whether `$touches` lists this relation.
+     */
+    touches(relation) {
+        const ctor = this.constructor;
+        return (ctor.touches ?? []).includes(relation);
+    }
+    /**
+     * Laravel `$model->touchOwners()` — touch each relation in `$touches`.
+     * Uses `relation.touch()` when available (BelongsTo / HasOne / HasMany);
+     * otherwise loads the related model and calls `touch()` on it.
+     */
+    async touchOwners() {
+        const ctor = this.constructor;
+        const names = ctor.touches ?? [];
+        if (names.length === 0)
+            return;
+        for (const name of names) {
+            const rel = this.related(name);
+            if (typeof rel.touch === "function") {
+                await rel.touch();
+                continue;
+            }
+            if (typeof rel.first === "function") {
+                const related = await rel.first();
+                if (related)
+                    await related.touch();
+            }
+        }
+    }
+    /**
+     * Laravel `$model->touch()` — bump `updated_at` (no-op while `withoutTouching`).
+     * Saving also runs `$touches` / `touchOwners()` for listed relations.
+     */
+    async touch() {
+        const ctor = this.constructor;
+        if (isIgnoringTouch(ctor))
+            return false;
+        if (ctor.timestamps === false)
+            return false;
+        if (!this.#exists)
+            return false;
+        const conn = this.getConnection();
+        const now = nowForConnection(conn);
+        this.updated_at = now;
+        await this.save();
+        return true;
+    }
+    /**
+     * Relation query builder (`$model->product()` in Laravel).
+     *
+     * Define relations on `static relations` and declare the loaded property:
+     * `declare product: Product | null` — then use `model.product` after `with('product')`,
+     * and `model.related('product')` when you need the relation query.
+     *
+     * Legacy instance methods named `product()` remain supported via the prototype.
+     */
+    related(name) {
+        const ctor = this.constructor;
+        if (modelsShouldPreventLazyLoading() &&
+            !isInsideEagerLoad() &&
+            this.#exists &&
+            !this.relationLoaded(name)) {
+            throw new LazyLoadingViolationException(ctor.name ?? "Model", name);
+        }
+        const raw = ctor.relations;
+        const map = typeof raw === "function" ? raw.call(ctor) : raw;
+        if (map != null && typeof map[name] === "function") {
+            return map[name](this);
+        }
+        let proto = Object.getPrototypeOf(this);
+        while (proto && proto !== Object.prototype) {
+            const desc = Object.getOwnPropertyDescriptor(proto, name);
+            if (desc && typeof desc.value === "function") {
+                return desc.value.call(this);
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        throw new Error(`Call to undefined relationship [${name}] on model [${ctor.name ?? "Model"}].`);
+    }
+    /** Laravel `$model->replicate()`. */
+    replicate(except = []) {
+        const ctor = this.constructor;
+        ctor.bootIfNotBooted();
+        const key = ctor.primaryKey;
+        const skip = new Set([key, "created_at", "updated_at", ...except]);
+        const attrs = {};
+        for (const [k, v] of Object.entries(this)) {
+            if (skip.has(k) || typeof v === "function")
+                continue;
+            attrs[k] = v;
+        }
+        const copy = new ctor(attrs);
+        // Fire sync-style; listeners may be async but replicate is sync in Laravel.
+        void fireModelEvent(copy, "replicating");
+        return copy;
+    }
+    async delete() {
+        const ctor = this.constructor;
+        ctor.bootIfNotBooted();
+        if ((await fireModelEvent(this, "deleting")) === false)
+            return;
+        if (usesSoftDeletes(ctor)) {
+            await this.#performSoftDelete();
+            await fireModelEvent(this, "deleted");
+            await fireModelEvent(this, "trashed");
+            return;
+        }
+        // Laravel delete(): touchOwners before performDeleteOnModel.
+        await this.touchOwners();
+        await this.#performForceDelete();
+        await fireModelEvent(this, "deleted");
+    }
+    async restore() {
+        const ctor = this.constructor;
+        if (!usesSoftDeletes(ctor))
+            return;
+        ctor.bootIfNotBooted();
+        if ((await fireModelEvent(this, "restoring")) === false)
+            return;
+        const key = ctor.primaryKey;
+        const row = this;
+        const col = deletedAtColumn(ctor);
+        row[col] = null;
+        await new Db(this.getConnection())
+            .table(ctor.table)
+            .where(key, row[key])
+            .update({ [col]: null });
+        await fireModelEvent(this, "restored");
+    }
+    async forceDelete() {
+        const ctor = this.constructor;
+        ctor.bootIfNotBooted();
+        if ((await fireModelEvent(this, "forceDeleting")) === false)
+            return;
+        await this.#performForceDelete();
+        await fireModelEvent(this, "forceDeleted");
+        await fireModelEvent(this, "deleted");
+    }
+    /** Laravel `$model->deleteQuietly()`. */
+    async deleteQuietly() {
+        const ctor = this.constructor;
+        await ctor.withoutEvents(() => this.delete());
+    }
+    async #performSoftDelete() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const row = this;
+        const col = deletedAtColumn(ctor);
+        const now = nowForConnection(this.getConnection());
+        row[col] = now;
+        const payload = { [col]: now };
+        if (ctor.timestamps !== false) {
+            row.updated_at = now;
+            payload.updated_at = now;
+        }
+        await withoutQueryWriteHook(() => new Db(this.getConnection())
+            .table(ctor.table)
+            .where(key, row[key])
+            .update(payload));
+        await this.touchOwners();
+    }
+    async #performForceDelete() {
+        const ctor = this.constructor;
+        const key = ctor.primaryKey;
+        const row = this;
+        await withoutQueryWriteHook(() => new Db(this.getConnection())
+            .table(ctor.table)
+            .where(key, row[key])
+            .delete());
+        this.#exists = false;
+    }
+    trashed() {
+        const ctor = this.constructor;
+        if (!usesSoftDeletes(ctor))
+            return false;
+        const col = deletedAtColumn(ctor);
+        const value = this[col];
+        return value != null && value !== "";
+    }
+    /** Laravel `$model->toArray()`. */
+    toArray() {
+        const ctor = this.constructor;
+        const hiddenList = this.getHidden();
+        const visibleList = this.getVisible();
+        const appends = this.getAppends();
+        const self = this;
+        const hidden = new Set(hiddenList);
+        const visible = visibleList.length > 0 ? new Set(visibleList) : null;
+        const out = {};
+        for (const key in self) {
+            const value = self[key];
+            if (typeof value === "function")
+                continue;
+            if (hidden.has(key))
+                continue;
+            if (visible && !visible.has(key))
+                continue;
+            out[key] = value instanceof Date ? value.toISOString() : value;
+        }
+        for (const key of appends) {
+            if (hidden.has(key))
+                continue;
+            if (visible && !visible.has(key))
+                continue;
+            out[key] = this.#mutateAppendedAttribute(key);
+        }
+        return out;
+    }
+    #mutateAppendedAttribute(key) {
+        const studly = key
+            .split("_")
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join("");
+        const getter = `get${studly}Attribute`;
+        const fn = this[getter];
+        if (typeof fn === "function") {
+            return fn.call(this);
+        }
+        return this[key];
+    }
+    /** Laravel `$model->loadCount(...$relations)`. */
+    async loadCount(...relations) {
+        const names = relations.flat();
+        if (names.length === 0)
+            return this;
+        for (const relation of names) {
+            const parsed = parseRelationAlias(relation);
+            const count = await aggregateRelation(this, parsed.relation, "count");
+            this[parsed.alias ?? `${parsed.relation}_count`] = count;
+        }
+        return this;
+    }
+    /** Laravel `$model->loadSum($relation, $column)`. */
+    async loadSum(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const value = await aggregateRelation(this, parsed.relation, "sum", column);
+        this[parsed.alias ?? `${parsed.relation}_sum_${column}`] = value;
+        return this;
+    }
+    async loadAvg(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const value = await aggregateRelation(this, parsed.relation, "avg", column);
+        this[parsed.alias ?? `${parsed.relation}_avg_${column}`] = value;
+        return this;
+    }
+    async loadMin(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const value = await aggregateRelation(this, parsed.relation, "min", column);
+        this[parsed.alias ?? `${parsed.relation}_min_${column}`] = value;
+        return this;
+    }
+    async loadMax(relation, column) {
+        const parsed = parseRelationAlias(relation);
+        const value = await aggregateRelation(this, parsed.relation, "max", column);
+        this[parsed.alias ?? `${parsed.relation}_max_${column}`] = value;
+        return this;
+    }
+    /** Laravel `$model->loadExists(...$relations)`. */
+    async loadExists(...relations) {
+        for (const relation of relations.flat()) {
+            const parsed = parseRelationAlias(relation);
+            const value = await aggregateRelation(this, parsed.relation, "exists");
+            this[parsed.alias ?? `${parsed.relation}_exists`] = value;
+        }
+        return this;
+    }
+    toJSON() {
+        return this.toArray();
+    }
+    /** Alias of {@link toJSON}. */
+    toJson() {
+        return this.toJSON();
+    }
+    /** Laravel `$model->increment($column, $amount)`. */
+    async increment(column, amount = 1) {
+        const row = this;
+        const current = Number(row[column] ?? 0);
+        row[column] = current + amount;
+        await this.save();
+        return this;
+    }
+    /** Laravel `$model->decrement($column, $amount)`. */
+    async decrement(column, amount = 1) {
+        return this.increment(column, -amount);
+    }
+    /** Laravel `Model::destroy($ids)`. */
+    static async destroy(ids) {
+        const list = Array.isArray(ids) ? ids : [ids];
+        let n = 0;
+        for (const id of list) {
+            const model = await this.find(id);
+            if (!model)
+                continue;
+            await model.delete();
+            n += 1;
+        }
+        return n;
+    }
+    /**
+     * Laravel `Model::forceDestroy($ids)` — permanent delete by key(s).
+     * Soft-delete models are found via `withTrashed()` so trashed rows are included.
+     */
+    static async forceDestroy(ids) {
+        const list = Array.isArray(ids) ? ids : [ids];
+        if (list.length === 0)
+            return 0;
+        this.bootIfNotBooted();
+        const key = this.primaryKey;
+        const models = await this.newQuery().withTrashed().whereIn(key, list).get();
+        let n = 0;
+        for (const model of models) {
+            await model.forceDelete();
+            n += 1;
+        }
+        return n;
+    }
+    /** Laravel `$this->hasMany(Related::class)`. */
+    hasMany(related, foreignKey, localKey) {
+        const key = foreignKey ?? `${singular(this.constructor.table)}_id`;
+        return new HasMany(this, related, key, localKey);
+    }
+    /** Laravel `$this->hasOne(Related::class)`. */
+    hasOne(related, foreignKey, localKey) {
+        const key = foreignKey ?? `${singular(this.constructor.table)}_id`;
+        return new HasOne(this, related, key, localKey);
+    }
+    /**
+     * Laravel `$this->hasManyThrough(Related::class, Through::class)`.
+     * Parent → Through (firstKey) → Related (secondKey).
+     */
+    hasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+        const parentCtor = this.constructor;
+        return new HasManyThrough(this, related, through, firstKey ?? `${singular(parentCtor.table)}_id`, secondKey ?? `${singular(through.table)}_id`, localKey ?? parentCtor.primaryKey, secondLocalKey ?? through.primaryKey);
+    }
+    /**
+     * Laravel `$this->hasOneThrough(Related::class, Through::class)`.
+     */
+    hasOneThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+        const parentCtor = this.constructor;
+        return new HasOneThrough(this, related, through, firstKey ?? `${singular(parentCtor.table)}_id`, secondKey ?? `${singular(through.table)}_id`, localKey ?? parentCtor.primaryKey, secondLocalKey ?? through.primaryKey);
+    }
+    /** Laravel `$this->belongsTo(Related::class)`. */
+    belongsTo(related, foreignKey, ownerKey) {
+        const key = foreignKey ?? `${singular(related.table)}_id`;
+        return new BelongsTo(this, related, key, ownerKey);
+    }
+    /** Laravel `$this->belongsToMany(Related::class, pivot)`. */
+    belongsToMany(related, table, foreignPivotKey, relatedPivotKey) {
+        const parent = this.constructor;
+        const pivot = table ??
+            [singular(parent.table), singular(related.table)].sort().join("_");
+        const foreign = foreignPivotKey ?? `${singular(parent.table)}_id`;
+        const relatedKey = relatedPivotKey ?? `${singular(related.table)}_id`;
+        return new BelongsToMany(this, related, pivot, foreign, relatedKey);
+    }
+    /**
+     * Polymorphic many-to-many (`model_has_roles`-style pivots).
+     * Third argument may be the pivot table name or an options bag (tenant/legacy morph types).
+     */
+    morphToMany(related, name, tableOrOptions, foreignPivotKey, relatedPivotKey) {
+        const options = typeof tableOrOptions === "string" || tableOrOptions == null
+            ? {
+                table: tableOrOptions,
+                foreignPivotKey,
+                relatedPivotKey,
+            }
+            : tableOrOptions;
+        const table = options.table ?? "model_has_roles";
+        const foreign = options.foreignPivotKey ?? "model_id";
+        const relatedKey = options.relatedPivotKey ?? `${singular(related.table)}_id`;
+        const morphTypeColumn = options.morphTypeColumn ?? "model_type";
+        const primaryMorph = morphTypeFor(this.constructor);
+        const morphTypes = options.morphTypes && options.morphTypes.length > 0
+            ? options.morphTypes
+            : [name, primaryMorph].filter((value, index, all) => all.indexOf(value) === index);
+        return new MorphToMany(this, related, table, foreign, relatedKey, morphTypeColumn, morphTypes, options.pivotTenantKey, options.parentTenantKey ?? options.pivotTenantKey);
+    }
+    /** Laravel `$this->morphMany(Related::class, name)`. */
+    morphMany(related, name, type, id, localKey) {
+        return new MorphMany(this, related, type ?? `${name}_type`, id ?? `${name}_id`, morphTypeFor(this.constructor), localKey);
+    }
+    /** Laravel `$this->morphOne(Related::class, name)`. */
+    morphOne(related, name, type, id, localKey) {
+        return new MorphOne(this, related, type ?? `${name}_type`, id ?? `${name}_id`, morphTypeFor(this.constructor), localKey);
+    }
+    /** Laravel `$this->morphTo($name)`. */
+    morphTo(name, type, id, ownerKey) {
+        return new MorphTo(this, type ?? `${name}_type`, id ?? `${name}_id`, ownerKey);
+    }
+}
+installLocalScopeCallStatic(Model);
+/** True when `value` is a Model subclass constructor (O(1) prototype check). */
+export function isModelCtor(value) {
+    return (typeof value === "function" &&
+        value !== Model &&
+        Boolean(value.prototype) &&
+        value.prototype instanceof Model);
+}
+// Re-exports — public API stays on ./model.ts for index.ts
+export { BelongsTo, BelongsToMany, HasMany, HasManyThrough, HasOne, HasOneThrough, MorphMany, MorphOne, MorphTo, MorphToMany, clearMorphMap, morphMap, } from "./relations.js";
+export { eagerLoadAggregates, eagerLoadModels, } from "./eager.js";
+export { ModelQuery } from "./model-query.js";
+export { LazyLoadingViolationException, MassAssignmentException, MissingAttributeException, resetModelStrictnessForTests, } from "./model-strictness.js";