peta-orm 0.2.6 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,2601 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as createCollection } from "./collection-Dv3sQPMx.mjs";
+import { a as ModelNotRegisteredError, c as ValidationError, i as ModelNotFoundError, n as normalizeError, o as RelationNotAllowedError, r as DatabaseError, s as RelationNotFoundError } from "./errors-sfFJolfu.mjs";
+import { a as registerSoftDeletesFor, n as getSoftDeleteConfig, o as registerTimestampsFor, r as hasSoftDelete, s as createHookManager, t as getHooksFor } from "./hooks-BD0xy7uw.mjs";
+import { a as castValue, r as initRuntime, t as createInstance } from "./factory-rIbPGjRg.mjs";
+import { a as getRawRelations, d as setExists, o as getState } from "./state-LtlHp6XV.mjs";
+import { a as setConfig$1, n as reloadModel, r as saveModel, t as getConfig$1 } from "./save-B8rudcT5.mjs";
+import { type } from "arktype";
+import { Kysely, sql } from "kysely";
+import { ulid as ulid$1 } from "ulid";
+//#region src/columns/arktype.ts
+function createArkTypeSchemaConfig() {
+	function compile(dataType, args, constraints) {
+		return type(buildDef(dataType, args, constraints));
+	}
+	function parse(schema, value) {
+		const result = schema(value);
+		if (result instanceof type.errors) throw new ValidationError([...extractProblems(result).entries()].map(([path, msgs]) => `${path}: ${msgs.join(", ")}`).join("; "));
+		return result;
+	}
+	function assert(schema, value) {
+		const t = schema;
+		try {
+			return t.assert(value);
+		} catch (e) {
+			if (isArkError(e)) throw new ValidationError([...extractProblems(e.arkErrors).entries()].map(([path, msgs]) => `${path}: ${msgs.join(", ")}`).join("; "));
+			throw e;
+		}
+	}
+	return {
+		compile,
+		parse,
+		assert
+	};
+}
+function buildDef(dataType, args, constraints) {
+	let lower, upper, nullable = false, hasEmail = false, hasUrl = false, pattern;
+	for (const c of constraints) switch (c.type) {
+		case "min":
+			lower = c.args[0];
+			break;
+		case "max":
+			upper = c.args[0];
+			break;
+		case "email":
+			hasEmail = true;
+			break;
+		case "url":
+			hasUrl = true;
+			break;
+		case "pattern":
+			pattern = c.args[0];
+			break;
+		case "nullable":
+			nullable = true;
+			break;
+	}
+	let def = "";
+	const typeWithSub = typeNameFor(dataType, args) + subTypeModifier(dataType, hasEmail, hasUrl);
+	if (lower !== void 0 && upper !== void 0) def += `${lower} <= ${typeWithSub} <= ${upper}`;
+	else {
+		def += typeWithSub;
+		if (lower !== void 0) def += ` >= ${lower}`;
+		if (upper !== void 0) def += ` <= ${upper}`;
+	}
+	if (pattern) def += ` & /${pattern}/`;
+	if (nullable) def += " | null";
+	return def;
+}
+function typeNameFor(dataType, args) {
+	switch (dataType) {
+		case "integer":
+		case "smallint":
+		case "bigint": return "number.integer";
+		case "float":
+		case "double":
+		case "decimal": return "number";
+		case "string":
+		case "varchar":
+		case "text": return "string";
+		case "boolean": return "boolean";
+		case "timestamp":
+		case "date": return "string.date.iso";
+		case "json":
+		case "jsonb": return "unknown";
+		case "uuid": return "string.uuid";
+		case "enum": return args.map((v) => JSON.stringify(v)).join(" | ");
+		default: return "unknown";
+	}
+}
+function subTypeModifier(dataType, hasEmail, hasUrl) {
+	if (dataType !== "string" && dataType !== "varchar" && dataType !== "text") return "";
+	if (hasEmail) return ".email";
+	if (hasUrl) return ".url";
+	return "";
+}
+function isArkError(e) {
+	return typeof e === "object" && e !== null && "arkErrors" in e;
+}
+function extractProblems(result) {
+	const problems = /* @__PURE__ */ new Map();
+	const raw = result.flatProblemsByPath;
+	if (raw) for (const [path, msgs] of Object.entries(raw)) problems.set(path, msgs);
+	return problems;
+}
+//#endregion
+//#region src/columns/column.ts
+function createColumn(schema, dataType, args = [], constraints = []) {
+	let compiled = null;
+	function withConstraint(type, extraArgs = []) {
+		return createColumn(schema, dataType, args, [...constraints, {
+			type,
+			args: extraArgs
+		}]);
+	}
+	const col = {
+		get arkType() {
+			if (compiled === null) compiled = schema.compile(dataType, args, constraints);
+			return compiled;
+		},
+		get dataType() {
+			return dataType;
+		},
+		get args() {
+			return args;
+		},
+		get constraints() {
+			return constraints;
+		},
+		get isNullable() {
+			return constraints.some((c) => c.type === "nullable");
+		},
+		get isPrimaryKey() {
+			return constraints.some((c) => c.type === "primaryKey");
+		},
+		get isUnique() {
+			return constraints.some((c) => c.type === "unique");
+		},
+		get defaultValue() {
+			const c = constraints.find((c) => c.type === "default");
+			if (!c) return void 0;
+			const val = c.args[0];
+			return typeof val === "function" ? val : val;
+		},
+		hasConstraint(type) {
+			return constraints.some((c) => c.type === type);
+		},
+		parse(value) {
+			return schema.parse(col.arkType, value);
+		},
+		assert(value) {
+			return schema.assert(col.arkType, value);
+		},
+		primaryKey() {
+			return withConstraint("primaryKey");
+		},
+		nullable() {
+			return withConstraint("nullable");
+		},
+		default(value) {
+			return withConstraint("default", [value]);
+		},
+		unique() {
+			return withConstraint("unique");
+		},
+		index() {
+			return withConstraint("index");
+		},
+		min(n) {
+			return withConstraint("min", [n]);
+		},
+		max(n) {
+			return withConstraint("max", [n]);
+		},
+		email() {
+			return withConstraint("email");
+		},
+		url() {
+			return withConstraint("url");
+		},
+		pattern(regex) {
+			return withConstraint("pattern", [typeof regex === "string" ? regex : regex.source]);
+		},
+		references(table, refColumns) {
+			return withConstraint("references", [table, refColumns]);
+		}
+	};
+	return col;
+}
+//#endregion
+//#region src/columns/types.ts
+function t(config) {
+	const schema = config.schema;
+	function col(dataType, args) {
+		return createColumn(schema, dataType, args);
+	}
+	return {
+		integer: () => col("integer"),
+		smallint: () => col("smallint"),
+		bigint: () => col("bigint"),
+		string: (maxLength) => maxLength !== void 0 ? col("string", [maxLength]) : col("string"),
+		text: () => col("text"),
+		boolean: () => col("boolean"),
+		timestamp: () => col("timestamp"),
+		date: () => col("date"),
+		json: () => col("json"),
+		jsonb: () => col("jsonb"),
+		float: () => col("float"),
+		double: () => col("double"),
+		decimal: (precision, scale) => precision !== void 0 ? col("decimal", [precision, scale ?? 0]) : col("decimal"),
+		uuid: () => col("uuid"),
+		enum: (...values) => col("enum", values),
+		timestamps: () => ({
+			createdAt: col("timestamp").default(() => (/* @__PURE__ */ new Date()).toISOString()),
+			updatedAt: col("timestamp").default(() => (/* @__PURE__ */ new Date()).toISOString())
+		})
+	};
+}
+//#endregion
+//#region src/hooks/static.ts
+var static_exports = /* @__PURE__ */ __exportAll({
+	addStaticHook: () => addStaticHook,
+	getStaticHooks: () => getStaticHooks,
+	hasStaticHooks: () => hasStaticHooks
+});
+const staticHooks = /* @__PURE__ */ new WeakMap();
+function addStaticHook(def, event, callback) {
+	let hooks = staticHooks.get(def);
+	if (!hooks) {
+		hooks = /* @__PURE__ */ new Map();
+		staticHooks.set(def, hooks);
+	}
+	let cbs = hooks.get(event);
+	if (!cbs) {
+		cbs = [];
+		hooks.set(event, cbs);
+	}
+	cbs.push(callback);
+	return () => {
+		const idx = cbs.indexOf(callback);
+		if (idx !== -1) cbs.splice(idx, 1);
+	};
+}
+function getStaticHooks(def, event) {
+	return staticHooks.get(def)?.get(event) ?? [];
+}
+function hasStaticHooks(def, event) {
+	return (staticHooks.get(def)?.get(event)?.length ?? 0) > 0;
+}
+//#endregion
+//#region src/relations/eager.ts
+var eager_exports = /* @__PURE__ */ __exportAll({ EagerLoader: () => EagerLoader });
+function isMorphRelation(relation) {
+	return relation._morphMap !== void 0;
+}
+var EagerLoader = class {
+	async loadRelated(models, eagerLoad, def) {
+		const { name, constraints } = eagerLoad;
+		const dotIdx = name.indexOf(".");
+		if (dotIdx === -1) {
+			const relation = def.relations[name];
+			if (!relation) throw new Error(`Relation "${name}" not found on ${def.name}`);
+			await relation.loadEager(models, name, constraints);
+		} else {
+			const baseName = name.slice(0, dotIdx);
+			const nestedName = name.slice(dotIdx + 1);
+			const relation = def.relations[baseName];
+			if (!relation) throw new Error(`Relation "${baseName}" not found on ${def.name}`);
+			if (isMorphRelation(relation)) throw new Error(`Cannot eagerly load nested relation "${nestedName}" through polymorphic relation "${baseName}" on ${def.name}. Nested eager loading through polymorphic belongsTo is not supported.`);
+			await relation.loadEager(models, baseName, null);
+			const relatedModels = [];
+			for (const model of models) {
+				const related = model.$getRelation(baseName);
+				if (Array.isArray(related)) relatedModels.push(...related);
+				else if (related) relatedModels.push(related);
+			}
+			if (relatedModels.length > 0) {
+				const nestedDef = relation.relatedModelClass;
+				if (!nestedDef) throw new Error(`Cannot load nested relation "${nestedName}": "${baseName}" on ${def.name} has no relatedModelClass (morphTo without a morphMap?).`);
+				const nestedRelation = nestedDef.relations[nestedName];
+				if (!nestedRelation) throw new Error(`Relation "${nestedName}" not found on ${nestedDef.name}`);
+				await nestedRelation.loadEager(relatedModels, nestedName, constraints);
+			}
+		}
+	}
+	async loadRelatedForModel(model, name, def) {
+		await this.loadRelated([model], { name }, def);
+	}
+};
+//#endregion
+//#region src/relations/graph/morph.ts
+/** Whether this relation is a MorphTo (polymorphic belongsTo) */
+function isMorphToRelation(relation) {
+	return relation._morphMap !== void 0;
+}
+/** Whether this relation is a MorphMany or MorphOne (polymorphic hasMany/hasOne) */
+function isMorphManyRelation(relation) {
+	return relation._morphType !== void 0 && !isMorphToRelation(relation);
+}
+/** Get the morph type column name (e.g. "commentableType") from a morph relation */
+function getMorphType(relation) {
+	return relation._morphType;
+}
+/** Get the morph type value (e.g. "morph_posts") from a MorphMany/MorphOne relation */
+function getMorphTypeValue(relation) {
+	return relation._morphTypeValue;
+}
+/** Get the morph id column name (e.g. "commentableId") from a morph relation */
+function getMorphId(relation) {
+	return relation._morphId;
+}
+const THUNK_CACHE$3 = /* @__PURE__ */ new WeakMap();
+function resolveThunk$3(thunk) {
+	let cls = THUNK_CACHE$3.get(thunk);
+	if (!cls) {
+		cls = thunk();
+		THUNK_CACHE$3.set(thunk, cls);
+	}
+	return cls;
+}
+//#endregion
+//#region src/relations/graph/parser.ts
+function getPrimaryKeyColumn$2(def) {
+	const cols = def.columns;
+	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
+	return "id";
+}
+function getDb$1(def) {
+	if (!def._orm) throw new Error("Model not registered");
+	return def._orm.kysely;
+}
+function getPivotInfo(relation) {
+	if (relation.type !== "manyToMany" || !relation.throughTable) throw new Error("Not a many-to-many relation");
+	return {
+		throughTable: relation.throughTable,
+		foreignPivotKey: relation.foreignPivotKey ?? "",
+		relatedPivotKey: relation.relatedPivotKey ?? ""
+	};
+}
+async function findRelated(def, conditions) {
+	const key = Object.keys(conditions)[0];
+	return def.query().where(key, "=", conditions[key]).executeTakeFirst();
+}
+async function resolveTargetId(def, target) {
+	if (typeof target === "number" || typeof target === "string") return target;
+	const found = await findRelated(def, target);
+	if (found) return found.get("id");
+}
+/**
+* Splits a graph node's keys into column data and relation operations.
+* Handles both the old-style { create: ..., connect: ... } wrappers and
+* the new graph-style where nested objects/arrays represent relations directly.
+*/
+function extractGraphRelationData(def, node) {
+	const columnData = {};
+	const relationOps = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "#id" || key === "#ref" || key === "#dbRef") continue;
+		if (def.relations[key]) relationOps[key] = value;
+		else columnData[key] = value;
+	}
+	return {
+		columnData,
+		relationOps
+	};
+}
+function collectRefs(node, def, refMap) {
+	const id = node["#id"];
+	if (id && typeof id === "string") {
+		if (refMap.has(id)) throw new Error(`Duplicate #id "${id}" in graph`);
+		refMap.set(id, {
+			node,
+			def
+		});
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "#id" || key === "#ref" || key === "#dbRef") continue;
+		if (def.relations[key]) {
+			const relatedDef = def.relations[key].relatedModelClass;
+			if (Array.isArray(value)) {
+				for (const item of value) if (item && typeof item === "object") collectRefs(item, relatedDef, refMap);
+			} else if (value && typeof value === "object") {
+				const inner = value.create;
+				if (inner && typeof inner === "object") collectRefs(inner, relatedDef, refMap);
+				else collectRefs(value, relatedDef, refMap);
+			}
+		}
+	}
+}
+function resolveRefs(node, context) {
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "#id" || key === "#ref" || key === "#dbRef") continue;
+		if (value && typeof value === "object") if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+			const item = value[i];
+			if (item && typeof item === "object") if ("#ref" in item) {
+				const refId = item["#ref"];
+				if (!context.allowRefs) throw new Error(`#ref is used but allowRefs option is not enabled. Set { allowRefs: true } to use #ref.`);
+				const entry = context.refMap.get(refId);
+				if (!entry) throw new Error(`#ref "${refId}" not found in graph`);
+				value[i] = entry.node;
+			} else resolveRefs(item, context);
+		}
+		else {
+			const obj = value;
+			if (obj.create && typeof obj.create === "object") resolveRefs(obj.create, context);
+			resolveRefs(obj, context);
+		}
+	}
+}
+//#endregion
+//#region src/relations/graph/security.ts
+function isRelationAllowed(relName, allowedSet) {
+	const parts = relName.split(".");
+	for (let i = 0; i < parts.length; i++) if (allowedSet.has(parts.slice(0, i + 1).join("."))) return true;
+	return false;
+}
+function isRelPathAllowed(relName, option) {
+	if (option === void 0 || option === false) return false;
+	if (option === true) return true;
+	return option.includes(relName);
+}
+/**
+* Resolve allowGraph from options (supports both string[] and Set<string>).
+*/
+function resolveAllowGraph(options) {
+	if (!options.allowGraph) return void 0;
+	return options.allowGraph instanceof Set ? options.allowGraph : new Set(options.allowGraph);
+}
+/**
+* Assert that a relation path is allowed by the allowGraph set.
+* Throws RelationNotAllowedError if the path is not permitted.
+* Does nothing if allowedSet is undefined (no restriction).
+*/
+function assertRelationAllowed(def, fullPath, allowedSet) {
+	if (!allowedSet || allowedSet.size === 0) return;
+	if (!isRelationAllowed(fullPath, allowedSet)) throw new RelationNotAllowedError(def.name, fullPath);
+}
+/**
+* Build the full dotted path for a nested relation.
+* If parentPath is empty, returns just relName. Otherwise parentPath + "." + relName.
+*/
+function joinPath(parentPath, relName) {
+	return parentPath ? `${parentPath}.${relName}` : relName;
+}
+function relNameFromPath(path) {
+	const parts = path.split(".");
+	return parts[parts.length - 1] ?? "";
+}
+//#endregion
+//#region src/relations/graph/insert.ts
+/**
+* Insert a graph of related models.
+*
+* Supports:
+* - Nested relation objects (belongsTo/hasOne)
+* - Nested relation arrays (hasMany/manyToMany)
+* - `#id` / `#ref` for shared references (requires `allowRefs: true`)
+* - `#dbRef` for relating to existing records
+*
+* Returns the root node(s) as ModelInstance(s) with IDs populated.
+*/
+async function insertGraph(def, data, options = {}) {
+	const context = {
+		refMap: /* @__PURE__ */ new Map(),
+		processedRefs: /* @__PURE__ */ new Map(),
+		allowRefs: options.allowRefs ?? false,
+		allowedGraphSet: resolveAllowGraph(options)
+	};
+	const nodes = Array.isArray(data) ? data : [data];
+	for (const node of nodes) collectRefs(node, def, context.refMap);
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (typeof node === "object" && node !== null && "#ref" in node) {
+			if (!context.allowRefs) throw new Error(`#ref is used but allowRefs option is not enabled. Set { allowRefs: true } to use #ref.`);
+			const refId = node["#ref"];
+			if (!refId) throw new Error(`#ref must be a string`);
+			const entry = context.refMap.get(refId);
+			if (!entry) throw new Error(`#ref "${refId}" not found in graph`);
+			nodes[i] = entry.node;
+		} else if (node) resolveRefs(node, context);
+	}
+	const results = [];
+	for (const node of nodes) {
+		const result = await processNode(node, def, null, options, context, "");
+		results.push(result);
+	}
+	return Array.isArray(data) ? results : results[0];
+}
+async function processNode(node, def, parentFK, options, context, path) {
+	const nodeId = node["#id"];
+	if (nodeId && typeof nodeId === "string" && context.processedRefs.has(nodeId)) return context.processedRefs.get(nodeId);
+	const { columnData, relationOps } = extractGraphRelationData(def, node);
+	if (parentFK) Object.assign(columnData, parentFK);
+	for (const [relName, op] of Object.entries(relationOps)) {
+		const relation = def.relations[relName];
+		if (relation?.type === "belongsTo") {
+			const relPath = joinPath(path, relName);
+			assertRelationAllowed(def, relPath, context.allowedGraphSet);
+			const relatedInstance = await processBelongsTo(relation, op, options, context, relPath, columnData);
+			if (relatedInstance) columnData[relation.foreignKey] = relatedInstance.get(relation.localKey);
+		}
+	}
+	if (node["#dbRef"] != null) {
+		const id = node["#dbRef"];
+		const existing = await def.find(id);
+		if (!existing) throw new DatabaseError(`#dbRef ${id} not found on ${def.name}`, "UNKNOWN");
+		if (nodeId && typeof nodeId === "string") context.processedRefs.set(nodeId, existing);
+		return existing;
+	}
+	const instance = await def.insert(columnData);
+	if (nodeId && typeof nodeId === "string") context.processedRefs.set(nodeId, instance);
+	const pkCol = getPrimaryKeyColumn$2(def);
+	const pkValue = instance.get(pkCol);
+	if (pkValue == null) throw new DatabaseError("Cannot process relations without primary key", "MISSING_ID");
+	for (const [relName, op] of Object.entries(relationOps)) {
+		const relation = def.relations[relName];
+		if (!relation) continue;
+		if (relation.type === "belongsTo") continue;
+		const relPath = joinPath(path, relName);
+		assertRelationAllowed(def, relPath, context.allowedGraphSet);
+		const relOptions = {
+			...options,
+			relate: options.relate
+		};
+		if (relation.type === "hasMany" || relation.type === "hasOne") await processHasMany(instance, relation, op, pkValue, relOptions, context, relPath);
+		else if (relation.type === "manyToMany") await processManyToMany(instance, relation, op, pkValue, relOptions, context, relPath);
+	}
+	return instance;
+}
+async function processBelongsTo(relation, op, options, context, path, parentColumnData) {
+	if (isMorphToRelation(relation)) return processMorphTo(relation, op, options, context, path, parentColumnData);
+	const relatedDef = relation.relatedModelClass;
+	if (op["#dbRef"] != null) {
+		const id = op["#dbRef"];
+		const existing = await relatedDef.find(id);
+		if (!existing) throw new DatabaseError(`#dbRef ${id} not found on ${relatedDef.name}`, "UNKNOWN");
+		return existing;
+	}
+	if (op.connect && typeof op.connect === "object") {
+		const conditions = op.connect;
+		const existing = await findRelated(relatedDef, conditions);
+		if (existing) return existing;
+		throw new DatabaseError(`Cannot connect: ${JSON.stringify(conditions)} not found on ${relatedDef.name}`, "UNKNOWN");
+	}
+	if (op.create && typeof op.create === "object") return processNode(op.create, relatedDef, null, options, context, path);
+	return processNode({ ...op }, relatedDef, null, options, context, path);
+}
+/**
+* Process a MorphTo (polymorphic belongsTo) relation in a graph operation.
+*
+* The user must specify which polymorphic type to create via a `type` key
+* in the operation data:
+*   { commentable: { create: { title: "..." }, type: "morph_posts" } }
+*
+* If the morphMap has only one entry, `type` is optional (auto-detected).
+*/
+async function processMorphTo(relation, op, options, context, path, parentColumnData) {
+	const morphMap = relation._morphMap;
+	const morphType = getMorphType(relation);
+	const morphId = getMorphId(relation);
+	if (!morphMap || Object.keys(morphMap).length === 0) throw new Error("Cannot process MorphTo relation: no morphMap provided. Define a morphMap with model thunks when calling defineMorphTo().");
+	let typeValue = op.type;
+	if (!typeValue) {
+		const keys = Object.keys(morphMap);
+		if (keys.length === 1) typeValue = keys[0];
+	}
+	if (!typeValue) throw new Error(`Cannot resolve MorphTo: no type specified. Provide a "type" key in the relation data (e.g., { type: "${Object.keys(morphMap)[0]}" }). Available types: ${Object.keys(morphMap).join(", ")}`);
+	const thunk = morphMap[typeValue];
+	if (!thunk) throw new Error(`No model registered for morph type "${typeValue}" in MorphTo. Available types: ${Object.keys(morphMap).join(", ")}`);
+	const relatedDef = resolveThunk$3(thunk);
+	let instance = null;
+	if (op["#dbRef"] != null) {
+		const id = op["#dbRef"];
+		const existing = await relatedDef.find(id);
+		if (!existing) throw new DatabaseError(`#dbRef ${id} not found on ${relatedDef.name}`, "UNKNOWN");
+		instance = existing;
+	} else if (op.connect && typeof op.connect === "object") {
+		const conditions = op.connect;
+		const existing = await findRelated(relatedDef, conditions);
+		if (existing) instance = existing;
+		else throw new DatabaseError(`Cannot connect: ${JSON.stringify(conditions)} not found on ${relatedDef.name}`, "UNKNOWN");
+	} else if (op.create && typeof op.create === "object") instance = await processNode(op.create, relatedDef, null, options, context, path);
+	else {
+		const createData = { ...op };
+		delete createData.type;
+		delete createData[morphType];
+		delete createData[morphId];
+		instance = await processNode(createData, relatedDef, null, options, context, path);
+	}
+	if (instance && parentColumnData && typeValue) parentColumnData[morphType] = typeValue;
+	return instance;
+}
+async function processHasMany(_instance, relation, op, pkValue, options, context, path) {
+	const relatedDef = relation.relatedModelClass;
+	const fk = relation.foreignKey;
+	let items;
+	if (op == null) items = [];
+	else if (Array.isArray(op)) items = op;
+	else if (op?.create && Array.isArray(op.create)) items = op.create;
+	else if (typeof op === "object" && !("connect" in op)) items = [op];
+	else items = [];
+	for (const item of items) {
+		if (item["#dbRef"] != null) {
+			const id = item["#dbRef"];
+			const existing = await relatedDef.find(id);
+			if (!existing) throw new DatabaseError(`#dbRef ${id} not found on ${relatedDef.name}`, "UNKNOWN");
+			existing.set(fk, pkValue);
+			await existing.$save();
+			continue;
+		}
+		const parentData = { [fk]: pkValue };
+		if (isMorphManyRelation(relation)) {
+			const typeCol = getMorphType(relation);
+			const typeVal = getMorphTypeValue(relation);
+			if (typeVal !== void 0) parentData[typeCol] = typeVal;
+		}
+		await processNode(item, relatedDef, parentData, options, context, path);
+	}
+	const connectItems = !Array.isArray(op) ? op?.connect ?? [] : [];
+	for (const target of connectItems) {
+		const targetId = await resolveTargetId(relatedDef, target);
+		if (targetId != null) {
+			const existing = await relatedDef.find(targetId);
+			if (existing) {
+				existing.set(fk, pkValue);
+				await existing.$save();
+			}
+		}
+	}
+}
+async function processManyToMany(_instance, relation, op, pkValue, options, context, path) {
+	const relatedDef = relation.relatedModelClass;
+	const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo(relation);
+	const db = getDb$1(relatedDef);
+	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
+	for (const item of items) {
+		if (item["#dbRef"] != null) {
+			const id = item["#dbRef"];
+			try {
+				await db.insertInto(throughTable).values({
+					[foreignPivotKey]: pkValue,
+					[relatedPivotKey]: id
+				}).execute();
+			} catch {}
+			continue;
+		}
+		const relatedId = (await processNode(item, relatedDef, null, options, context, path)).get(relation.localKey ?? "id");
+		if (relatedId != null) try {
+			await db.insertInto(throughTable).values({
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: relatedId
+			}).execute();
+		} catch {}
+	}
+	const connectItems = !Array.isArray(op) ? op?.connect ?? [] : [];
+	for (const target of connectItems) {
+		const targetId = await resolveTargetId(relatedDef, target);
+		if (targetId != null) try {
+			await db.insertInto(throughTable).values({
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: targetId
+			}).execute();
+		} catch {}
+	}
+}
+//#endregion
+//#region src/relations/graph/upsert.ts
+/**
+* Upsert a graph of related models.
+*
+* Models with an `id` get updated, models without an `id` get inserted.
+* Models in relation arrays that were not included get deleted (or unrelated).
+*
+* See {@link UpsertGraphOptions} for fine-grained control.
+*/
+async function upsertGraph(def, data, options = {}) {
+	const context = {
+		refMap: /* @__PURE__ */ new Map(),
+		processedRefs: /* @__PURE__ */ new Map(),
+		allowRefs: options.allowRefs ?? false,
+		allowedGraphSet: resolveAllowGraph(options)
+	};
+	const nodes = Array.isArray(data) ? data : [data];
+	for (const node of nodes) collectRefs(node, def, context.refMap);
+	for (const node of nodes) resolveRefs(node, context);
+	const results = [];
+	for (const node of nodes) {
+		const result = await upsertNode(node, def, null, options, context, "");
+		results.push(result);
+	}
+	return Array.isArray(data) ? results : results[0];
+}
+async function upsertNode(node, def, parentFK, options, context, _path) {
+	const nodeId = node["#id"];
+	if (nodeId && typeof nodeId === "string" && context.processedRefs.has(nodeId)) return context.processedRefs.get(nodeId);
+	const { columnData, relationOps } = extractGraphRelationData(def, node);
+	if (parentFK) Object.assign(columnData, parentFK);
+	for (const [relName, op] of Object.entries(relationOps)) {
+		const relation = def.relations[relName];
+		if (relation?.type === "belongsTo") {
+			const relPath = joinPath(_path, relName);
+			assertRelationAllowed(def, relPath, context.allowedGraphSet);
+			const relatedInstance = await processBelongsTo(relation, op, options, context, relPath, columnData);
+			if (relatedInstance) columnData[relation.foreignKey] = relatedInstance.get(relation.localKey);
+		}
+	}
+	const pkCol = getPrimaryKeyColumn$2(def);
+	const idValue = columnData[pkCol] ?? node[pkCol];
+	let instance;
+	if (idValue != null) if (isRelPathAllowed(pkCol, options.noUpdate)) {
+		const existing = await def.find(idValue);
+		if (!existing) throw new DatabaseError(`Cannot find ${def.name} with id ${idValue}`, "UNKNOWN");
+		instance = existing;
+	} else {
+		const existing = await def.find(idValue);
+		if (existing) {
+			existing.fill(columnData);
+			await existing.$save();
+			instance = existing;
+		} else instance = await def.insert(columnData);
+	}
+	else instance = await def.insert(columnData);
+	if (nodeId && typeof nodeId === "string") context.processedRefs.set(nodeId, instance);
+	const pkValue = instance.get(pkCol);
+	if (pkValue == null) throw new DatabaseError("Cannot process relations without primary key", "MISSING_ID");
+	for (const [relName, op] of Object.entries(relationOps)) {
+		const relation = def.relations[relName];
+		if (!relation) continue;
+		if (relation.type === "belongsTo") continue;
+		const relPath = joinPath(_path, relName);
+		assertRelationAllowed(def, relPath, context.allowedGraphSet);
+		if (relation.type === "hasMany" || relation.type === "hasOne") await upsertHasMany(instance, relation, op, pkValue, options, context, relPath);
+		else if (relation.type === "manyToMany") await upsertManyToMany(instance, relation, op, pkValue, options, context, relPath);
+	}
+	return instance;
+}
+async function upsertHasMany(_instance, relation, op, pkValue, options, context, path) {
+	const relatedDef = relation.relatedModelClass;
+	const fk = relation.foreignKey;
+	const existingChildren = await relatedDef.query().where(fk, "=", pkValue).execute();
+	const existingMap = /* @__PURE__ */ new Map();
+	for (const child of existingChildren) {
+		const pkCol = getPrimaryKeyColumn$2(relatedDef);
+		existingMap.set(child.get(pkCol), child);
+	}
+	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
+	const incomingIds = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		const itemId = item[getPrimaryKeyColumn$2(relatedDef)] ?? item.id;
+		if (itemId != null) {
+			incomingIds.add(itemId);
+			if (!isRelPathAllowed(relNameFromPath(path), options.noUpdate)) {
+				const existing = existingMap.get(itemId);
+				if (existing) {
+					const { columnData: colData, relationOps: nestedOps } = extractGraphRelationData(relatedDef, item);
+					existing.fill(colData);
+					await existing.$save();
+					if (item["#id"]) context.processedRefs.set(item["#id"], existing);
+					existingMap.delete(itemId);
+					for (const [relName, relOp] of Object.entries(nestedOps)) {
+						const rel = relatedDef.relations[relName];
+						if (!rel) continue;
+						const nestedPath = `${path}.${relName}`;
+						assertRelationAllowed(relatedDef, nestedPath, context.allowedGraphSet);
+						const childPk = existing.get(getPrimaryKeyColumn$2(relatedDef));
+						if (rel.type === "hasMany" || rel.type === "hasOne") await upsertHasMany(existing, rel, relOp, childPk, options, context, nestedPath);
+						else if (rel.type === "manyToMany") await upsertManyToMany(existing, rel, relOp, childPk, options, context, nestedPath);
+					}
+					continue;
+				}
+			}
+		}
+		const parentData = { [fk]: pkValue };
+		if (isMorphManyRelation(relation)) {
+			const typeCol = getMorphType(relation);
+			const typeVal = getMorphTypeValue(relation);
+			if (typeVal !== void 0) parentData[typeCol] = typeVal;
+		}
+		await processNode(item, relatedDef, parentData, options, context, path);
+	}
+	const relName = relNameFromPath(path);
+	const shouldDelete = !isRelPathAllowed(relName, options.noDelete);
+	const shouldUnrelate = isRelPathAllowed(relName, options.unrelate);
+	if (shouldDelete || shouldUnrelate) {
+		for (const [existingId, existing] of existingMap) if (!incomingIds.has(existingId)) {
+			if (shouldUnrelate) {
+				existing.set(fk, null);
+				await existing.$save();
+			} else if (shouldDelete) await existing.$delete();
+		}
+	}
+}
+async function upsertManyToMany(_instance, relation, op, pkValue, options, context, path) {
+	const relatedDef = relation.relatedModelClass;
+	const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo(relation);
+	const db = getDb$1(relatedDef);
+	let existingPivotIds = /* @__PURE__ */ new Set();
+	try {
+		const pivots = await db.selectFrom(throughTable).select(relatedPivotKey).where(foreignPivotKey, "=", pkValue).execute();
+		existingPivotIds = new Set(pivots.map((p) => p[relatedPivotKey]));
+	} catch {}
+	const incomingIds = /* @__PURE__ */ new Set();
+	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
+	for (const item of items) {
+		if (item["#dbRef"] != null) {
+			const id = item["#dbRef"];
+			incomingIds.add(id);
+			if (!existingPivotIds.has(id)) try {
+				await db.insertInto(throughTable).values({
+					[foreignPivotKey]: pkValue,
+					[relatedPivotKey]: id
+				}).execute();
+			} catch {}
+			continue;
+		}
+		const itemId = item[getPrimaryKeyColumn$2(relatedDef)] ?? item.id;
+		if (itemId != null) {
+			incomingIds.add(itemId);
+			if (!isRelPathAllowed(relNameFromPath(path), options.noUpdate)) {
+				const existing = await relatedDef.find(itemId);
+				if (existing) {
+					existing.fill(item);
+					await existing.$save();
+				}
+			}
+			if (!existingPivotIds.has(itemId)) try {
+				await db.insertInto(throughTable).values({
+					[foreignPivotKey]: pkValue,
+					[relatedPivotKey]: itemId
+				}).execute();
+			} catch {}
+		} else {
+			const relatedId = (await processNode(item, relatedDef, null, options, context, path)).get(relation.localKey ?? "id");
+			if (relatedId != null) {
+				incomingIds.add(relatedId);
+				try {
+					await db.insertInto(throughTable).values({
+						[foreignPivotKey]: pkValue,
+						[relatedPivotKey]: relatedId
+					}).execute();
+				} catch {}
+			}
+		}
+	}
+	const connectItems = !Array.isArray(op) ? op?.connect ?? [] : [];
+	for (const target of connectItems) {
+		const targetId = await resolveTargetId(relatedDef, target);
+		if (targetId != null) {
+			incomingIds.add(targetId);
+			if (!existingPivotIds.has(targetId)) try {
+				await db.insertInto(throughTable).values({
+					[foreignPivotKey]: pkValue,
+					[relatedPivotKey]: targetId
+				}).execute();
+			} catch {}
+		}
+	}
+	const relName = relNameFromPath(path);
+	const shouldDelete = !isRelPathAllowed(relName, options.noDelete);
+	const shouldUnrelate = isRelPathAllowed(relName, options.unrelate);
+	if (shouldDelete || shouldUnrelate) {
+		for (const pivotId of existingPivotIds) if (!incomingIds.has(pivotId)) {
+			if (shouldUnrelate) try {
+				await db.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "=", pivotId).execute();
+			} catch {}
+			else if (shouldDelete) {
+				await (await relatedDef.find(pivotId))?.$delete();
+				try {
+					await db.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "=", pivotId).execute();
+				} catch {}
+			}
+		}
+	}
+}
+//#endregion
+//#region src/relations/graph/index.ts
+var graph_exports = /* @__PURE__ */ __exportAll({
+	insertGraph: () => insertGraph,
+	upsertGraph: () => upsertGraph
+});
+//#endregion
+//#region src/query/builder.ts
+function rawSql(str) {
+	return sql([str]);
+}
+const SAFE_COLUMN = /^[a-zA-Z_*][a-zA-Z0-9_.*]*$/;
+function createQueryBuilder(def, peta) {
+	const db = peta?.kysely ?? def._orm?.kysely;
+	if (!db) throw new Error("Model not registered with an ORM instance");
+	let qb = db.selectFrom(def.table);
+	let hasAll = false;
+	const eagerLoads = [];
+	let withTrashed = false;
+	let onlyTrashedMode = false;
+	const omitScopes = /* @__PURE__ */ new Set();
+	let scopesApplied = false;
+	let hasEffectiveWhere = false;
+	let selectedColumns = null;
+	const aggregateColumns = [];
+	const aggregateAliases = [];
+	const whereOps = [];
+	let allowedGraphSet = null;
+	function validateColumn(ref) {
+		if (!SAFE_COLUMN.test(ref)) throw new Error(`Invalid column reference: ${ref}`);
+		return ref;
+	}
+	function applyScopes() {
+		if (scopesApplied) return;
+		scopesApplied = true;
+		const scopes = def.getGlobalScopes?.();
+		if (scopes) {
+			for (const [name, fn] of scopes) if (!omitScopes.has(name)) fn(self);
+		}
+		const cols = def.columns;
+		if ("deletedAt" in cols || Object.values(cols).some((c) => c.dataType === "timestamp" && c.isNullable)) {
+			if (onlyTrashedMode) qb = qb.where("deletedAt", "is not", null);
+			else if (!withTrashed) qb = qb.where("deletedAt", "is", null);
+		}
+	}
+	function assertWhereForMutation() {
+		if (!hasEffectiveWhere && !hasAll) throw new Error("Mutation requires an explicit WHERE condition or .all(). Use .all() to target all rows, or add a WHERE clause.");
+	}
+	async function runExecute() {
+		applyScopes();
+		const { getComputedConfig, applyComputedColumnsAsync } = await Promise.resolve().then(() => computed_exports);
+		const computedConfig = getComputedConfig(def);
+		const sqlColumns = selectedColumns?.filter((col) => !computedConfig?.[col]);
+		const allSelectedAreComputed = selectedColumns !== null && sqlColumns !== void 0 && sqlColumns.length === 0 && selectedColumns.length > 0;
+		let currentQb = sqlColumns && sqlColumns.length > 0 ? qb.select(sqlColumns.map(validateColumn)) : allSelectedAreComputed ? qb.selectAll() : selectedColumns ? qb.select(selectedColumns.map(validateColumn)) : qb.selectAll();
+		for (let i = 0; i < aggregateColumns.length; i++) {
+			const col = aggregateColumns[i];
+			if (col) currentQb = currentQb.select(sql([col]));
+		}
+		const models = (await currentQb.execute()).map((row) => def.hydrate(row));
+		if (models.length > 0) {
+			if (computedConfig) await applyComputedColumnsAsync(models, computedConfig, selectedColumns);
+		}
+		if (eagerLoads.length > 0) {
+			const loader = new EagerLoader();
+			for (const el of eagerLoads) await loader.loadRelated(models, el, def);
+		}
+		return models;
+	}
+	const self = {
+		then(onfulfilled, onrejected) {
+			return runExecute().then(onfulfilled, onrejected);
+		},
+		execute: runExecute,
+		async collect() {
+			const items = await runExecute();
+			const { createCollection } = await import("./collection-Dv3sQPMx.mjs").then((n) => n.t);
+			return createCollection(items);
+		},
+		async executeTakeFirst() {
+			return (await self.limit(1).execute())[0];
+		},
+		async executeTakeFirstOrThrow() {
+			const item = await self.executeTakeFirst();
+			if (!item) throw new ModelNotFoundError(def.name, "query");
+			return item;
+		},
+		async find(id) {
+			return self.where("id", "=", id).executeTakeFirst();
+		},
+		async findOrFail(id) {
+			const item = await self.find(id);
+			if (!item) throw new ModelNotFoundError(def.name, id);
+			return item;
+		},
+		async first() {
+			return self.limit(1).executeTakeFirst();
+		},
+		toSQL() {
+			applyScopes();
+			const compiled = qb.selectAll().compile();
+			return {
+				sql: compiled.sql,
+				parameters: compiled.parameters
+			};
+		},
+		async count() {
+			applyScopes();
+			const result = await qb.clearOrderBy().select((eb) => eb.fn.countAll().as("count")).executeTakeFirst();
+			return Number(result?.count ?? 0);
+		},
+		async sum(column) {
+			applyScopes();
+			const result = await qb.select((eb) => eb.fn.sum(validateColumn(column)).as("sum")).executeTakeFirst();
+			return Number(result?.sum ?? 0);
+		},
+		async avg(column) {
+			applyScopes();
+			const result = await qb.select((eb) => eb.fn.avg(validateColumn(column)).as("avg")).executeTakeFirst();
+			return Number(result?.avg ?? 0);
+		},
+		async min(column) {
+			applyScopes();
+			const result = await qb.select((eb) => eb.fn.min(validateColumn(column)).as("min")).executeTakeFirst();
+			return Number(result?.min ?? 0);
+		},
+		async max(column) {
+			applyScopes();
+			const result = await qb.select((eb) => eb.fn.max(validateColumn(column)).as("max")).executeTakeFirst();
+			return Number(result?.max ?? 0);
+		},
+		withCount(relation) {
+			const alias = `${relation}_count`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT COUNT(*) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		withSum(relation, column) {
+			const alias = `${relation}_sum_${column}`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT COALESCE(SUM(${relatedTable}.${validateColumn(column)}), 0) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		withAvg(relation, column) {
+			const alias = `${relation}_avg_${column}`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT AVG(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		withMin(relation, column) {
+			const alias = `${relation}_min_${column}`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT MIN(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		withMax(relation, column) {
+			const alias = `${relation}_max_${column}`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT MAX(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		withExists(relation) {
+			const alias = `${relation}_exists`;
+			const rel = def.relations[relation];
+			if (!rel) throw new RelationNotFoundError(def.name, relation);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			aggregateColumns.push(`(SELECT EXISTS(SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})) as ${alias}`);
+			aggregateAliases.push(alias);
+			return self;
+		},
+		async chunk(size, callback) {
+			let offset = 0;
+			let hasMore = true;
+			while (hasMore) {
+				const items = await self.limit(size).offset(offset).execute();
+				if (items.length === 0) hasMore = false;
+				else {
+					await callback(items);
+					offset += items.length;
+					hasMore = items.length >= size;
+				}
+			}
+		},
+		async paginate(page, perPage = 20) {
+			const safePage = Math.max(1, page);
+			const safePerPage = Math.min(Math.max(1, perPage), 1e3);
+			applyScopes();
+			const countResult = await qb.clearOrderBy().select((eb) => eb.fn.countAll().as("total")).executeTakeFirst();
+			const total = Number(countResult?.total ?? 0);
+			const items = await self.limit(safePerPage).offset((safePage - 1) * safePerPage).execute();
+			const { createPaginator } = await Promise.resolve().then(() => pagination_exports);
+			return createPaginator(items, total, safePerPage, safePage);
+		},
+		allowGraph(...expressions) {
+			const paths = /* @__PURE__ */ new Set();
+			for (const expr of expressions) {
+				const parts = expr.replace(/[[\]']/g, "").split(/[\s,]+/).filter(Boolean);
+				for (const part of parts) paths.add(part);
+			}
+			allowedGraphSet = paths;
+			return self;
+		},
+		with(...relations) {
+			for (const rel of relations) if (typeof rel === "string") {
+				if (allowedGraphSet && !isRelationAllowed(rel, allowedGraphSet)) throw new RelationNotAllowedError(def.name, rel);
+				eagerLoads.push({ name: rel });
+			} else for (const [name, constraints] of Object.entries(rel)) {
+				if (allowedGraphSet && !isRelationAllowed(name, allowedGraphSet)) throw new RelationNotAllowedError(def.name, name);
+				eagerLoads.push({
+					name,
+					constraints
+				});
+			}
+			return self;
+		},
+		async insertGraph(data, options) {
+			const { insertGraph: doInsertGraph } = await Promise.resolve().then(() => graph_exports);
+			return doInsertGraph(def, data, {
+				...options,
+				allowGraph: allowedGraphSet ? [...allowedGraphSet] : options?.allowGraph
+			});
+		},
+		async upsertGraph(data, options) {
+			const { upsertGraph: doUpsertGraph } = await Promise.resolve().then(() => graph_exports);
+			return doUpsertGraph(def, data, {
+				...options,
+				allowGraph: allowedGraphSet ? [...allowedGraphSet] : options?.allowGraph
+			});
+		},
+		async updateMany(data) {
+			applyScopes();
+			assertWhereForMutation();
+			const { hasStaticHooks, getStaticHooks } = await Promise.resolve().then(() => static_exports);
+			if (hasStaticHooks(def, "beforeUpdate")) {
+				const hooks = getStaticHooks(def, "beforeUpdate");
+				let cancelled = false;
+				let cancelResult;
+				const asFindQuery = () => {
+					const selectQb = createQueryBuilder(def);
+					for (const op of whereOps) op(selectQb);
+					return selectQb;
+				};
+				const cancelQuery = (result) => {
+					cancelled = true;
+					cancelResult = result;
+				};
+				for (const hook of hooks) await hook({
+					asFindQuery,
+					cancelQuery,
+					inputItems: [data]
+				});
+				if (cancelled) return cancelResult;
+			}
+			let updateQb = db.updateTable(def.table).set(data);
+			for (const op of whereOps) updateQb = op(updateQb);
+			try {
+				const result = await updateQb.execute();
+				return Number(result.numUpdatedRows ?? 0);
+			} catch (e) {
+				const { normalizeError } = await import("./errors-sfFJolfu.mjs").then((n) => n.t);
+				throw normalizeError(e, def.table);
+			}
+		},
+		async deleteMany() {
+			applyScopes();
+			assertWhereForMutation();
+			const { hasStaticHooks, getStaticHooks } = await Promise.resolve().then(() => static_exports);
+			const hasBefore = hasStaticHooks(def, "beforeDelete");
+			const hasAfter = hasStaticHooks(def, "afterDelete");
+			if (hasBefore) {
+				const hooks = getStaticHooks(def, "beforeDelete");
+				let cancelled = false;
+				let cancelResult;
+				const asFindQuery = () => {
+					const selectQb = createQueryBuilder(def);
+					for (const op of whereOps) op(selectQb);
+					return selectQb;
+				};
+				const cancelQuery = (result) => {
+					cancelled = true;
+					cancelResult = result;
+				};
+				for (const hook of hooks) await hook({
+					asFindQuery,
+					cancelQuery,
+					inputItems: void 0
+				});
+				if (cancelled) return cancelResult;
+			}
+			let deletedRows = [];
+			if (hasAfter) {
+				const previewQb = createQueryBuilder(def);
+				for (const op of whereOps) op(previewQb);
+				deletedRows = await previewQb.execute();
+			}
+			let deleteQb = db.deleteFrom(def.table);
+			for (const op of whereOps) deleteQb = op(deleteQb);
+			let numDeleted = 0;
+			try {
+				const result = await deleteQb.execute();
+				numDeleted = Number(result.numDeletedRows ?? 0);
+			} catch (e) {
+				const { normalizeError } = await import("./errors-sfFJolfu.mjs").then((n) => n.t);
+				throw normalizeError(e, def.table);
+			}
+			if (hasAfter && deletedRows.length > 0) {
+				const hooks = getStaticHooks(def, "afterDelete");
+				const afterAsFindQuery = () => {
+					const selectQb = createQueryBuilder(def);
+					for (const op of whereOps) op(selectQb);
+					return selectQb;
+				};
+				for (const hook of hooks) await hook({
+					asFindQuery: afterAsFindQuery,
+					cancelQuery: () => {},
+					inputItems: void 0
+				});
+			}
+			return numDeleted;
+		},
+		withTrashed() {
+			withTrashed = true;
+			return self;
+		},
+		onlyTrashed() {
+			onlyTrashedMode = true;
+			withTrashed = false;
+			return self;
+		},
+		whereIn(column, values) {
+			qb = qb.where(validateColumn(column), "in", values);
+			whereOps.push((q) => q.where(validateColumn(column), "in", values));
+			hasEffectiveWhere = values.length > 0;
+			return self;
+		},
+		whereInPivot(column, values) {
+			qb = qb.where(validateColumn(column), "in", values);
+			whereOps.push((q) => q.where(validateColumn(column), "in", values));
+			hasEffectiveWhere = values.length > 0;
+			return self;
+		},
+		has(relationName) {
+			const rel = def.relations[relationName];
+			if (!rel) throw new RelationNotFoundError(def.name, relationName);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			const existsExpr = rawSql(`EXISTS (SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})`);
+			qb = qb.where(existsExpr);
+			hasEffectiveWhere = true;
+			return self;
+		},
+		whereHas(relationName, _callback) {
+			return self.has(relationName);
+		},
+		whereDoesntHave(relationName, _callback) {
+			const rel = def.relations[relationName];
+			if (!rel) throw new RelationNotFoundError(def.name, relationName);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			const notExistsExpr = rawSql(`NOT EXISTS (SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})`);
+			qb = qb.where(notExistsExpr);
+			hasEffectiveWhere = true;
+			return self;
+		},
+		where(column, operator, value) {
+			if (value === void 0) {
+				qb = qb.where(validateColumn(column), "=", operator);
+				whereOps.push((q) => q.where(validateColumn(column), "=", operator));
+				hasEffectiveWhere = true;
+			} else {
+				qb = qb.where(validateColumn(column), operator, value);
+				whereOps.push((q) => q.where(validateColumn(column), operator, value));
+				hasEffectiveWhere = true;
+			}
+			return self;
+		},
+		whereRef(col1, operator, col2) {
+			qb = qb.whereRef(validateColumn(col1), operator, validateColumn(col2));
+			whereOps.push((q) => q.whereRef(validateColumn(col1), operator, validateColumn(col2)));
+			hasEffectiveWhere = true;
+			return self;
+		},
+		orWhere(column, operator, value) {
+			if (value === void 0) {
+				qb = qb.orWhere(validateColumn(column), "=", operator);
+				whereOps.push((q) => q.orWhere(validateColumn(column), "=", operator));
+			} else {
+				qb = qb.orWhere(validateColumn(column), operator, value);
+				whereOps.push((q) => q.orWhere(validateColumn(column), operator, value));
+			}
+			hasEffectiveWhere = true;
+			return self;
+		},
+		orderBy(column, direction = "asc") {
+			qb = qb.orderBy(validateColumn(column), direction);
+			return self;
+		},
+		limit(n) {
+			qb = qb.limit(n);
+			return self;
+		},
+		offset(n) {
+			qb = qb.offset(n);
+			return self;
+		},
+		select(...columns) {
+			selectedColumns = columns;
+			return self;
+		},
+		selectAll(_table) {
+			selectedColumns = null;
+			return self;
+		},
+		innerJoin(table, lhs, rhs) {
+			qb = qb.innerJoin(table, (join) => join.onRef(lhs, "=", rhs));
+			return self;
+		},
+		leftJoin(table, lhs, rhs) {
+			qb = qb.leftJoin(table, (join) => join.onRef(lhs, "=", rhs));
+			return self;
+		},
+		groupBy(...columns) {
+			qb = qb.groupBy(columns.map(validateColumn));
+			return self;
+		},
+		having(column, operator, value) {
+			qb = qb.having(validateColumn(column), operator, value);
+			hasEffectiveWhere = true;
+			return self;
+		},
+		withoutGlobalScope(name) {
+			omitScopes.add(name);
+			return self;
+		},
+		all() {
+			hasAll = true;
+			return self;
+		},
+		when(condition, callback) {
+			if (condition) return callback(self);
+			return self;
+		},
+		unless(condition, callback) {
+			if (!condition) return callback(self);
+			return self;
+		},
+		_getKyselyQb() {
+			return qb;
+		},
+		_replaceKyselyQb(newQb) {
+			qb = newQb;
+		}
+	};
+	return self;
+}
+//#endregion
+//#region src/model/scopes.ts
+const globalScopes = /* @__PURE__ */ new WeakMap();
+function addScope(def, name, callback) {
+	let scopes = globalScopes.get(def);
+	if (!scopes) {
+		scopes = /* @__PURE__ */ new Map();
+		globalScopes.set(def, scopes);
+	}
+	scopes.set(name, callback);
+}
+function removeScope(def, name) {
+	globalScopes.get(def)?.delete(name);
+}
+function getScopes(def) {
+	return globalScopes.get(def);
+}
+//#endregion
+//#region src/model/define.ts
+function defineModel(table, config) {
+	const def = {
+		table,
+		columns: config.columns,
+		relations: config.relations ?? {},
+		name: table,
+		_orm: null,
+		query() {
+			if (!this._orm) throw new ModelNotRegisteredError(this.name);
+			return createQueryBuilder(this);
+		},
+		async find(id) {
+			return this.query().find(id);
+		},
+		async findOrFail(id) {
+			return this.query().findOrFail(id);
+		},
+		async first() {
+			return this.query().first();
+		},
+		async create(data) {
+			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertModel(def, data);
+		},
+		async insert(data) {
+			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertModel(def, data);
+		},
+		async insertMany(dataArray) {
+			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertManyModel(def, dataArray);
+		},
+		async update(id, data) {
+			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).updateModel(def, id, data);
+		},
+		async insertGraph(data, options) {
+			return (await Promise.resolve().then(() => graph_exports)).insertGraph(def, data, options);
+		},
+		async upsertGraph(data, options) {
+			return (await Promise.resolve().then(() => graph_exports)).upsertGraph(def, data, options);
+		},
+		async delete(id) {
+			const model = await this.findOrFail(id);
+			await (await Promise.resolve().then(() => delete_exports)).deleteModel(def, model);
+		},
+		hydrate(row) {
+			return createInstance(def, config, row, true);
+		},
+		on(event, callback) {
+			return getHooksFor(def).on(event, callback);
+		},
+		use(plugin) {
+			plugin(def);
+			return def;
+		},
+		makeHelper(fn) {
+			return (...args) => {
+				return fn(def.query(), ...args);
+			};
+		},
+		getHooks() {
+			return getHooksFor(def);
+		},
+		addGlobalScope(name, callback) {
+			addScope(def, name, callback);
+		},
+		removeGlobalScope(name) {
+			removeScope(def, name);
+		},
+		getGlobalScopes() {
+			return getScopes(def);
+		},
+		beforeDelete(callback) {
+			return addStaticHook(def, "beforeDelete", callback);
+		},
+		afterDelete(callback) {
+			return addStaticHook(def, "afterDelete", callback);
+		},
+		beforeUpdate(callback) {
+			return addStaticHook(def, "beforeUpdate", callback);
+		},
+		afterUpdate(callback) {
+			return addStaticHook(def, "afterUpdate", callback);
+		},
+		beforeCreate(callback) {
+			return addStaticHook(def, "beforeCreate", callback);
+		},
+		afterCreate(callback) {
+			return addStaticHook(def, "afterCreate", callback);
+		},
+		beforeFind(callback) {
+			return addStaticHook(def, "beforeFind", callback);
+		},
+		afterFind(callback) {
+			return addStaticHook(def, "afterFind", callback);
+		},
+		_init(orm) {
+			def._orm = orm;
+			setConfig$1(def, config);
+			Promise.resolve().then(() => serialize_exports).then((mod) => mod.setConfig?.(def, config));
+		}
+	};
+	setConfig$1(def, config);
+	Promise.resolve().then(() => serialize_exports).then((mod) => mod.setConfig?.(def, config));
+	if (config.computed) Promise.resolve().then(() => computed_exports).then((mod) => mod.setComputedConfig?.(def, config.computed));
+	def.registerTimestamps = (createdAtCol, updatedAtCol) => {
+		registerTimestampsFor(def, createdAtCol, updatedAtCol);
+	};
+	def.registerSoftDeletes = (deletedAtCol) => {
+		registerSoftDeletesFor(def, deletedAtCol);
+	};
+	def.discover = async () => {
+		throw new Error("discover() not yet implemented in v2");
+	};
+	return def;
+}
+//#endregion
+//#region src/model/attribute.ts
+/**
+* Defines an accessor (`get`) and/or mutator (`set`) for a model attribute.
+*
+* ### Accessor (get)
+* Transforms the attribute value when read via `model.get()` or `model.$toJSON()`.
+* Receives the casted value and the model instance.
+*
+* ### Mutator (set)
+* Transforms the attribute value when written via `model.set()`, `model.fill()`,
+* or during model creation (`Model.insert()` / `Model.create()`).
+* Receives the raw input value and the model instance, returns the value to store.
+* Applied **before** type casting.
+*
+* ### Usage
+* ```ts
+* defineModel('users', {
+*   columns: { id, name, password, ... },
+*   attributes: {
+*     password: Attribute.make({
+*       set: (value) => Bun.password.hashSync(value, { algorithm: 'bcrypt' }),
+*       get: () => '***',
+*     }),
+*     fullName: Attribute.make({
+*       get: (_, instance) => `${instance.get('firstName')} ${instance.get('lastName')}`,
+*     }),
+*   },
+* })
+* ```
+*/
+var Attribute = class Attribute {
+	get;
+	set;
+	constructor(get, set) {
+		this.get = get;
+		this.set = set;
+	}
+	static make(config) {
+		if (!config.get && !config.set) throw new Error("Attribute.make() requires at least one of `get` or `set`");
+		return new Attribute(config.get, config.set);
+	}
+};
+//#endregion
+//#region src/model/computed.ts
+var computed_exports = /* @__PURE__ */ __exportAll({
+	applyComputedColumnsAsync: () => applyComputedColumnsAsync,
+	getComputedConfig: () => getComputedConfig,
+	setComputedConfig: () => setComputedConfig
+});
+const computedConfigs = /* @__PURE__ */ new WeakMap();
+function setComputedConfig(def, config) {
+	computedConfigs.set(def, config);
+}
+function getComputedConfig(def) {
+	return computedConfigs.get(def);
+}
+/**
+* Apply computed columns to a set of loaded records.
+* Handles SQL, runtime, and batch computed columns.
+*/
+/** Resolve a ComputedConfig entry (lazy function or plain object). */
+function resolveComputedColumn(entry) {
+	return typeof entry === "function" ? entry() : entry;
+}
+/**
+* Apply computed columns and return a promise (for async batch computes).
+*/
+async function applyComputedColumnsAsync(records, computedConfig, selectedColumns) {
+	if (records.length === 0) return;
+	const relevant = Object.entries(computedConfig).filter(([name]) => !selectedColumns || selectedColumns.includes(name));
+	const batchDefs = relevant.filter(([, c]) => resolveComputedColumn(c).type === "batch");
+	for (const [name, col] of batchDefs) if (col.batchCompute) {
+		const values = await col.batchCompute(records);
+		for (let i = 0; i < records.length && i < values.length; i++) records[i].set(name, values[i]);
+	}
+	for (const record of records) for (const [name, c] of relevant) {
+		const col = resolveComputedColumn(c);
+		if (col.type === "runtime" && col.compute) record.set(name, col.compute(record));
+	}
+}
+//#endregion
+//#region src/model/delete.ts
+var delete_exports = /* @__PURE__ */ __exportAll({
+	deleteModel: () => deleteModel,
+	forceDeleteModel: () => forceDeleteModel,
+	restoreModel: () => restoreModel,
+	trashedModel: () => trashedModel
+});
+function getTable(def) {
+	return def.table;
+}
+function getDb(def) {
+	if (!def._orm) throw new ModelNotRegisteredError(def.name);
+	return def._orm.kysely;
+}
+function getPrimaryKeyColumn$1(def) {
+	const cols = def.columns;
+	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
+	return "id";
+}
+async function deleteModel(def, model) {
+	const pk = getPrimaryKeyColumn$1(def);
+	const pkValue = model.get(pk);
+	if (pkValue == null) throw new DatabaseError("Cannot delete model without primary key", "MISSING_ID");
+	const hm = getHooksFor(def);
+	if (hasSoftDelete(def)) {
+		await hm.trigger("beforeDelete", model);
+		const config = getSoftDeleteConfig(def);
+		const db = getDb(def);
+		try {
+			await db.updateTable(getTable(def)).set({ [config.column]: (/* @__PURE__ */ new Date()).toISOString() }).where(pk, "=", pkValue).execute();
+		} catch (e) {
+			throw normalizeError(e, getTable(def));
+		}
+		model.set(config.column, (/* @__PURE__ */ new Date()).toISOString());
+		await hm.trigger("afterDelete", model);
+	} else {
+		await hm.trigger("beforeDelete", model);
+		const db = getDb(def);
+		try {
+			await db.deleteFrom(getTable(def)).where(pk, "=", pkValue).execute();
+		} catch (e) {
+			throw normalizeError(e, getTable(def));
+		}
+		setExists(model, false);
+		await hm.trigger("afterDelete", model);
+	}
+}
+async function forceDeleteModel(def, model) {
+	const pk = getPrimaryKeyColumn$1(def);
+	const pkValue = model.get(pk);
+	if (pkValue == null) throw new DatabaseError("Cannot delete model without primary key", "MISSING_ID");
+	const hm = getHooksFor(def);
+	await hm.trigger("beforeForceDelete", model);
+	const db = getDb(def);
+	try {
+		await db.deleteFrom(getTable(def)).where(pk, "=", pkValue).execute();
+	} catch (e) {
+		throw normalizeError(e, getTable(def));
+	}
+	setExists(model, false);
+	await hm.trigger("afterForceDelete", model);
+}
+async function restoreModel(def, model) {
+	const pk = getPrimaryKeyColumn$1(def);
+	const pkValue = model.get(pk);
+	if (pkValue == null) return;
+	if (!hasSoftDelete(def)) return;
+	const hm = getHooksFor(def);
+	await hm.trigger("beforeRestore", model);
+	const config = getSoftDeleteConfig(def);
+	const db = getDb(def);
+	try {
+		await db.updateTable(getTable(def)).set({ [config.column]: null }).where(pk, "=", pkValue).execute();
+	} catch (e) {
+		throw normalizeError(e, getTable(def));
+	}
+	model.set(config.column, null);
+	setExists(model, true);
+	await hm.trigger("afterRestore", model);
+}
+function trashedModel(def, model) {
+	if (!hasSoftDelete(def)) return false;
+	const config = getSoftDeleteConfig(def);
+	return model.get(config.column) != null;
+}
+//#endregion
+//#region src/model/relation.ts
+var relation_exports = /* @__PURE__ */ __exportAll({
+	getModelDef: () => getModelDef,
+	loadModelRelations: () => loadModelRelations
+});
+const modelDefs = /* @__PURE__ */ new WeakMap();
+function getModelDef(instance) {
+	return modelDefs.get(instance);
+}
+async function loadModelRelations(model, def, ...relations) {
+	const { EagerLoader } = await Promise.resolve().then(() => eager_exports);
+	const loader = new EagerLoader();
+	for (const rel of relations) await loader.loadRelatedForModel(model, rel, def);
+}
+//#endregion
+//#region src/model/serialize.ts
+var serialize_exports = /* @__PURE__ */ __exportAll({
+	getConfig: () => getConfig,
+	modelToJSON: () => modelToJSON,
+	setConfig: () => setConfig
+});
+const VISITED = /* @__PURE__ */ new WeakSet();
+/** Type guard: checks if a value looks like a SerializableModel. */
+function isSerializableModel(value) {
+	return value !== null && typeof value === "object" && typeof value.$toJSON === "function";
+}
+function modelToJSON(def, model) {
+	const config = getConfig$1(def) ?? getConfig(def);
+	const state = getState(model);
+	const result = {};
+	const attributes = state.attributes;
+	const hidden = config?.hidden ?? [];
+	const visible = config?.visible;
+	const appends = config?.appends ?? [];
+	const casts = config?.casts ?? {};
+	const keys = visible && visible.length > 0 ? visible : Object.keys(attributes);
+	for (const key of keys) {
+		if (hidden.includes(key)) continue;
+		if (key in attributes) {
+			let value = attributes[key];
+			if (casts[key]) value = castValue(value, casts[key]);
+			const attrDef = config?.attributes?.[key];
+			if (attrDef?.get) value = attrDef.get(value, model);
+			result[key] = value;
+		}
+	}
+	const relations = getRawRelations(model);
+	for (const [relName, relValue] of Object.entries(relations)) {
+		if (hidden.includes(relName)) continue;
+		if (visible && visible.length > 0 && !visible.includes(relName)) continue;
+		if (Array.isArray(relValue)) result[relName] = relValue.map((item) => {
+			if (isSerializableModel(item)) {
+				if (VISITED.has(item)) return { id: item.get("id") };
+				VISITED.add(item);
+				const json = item.$toJSON();
+				VISITED.delete(item);
+				return json;
+			}
+			return item;
+		});
+		else if (isSerializableModel(relValue)) if (VISITED.has(relValue)) result[relName] = { id: relValue.get("id") };
+		else {
+			VISITED.add(relValue);
+			result[relName] = relValue.$toJSON();
+			VISITED.delete(relValue);
+		}
+		else if (relValue != null) result[relName] = relValue;
+	}
+	for (const append of appends) if (!(append in result)) {
+		const fn = model[`get${append.charAt(0).toUpperCase()}${append.slice(1)}Attribute`];
+		if (typeof fn === "function") result[append] = fn.call(model);
+	}
+	return result;
+}
+const configMap = /* @__PURE__ */ new WeakMap();
+function setConfig(def, config) {
+	configMap.set(def, config);
+}
+function getConfig(def) {
+	return configMap.get(def);
+}
+//#endregion
+//#region src/relations/related-query.ts
+/**
+* Create a RelationQuery — a QueryBuilder scoped to a relation, with
+* additional methods for managing many-to-many pivot tables.
+*/
+function createRelationQuery(instance, def, relationName) {
+	const relation = def.relations[relationName];
+	if (!relation) throw new RelationNotFoundError(def.name, relationName);
+	const relatedDef = relation.relatedModelClass;
+	const qb = createQueryBuilder(relatedDef);
+	if (relation.type === "belongsTo") {
+		const fkValue = instance.get(relation.foreignKey);
+		if (fkValue != null) qb.where(relation.localKey, "=", fkValue);
+		else qb.where(relation.localKey, "=", -1);
+	} else if (relation.type === "manyToMany") {
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue != null && relation.throughTable && relation.foreignPivotKey && relation.relatedPivotKey) {
+			const relatedPk = Object.keys(relatedDef.columns).find((k) => relatedDef.columns[k]?.isPrimaryKey) ?? "id";
+			const t = relation.throughTable;
+			const rpk = relation.relatedPivotKey;
+			const fpk = relation.foreignPivotKey;
+			const newQb = qb._getKyselyQb().where(sql`${sql.id(relatedPk)} IN (SELECT ${sql.id(rpk)} FROM ${sql.id(t)} WHERE ${sql.id(fpk)} = ${pkValue})`);
+			qb._replaceKyselyQb(newQb);
+		} else qb.where(relation.localKey, "=", -1);
+	} else {
+		const fkValue = instance.get(relation.localKey);
+		if (fkValue != null) qb.where(relation.foreignKey, "=", fkValue);
+		else qb.where(relation.foreignKey, "=", -1);
+	}
+	const rqb = Object.create(qb);
+	for (const key of Object.keys(qb)) if (typeof qb[key] === "function") {
+		const fn = qb[key];
+		rqb[key] = (...args) => {
+			const result = fn.apply(qb, args);
+			return result === qb ? rqb : result;
+		};
+	}
+	const pivotRelation = relation;
+	function getPivotInfo() {
+		if (pivotRelation.type !== "manyToMany" || !pivotRelation.throughTable) throw new Error(`attach/detach/sync are only available on manyToMany relations, got "${pivotRelation.type}"`);
+		return {
+			throughTable: pivotRelation.throughTable,
+			foreignPivotKey: pivotRelation.foreignPivotKey ?? "",
+			relatedPivotKey: pivotRelation.relatedPivotKey ?? ""
+		};
+	}
+	rqb.attach = async (ids, pivotData) => {
+		const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo();
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) return;
+		const idsArr = Array.isArray(ids) ? ids : [ids];
+		const _db = relatedDef._orm?.kysely;
+		if (!_db) throw new Error("Model not registered");
+		const qdb = _db;
+		for (const id of idsArr) {
+			const row = {
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: id,
+				...pivotData
+			};
+			try {
+				await qdb.insertInto(throughTable).values(row).execute();
+			} catch (e) {
+				const err = e;
+				if (!(err.code === "SQLITE_CONSTRAINT_UNIQUE" || err.code === "SQLITE_CONSTRAINT" || err.code === "23505" || err.code === "ER_DUP_ENTRY" || err.errno === 1062)) throw e;
+			}
+		}
+	};
+	rqb.detach = async (ids) => {
+		const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo();
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) return;
+		const _db = relatedDef._orm?.kysely;
+		if (!_db) throw new Error("Model not registered");
+		let query = _db.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue);
+		if (ids !== void 0) {
+			const idsArr = Array.isArray(ids) ? ids : [ids];
+			query = query.where(relatedPivotKey, "in", idsArr);
+		}
+		await query.execute();
+	};
+	rqb.sync = async (ids) => {
+		const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo();
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) return;
+		const _db = relatedDef._orm?.kysely;
+		if (!_db) throw new Error("Model not registered");
+		const qdb = _db;
+		const desiredIds = Array.isArray(ids) ? ids : Object.keys(ids).map(Number);
+		const currentRows = await qdb.selectFrom(throughTable).select(relatedPivotKey).where(foreignPivotKey, "=", pkValue).execute();
+		const currentIds = new Set(currentRows.map((r) => r[relatedPivotKey]));
+		const toAttach = desiredIds.filter((id) => !currentIds.has(id));
+		const toDetach = [...currentIds].filter((id) => (typeof id === "string" || typeof id === "number") && !desiredIds.includes(id));
+		const ops = [];
+		if (toDetach.length > 0) ops.push(qdb.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "in", toDetach).execute());
+		for (const id of toAttach) {
+			const pivotRow = {
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: id
+			};
+			if (!Array.isArray(ids) && typeof ids === "object") {
+				const entry = ids[String(id)];
+				if (entry) Object.assign(pivotRow, entry);
+			}
+			ops.push(qdb.insertInto(throughTable).values(pivotRow).execute());
+		}
+		await Promise.all(ops);
+	};
+	rqb.syncWithoutDetaching = async (ids) => {
+		const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo();
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) return;
+		const _db = relatedDef._orm?.kysely;
+		if (!_db) throw new Error("Model not registered");
+		const qdb = _db;
+		const idsArr = Array.isArray(ids) ? ids : [ids];
+		for (const id of idsArr) {
+			const row = {
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: id
+			};
+			try {
+				await qdb.insertInto(throughTable).values(row).execute();
+			} catch (e) {
+				const err = e;
+				if (!(err.code === "SQLITE_CONSTRAINT_UNIQUE" || err.code === "SQLITE_CONSTRAINT" || err.code === "23505" || err.code === "ER_DUP_ENTRY" || err.errno === 1062)) throw e;
+			}
+		}
+	};
+	rqb.updateExistingPivot = async (id, data) => {
+		const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo();
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) return;
+		const _db = relatedDef._orm?.kysely;
+		if (!_db) throw new Error("Model not registered");
+		await _db.updateTable(throughTable).set(data).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "=", id).execute();
+	};
+	return rqb;
+}
+//#endregion
+//#region src/model/index.ts
+initRuntime({
+	saveModel,
+	deleteModel,
+	forceDeleteModel,
+	restoreModel,
+	trashedModel,
+	reloadModel,
+	modelToJSON,
+	loadModelRelations,
+	createRelationQuery
+});
+//#endregion
+//#region src/orm/index.ts
+/**
+* Create an ORM instance — the central registry that wires Kysely to model definitions.
+* Replaces createPeta() from v0.x.
+*/
+function createORM(config) {
+	const kysely = new Kysely({ dialect: config.dialect });
+	const modelMap = /* @__PURE__ */ new Map();
+	const orm = {
+		kysely,
+		register(model) {
+			model._init(orm);
+			modelMap.set(model.name, model);
+		},
+		registerAll(...models) {
+			const flat = models.flat();
+			for (const model of flat) {
+				if (!model.table) continue;
+				this.register(model);
+			}
+		},
+		async destroy() {
+			await kysely.destroy();
+		},
+		async transaction(fn) {
+			return kysely.transaction().execute((trx) => fn(trx));
+		},
+		get models() {
+			return modelMap;
+		},
+		getModel(name) {
+			return modelMap.get(name);
+		}
+	};
+	if (config.models) for (const [_name, model] of Object.entries(config.models)) orm.register(model);
+	return orm;
+}
+//#endregion
+//#region src/pagination/index.ts
+var pagination_exports = /* @__PURE__ */ __exportAll({ createPaginator: () => createPaginator });
+function createPaginator(items, total, perPage, currentPage) {
+	const collection = createCollection(items);
+	const lastPage = Math.max(1, Math.ceil(total / perPage));
+	return {
+		get data() {
+			return collection;
+		},
+		get total() {
+			return total;
+		},
+		get perPage() {
+			return perPage;
+		},
+		get currentPage() {
+			return currentPage;
+		},
+		get lastPage() {
+			return lastPage;
+		},
+		get hasMorePages() {
+			return currentPage < lastPage;
+		},
+		get hasPages() {
+			return lastPage > 1;
+		},
+		get firstItem() {
+			return items.length > 0 ? (currentPage - 1) * perPage + 1 : 0;
+		},
+		get lastItem() {
+			return items.length > 0 ? (currentPage - 1) * perPage + items.length : 0;
+		},
+		get onFirstPage() {
+			return currentPage === 1;
+		},
+		get onLastPage() {
+			return currentPage >= lastPage;
+		},
+		get count() {
+			return items.length;
+		},
+		map(fn) {
+			return items.map(fn);
+		},
+		toJSON() {
+			return {
+				data: collection.toJSON(),
+				total,
+				perPage,
+				currentPage,
+				lastPage,
+				hasMorePages: currentPage < lastPage,
+				hasPages: lastPage > 1,
+				firstItem: items.length > 0 ? (currentPage - 1) * perPage + 1 : null,
+				lastItem: items.length > 0 ? (currentPage - 1) * perPage + items.length : null,
+				onFirstPage: currentPage === 1,
+				onLastPage: currentPage >= lastPage
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugins/soft-deletes.ts
+let _hooksMod = null;
+async function getHooksMod() {
+	if (!_hooksMod) _hooksMod = await import("./hooks-BD0xy7uw.mjs").then((n) => n.i);
+	return _hooksMod;
+}
+/**
+* Plugin that enables soft-delete behavior on a model.
+* Sets `deletedAt` on delete, automatically filters out deleted records.
+*
+* ```ts
+* const User = defineModel('users', {
+*   columns: { deletedAt: t.timestamp().nullable() }
+* }).use(softDeletes())
+* ```
+*/
+function softDeletes(opts) {
+	const column = opts?.column ?? "deletedAt";
+	return (def) => {
+		getHooksMod().then((mod) => mod.registerSoftDeletesFor(def, column));
+		def.on("beforeDelete", async (model) => {
+			const pk = getPrimaryKeyColumn(def);
+			const pkValue = model.get(pk);
+			if (pkValue == null) return;
+			const db = def._orm?.kysely;
+			if (!db) return;
+			try {
+				await db.updateTable(def.table).set({ [column]: (/* @__PURE__ */ new Date()).toISOString() }).where(pk, "=", pkValue).execute();
+			} catch {}
+		});
+	};
+}
+function getPrimaryKeyColumn(def) {
+	const cols = def.columns;
+	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
+	return "id";
+}
+//#endregion
+//#region src/plugins/timestamps.ts
+/**
+* Plugin that automatically sets `createdAt` and `updatedAt` timestamps.
+*
+* ```ts
+* const User = defineModel('users', { columns: { ...t.timestamps() } })
+*   .use(timestamps())
+* ```
+*/
+function timestamps(opts) {
+	const createdAtCol = opts?.createdAt ?? "createdAt";
+	const updatedAtCol = opts?.updatedAt ?? "updatedAt";
+	return (def) => {
+		def.on("beforeCreate", (model) => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			if (!model.get(createdAtCol)) model.set(createdAtCol, now);
+			model.set(updatedAtCol, now);
+		});
+		def.on("beforeUpdate", (model) => {
+			model.set(updatedAtCol, (/* @__PURE__ */ new Date()).toISOString());
+		});
+	};
+}
+//#endregion
+//#region src/plugins/ulid.ts
+/**
+* Plugin that auto-generates ULID primary keys on `beforeCreate`.
+*
+* Requires the model's `id` column to be `t.string(26).primaryKey()`.
+*
+* @example
+* ```ts
+* const User = defineModel("users", {
+*   columns: { id: t.string(26).primaryKey() }
+* }).use(ulid())
+* ```
+*/
+function ulid() {
+	return (def) => {
+		def.on("beforeCreate", (model) => {
+			if (!model.get("id")) model.set("id", ulid$1());
+		});
+	};
+}
+//#endregion
+//#region src/relations/has-many.ts
+const THUNK_CACHE$2 = /* @__PURE__ */ new WeakMap();
+function resolveThunk$2(thunk) {
+	let cls = THUNK_CACHE$2.get(thunk);
+	if (!cls) {
+		cls = thunk();
+		THUNK_CACHE$2.set(thunk, cls);
+	}
+	return cls;
+}
+function guessForeignKey(modelDef) {
+	const table = modelDef.table;
+	return `${table.endsWith("s") ? table.slice(0, -1) : table}Id`;
+}
+function groupByArray$1(items, key) {
+	const result = {};
+	for (const item of items) {
+		const v = item.get(key);
+		if (v == null) continue;
+		const k = String(v);
+		if (!result[k]) result[k] = [];
+		result[k].push(item);
+	}
+	return result;
+}
+function hasMany(relatedThunk, options = {}) {
+	let _related;
+	function getRelated() {
+		if (!_related) _related = resolveThunk$2(relatedThunk) ?? void 0;
+		if (!_related) throw new Error(`Cannot resolve hasMany relation — related model not found`);
+		return _related;
+	}
+	const foreignKey = options.foreignKey ?? "";
+	const localKey = options.localKey ?? "id";
+	return {
+		type: "hasMany",
+		get relatedModelClass() {
+			return getRelated();
+		},
+		foreignKey,
+		localKey,
+		get throughTable() {},
+		get foreignPivotKey() {},
+		get relatedPivotKey() {},
+		get throughForeignKey() {},
+		get throughLocalKey() {},
+		query(parent) {
+			const qb = createQueryBuilder(getRelated());
+			const fkValue = parent.get(localKey);
+			if (fkValue != null) qb.where(foreignKey, "=", fkValue);
+			else qb.where(foreignKey, "=", -1);
+			return qb;
+		},
+		addEagerConstraints(qb, models) {
+			const ids = models.map((m) => m.get(localKey)).filter((id) => id != null);
+			if (ids.length > 0) qb.whereIn(foreignKey, ids);
+			else qb.where(foreignKey, "=", -1);
+		},
+		match(models, results, relationName) {
+			const grouped = groupByArray$1(results, foreignKey);
+			for (const model of models) {
+				const key = String(model.get(localKey));
+				model.$setRelation(relationName, grouped[key] ?? []);
+			}
+		},
+		async getResults(parent) {
+			return this.query(parent).execute();
+		},
+		async loadEager(models, relationName, constraints) {
+			const rel = getRelated();
+			if (models.length === 0) return;
+			const qb = createQueryBuilder(rel);
+			this.addEagerConstraints(qb, models);
+			if (constraints) constraints(qb);
+			const results = await qb.execute();
+			this.match(models, results, relationName);
+		}
+	};
+}
+function hasOne(relatedThunk, options = {}) {
+	const base = hasMany(relatedThunk, options);
+	const result = {};
+	for (const key of Object.keys(base)) Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(base, key));
+	result.match = function match(models, results, relationName) {
+		const grouped = groupByArray$1(results, base.foreignKey);
+		for (const model of models) {
+			const key = String(model.get(base.localKey));
+			model.$setRelation(relationName, (grouped[key] ?? [])[0] ?? null);
+		}
+	};
+	result.getResults = async function getResults(parent) {
+		return (await base.getResults(parent))[0] ?? null;
+	};
+	return result;
+}
+function belongsTo(relatedThunk, options = {}) {
+	const related = resolveThunk$2(relatedThunk);
+	const foreignKey = options.foreignKey ?? guessForeignKey(related);
+	const localKey = options.localKey ?? "id";
+	return {
+		type: "belongsTo",
+		relatedModelClass: related,
+		foreignKey,
+		localKey,
+		get throughTable() {},
+		get foreignPivotKey() {},
+		get relatedPivotKey() {},
+		get throughForeignKey() {},
+		get throughLocalKey() {},
+		query(parent) {
+			const qb = createQueryBuilder(related);
+			const fkValue = parent.get(foreignKey);
+			if (fkValue != null) qb.where(localKey, "=", fkValue);
+			else qb.where(localKey, "=", -1);
+			return qb;
+		},
+		addEagerConstraints(qb, models) {
+			const ids = models.map((m) => m.get(foreignKey)).filter((id) => id != null);
+			if (ids.length > 0) qb.whereIn(localKey, ids);
+			else qb.where(localKey, "=", -1);
+		},
+		match(models, results, relationName) {
+			const keyed = Object.fromEntries(results.map((r) => [String(r.get(localKey)), r]));
+			for (const model of models) {
+				const fkValue = model.get(foreignKey);
+				model.$setRelation(relationName, fkValue != null ? keyed[String(fkValue)] ?? null : null);
+			}
+		},
+		async getResults(parent) {
+			return (await this.query(parent).execute())[0] ?? null;
+		},
+		async loadEager(models, relationName, constraints) {
+			if (models.length === 0) return;
+			const qb = createQueryBuilder(related);
+			this.addEagerConstraints(qb, models);
+			if (constraints) constraints(qb);
+			const results = await qb.execute();
+			this.match(models, results, relationName);
+		}
+	};
+}
+//#endregion
+//#region src/relations/many-to-many.ts
+const THUNK_CACHE$1 = /* @__PURE__ */ new WeakMap();
+/** Stores pivot data for many-to-many relation results (instead of attaching to the model). */
+const pivotData = /* @__PURE__ */ new WeakMap();
+function resolveThunk$1(thunk) {
+	let cls = THUNK_CACHE$1.get(thunk);
+	if (!cls) {
+		cls = thunk();
+		THUNK_CACHE$1.set(thunk, cls);
+	}
+	return cls;
+}
+function snakeCase(str) {
+	return str.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`).replace(/^_/, "");
+}
+function manyToMany(relatedThunk, options) {
+	let _related;
+	function getRelated() {
+		if (!_related) _related = resolveThunk$1(relatedThunk) ?? void 0;
+		if (!_related) throw new Error(`Cannot resolve manyToMany relation — related model not found`);
+		return _related;
+	}
+	const localKey = options.localKey ?? "id";
+	const throughTable = options.through ?? "";
+	let _table;
+	try {
+		_table = getRelated().table;
+	} catch {}
+	const foreignKey = options.foreignKey ?? (_table ? `${snakeCase(_table)}Id` : "");
+	const foreignPivotKey = options.foreignPivotKey ?? (_table ? `${snakeCase(_table)}Id` : "");
+	const relatedPivotKey = options.relatedPivotKey ?? (_table ? `${snakeCase(_table)}Id` : "");
+	const pivotExtras = options.pivotExtras ?? [];
+	return {
+		type: "manyToMany",
+		get relatedModelClass() {
+			return getRelated();
+		},
+		foreignKey,
+		localKey,
+		throughTable,
+		foreignPivotKey,
+		relatedPivotKey,
+		get throughForeignKey() {},
+		get throughLocalKey() {},
+		query(parent) {
+			const rel = getRelated();
+			const pkValue = parent.get(localKey);
+			const qb = createQueryBuilder(rel);
+			if (pkValue == null) {
+				qb.where(localKey, "=", -1);
+				return qb;
+			}
+			qb.innerJoin(throughTable, `${rel.table}.${localKey}`, `${throughTable}.${relatedPivotKey}`);
+			qb.where(`${throughTable}.${foreignPivotKey}`, "=", pkValue);
+			return qb;
+		},
+		addEagerConstraints(_query, _models) {},
+		match(models, results, relationName) {
+			const grouped = {};
+			for (const model of models) {
+				const key = String(model.get(localKey));
+				grouped[key] = [];
+			}
+			for (const result of results) {
+				const pivot = pivotData.get(result);
+				if (pivot) {
+					const key = String(pivot[foreignPivotKey]);
+					if (grouped[key]) grouped[key].push(result);
+				}
+			}
+			for (const model of models) {
+				const key = String(model.get(localKey));
+				model.$setRelation(relationName, grouped[key] ?? []);
+			}
+		},
+		async getResults(parent) {
+			return this.query(parent).execute();
+		},
+		async loadEager(models, relationName, constraints) {
+			const rel = getRelated();
+			if (models.length === 0) return;
+			const ids = models.map((m) => m.get(localKey)).filter((id) => id != null);
+			if (ids.length === 0) return;
+			const qb = createQueryBuilder(rel);
+			qb.innerJoin(throughTable, `${rel.table}.${localKey}`, `${throughTable}.${relatedPivotKey}`);
+			qb.where(`${throughTable}.${foreignPivotKey}`, "in", ids);
+			const selectCols = [`${rel.table}.*`];
+			if (pivotExtras.length > 0) for (const extra of pivotExtras) selectCols.push(`${throughTable}.${extra}`);
+			selectCols.push(`${throughTable}.${foreignPivotKey}`);
+			qb.select(...selectCols);
+			if (constraints) constraints(qb);
+			const results = await qb.execute();
+			for (const result of results) {
+				const pivot = {};
+				const col = `${foreignPivotKey}`;
+				pivot[foreignPivotKey] = result.get(col);
+				for (const extra of pivotExtras) pivot[extra] = result.get(extra);
+				pivotData.set(result, pivot);
+			}
+			this.match(models, results, relationName);
+		}
+	};
+}
+function hasManyThrough(relatedThunk, throughThunk, options = {}) {
+	const related = resolveThunk$1(relatedThunk);
+	const through = resolveThunk$1(throughThunk);
+	const foreignKey = options.foreignKey ?? `${snakeCase(through.table)}Id`;
+	const localKey = options.localKey ?? "id";
+	const throughForeignKey = options.throughForeignKey ?? `${snakeCase(resolveThunk$1(relatedThunk).table)}Id`;
+	const throughLocalKey = options.throughLocalKey ?? "id";
+	return {
+		type: "hasManyThrough",
+		relatedModelClass: related,
+		foreignKey,
+		localKey,
+		throughTable: through.table,
+		throughForeignKey,
+		throughLocalKey,
+		get foreignPivotKey() {},
+		get relatedPivotKey() {},
+		query(parent) {
+			const pkValue = parent.get(localKey);
+			const qb = createQueryBuilder(related);
+			if (pkValue == null) {
+				qb.where(localKey, "=", -1);
+				return qb;
+			}
+			qb.innerJoin(through.table, `${through.table}.${throughLocalKey}`, `${related.table}.${throughForeignKey}`);
+			qb.where(`${through.table}.${foreignKey}`, "=", pkValue);
+			return qb;
+		},
+		addEagerConstraints(query, models) {
+			const ids = models.map((m) => m.get(localKey)).filter((id) => id != null);
+			if (ids.length > 0) {
+				query.innerJoin(through.table, `${through.table}.${throughLocalKey}`, `${related.table}.${throughForeignKey}`);
+				query.where(`${through.table}.${foreignKey}`, "in", ids);
+			}
+		},
+		match(models, results, relationName) {
+			const grouped = {};
+			for (const result of results) {
+				const fkValue = result.get(throughForeignKey);
+				if (fkValue == null) continue;
+				const key = String(fkValue);
+				if (!grouped[key]) grouped[key] = [];
+				grouped[key].push(result);
+			}
+			for (const model of models) {
+				const key = String(model.get(localKey));
+				model.$setRelation(relationName, grouped[key] ?? []);
+			}
+		},
+		async getResults(parent) {
+			return this.query(parent).execute();
+		},
+		async loadEager(models, relationName, constraints) {
+			if (models.length === 0) return;
+			const qb = createQueryBuilder(related);
+			this.addEagerConstraints(qb, models);
+			if (constraints) constraints(qb);
+			const results = await qb.execute();
+			this.match(models, results, relationName);
+		}
+	};
+}
+//#endregion
+//#region src/relations/morph.ts
+function groupByArray(items, key) {
+	const result = {};
+	for (const item of items) {
+		const v = item.get(key);
+		if (v == null) continue;
+		const k = String(v);
+		if (!result[k]) result[k] = [];
+		result[k].push(item);
+	}
+	return result;
+}
+const THUNK_CACHE = /* @__PURE__ */ new WeakMap();
+function resolveThunk(thunk) {
+	let cls = THUNK_CACHE.get(thunk);
+	if (!cls) {
+		cls = thunk();
+		THUNK_CACHE.set(thunk, cls);
+	}
+	return cls;
+}
+/**
+* Resolve the related model for a MorphTo relation given a parent instance.
+* Looks up the parent's `{name}Type` column value in the relation's morphMap
+* and returns the corresponding ModelDefinition.
+*
+* Returns `undefined` if the type column is null, the morph map entry is
+* missing, or the relation is not a morphTo.
+*/
+function resolveMorphRelation(relation, parent) {
+	const morphMap = relation._morphMap;
+	const morphType = relation._morphType;
+	if (!morphMap || !morphType) return void 0;
+	const typeValue = parent.get(morphType);
+	if (!typeValue) return void 0;
+	const thunk = morphMap[typeValue];
+	return thunk ? resolveThunk(thunk) : void 0;
+}
+/**
+* Define a polymorphic belongsTo relationship.
+*
+* Requires a `morphMap` to resolve the related model class at runtime
+* based on the value of the type column.
+*
+* ### Usage
+* ```ts
+* Comment.relations.commentable = defineMorphTo({
+*   name: "commentable",
+*   morphMap: {
+*     posts: () => Post,
+*     videos: () => Video,
+*   },
+* })
+* ```
+*
+* Eager loading groups parents by type and issues one query per type:
+* ```ts
+* const comments = await Comment.query().with("commentable")
+* // → SELECT * FROM comments
+* // → SELECT * FROM posts WHERE id IN (...)
+* // → SELECT * FROM videos WHERE id IN (...)
+* ```
+*/
+function defineMorphTo(options) {
+	const morphType = options.type ?? `${options.name}Type`;
+	const morphId = options.id ?? `${options.name}Id`;
+	const morphMap = options.morphMap ?? {};
+	const firstEntry = Object.entries(morphMap)[0];
+	return {
+		type: "belongsTo",
+		relatedModelClass: (firstEntry ? resolveThunk(firstEntry[1]) : null) ?? null,
+		foreignKey: morphId,
+		localKey: "id",
+		get throughTable() {},
+		get foreignPivotKey() {},
+		get relatedPivotKey() {},
+		get throughForeignKey() {},
+		get throughLocalKey() {},
+		_morphMap: morphMap,
+		_morphType: morphType,
+		_morphId: morphId,
+		/**
+		* Build a query for the related model.
+		* Throws if the type column is null/undefined or if no model is registered
+		* for the type value.
+		*/
+		query(parent) {
+			const typeValue = parent.get(morphType);
+			if (!typeValue) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphType}" is null on ${defName(parent)}`);
+			const thunk = morphMap[typeValue];
+			if (!thunk) throw new Error(`No model registered for morph type "${typeValue}" in morphTo "${options.name}". Available types: ${Object.keys(morphMap).join(", ") || "(none)"}`);
+			const relatedDef = resolveThunk(thunk);
+			const id = parent.get(morphId);
+			if (id == null) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphId}" is null on ${defName(parent)}`);
+			return relatedDef.query().where("id", "=", id);
+		},
+		addEagerConstraints(_query, _models) {},
+		match(_models, _results, _relationName) {},
+		async getResults(parent) {
+			return await this.query(parent).executeTakeFirst() ?? null;
+		},
+		async loadEager(models, relationName, constraints) {
+			if (models.length === 0) return;
+			const grouped = {};
+			const nullType = [];
+			for (const model of models) {
+				const typeValue = model.get(morphType);
+				if (typeValue) {
+					if (!grouped[typeValue]) grouped[typeValue] = [];
+					grouped[typeValue].push(model);
+				} else nullType.push(model);
+			}
+			for (const model of nullType) model.$setRelation(relationName, null);
+			for (const [typeValue, typeModels] of Object.entries(grouped)) {
+				const thunk = morphMap[typeValue];
+				if (!thunk) {
+					for (const model of typeModels) model.$setRelation(relationName, null);
+					continue;
+				}
+				const relatedDef = resolveThunk(thunk);
+				const ids = typeModels.map((m) => m.get(morphId)).filter((id) => id != null);
+				if (ids.length === 0) {
+					for (const model of typeModels) model.$setRelation(relationName, null);
+					continue;
+				}
+				const qb = relatedDef.query();
+				qb.whereIn("id", ids);
+				if (constraints) constraints(qb);
+				const results = await qb.execute();
+				const resultMap = /* @__PURE__ */ new Map();
+				for (const r of results) resultMap.set(r.get("id"), r);
+				for (const model of typeModels) model.$setRelation(relationName, resultMap.get(model.get(morphId)) ?? null);
+			}
+		}
+	};
+}
+/**
+* Define a polymorphic hasMany relationship.
+* The related table stores the parent's type and id.
+*/
+function defineMorphMany(options) {
+	const related = resolveThunk(options.related);
+	const morphType = options.type ?? `${options.name}Type`;
+	const morphId = options.id ?? `${options.name}Id`;
+	const typeValue = options.typeValue ?? related.table;
+	return {
+		type: "hasMany",
+		relatedModelClass: related,
+		foreignKey: morphId,
+		localKey: "id",
+		get throughTable() {},
+		get foreignPivotKey() {},
+		get relatedPivotKey() {},
+		get throughForeignKey() {},
+		get throughLocalKey() {},
+		_morphType: morphType,
+		_morphId: morphId,
+		_morphTypeValue: typeValue,
+		query(parent) {
+			const qb = createQueryBuilder(related);
+			qb.where(morphId, "=", parent.get("id"));
+			qb.where(morphType, "=", typeValue);
+			return qb;
+		},
+		addEagerConstraints(query, models) {
+			const ids = models.map((m) => m.get("id")).filter((id) => id != null);
+			if (ids.length > 0) {
+				query.whereIn(morphId, ids);
+				query.where(morphType, "=", typeValue);
+			}
+		},
+		match(models, results, relationName) {
+			const grouped = groupByArray(results, morphId);
+			for (const model of models) {
+				const key = String(model.get("id"));
+				model.$setRelation(relationName, grouped[key] ?? []);
+			}
+		},
+		async getResults(parent) {
+			return this.query(parent).execute();
+		},
+		async loadEager(models, relationName, constraints) {
+			if (models.length === 0) return;
+			const qb = createQueryBuilder(related);
+			this.addEagerConstraints(qb, models);
+			if (constraints) constraints(qb);
+			const results = await qb.execute();
+			this.match(models, results, relationName);
+		}
+	};
+}
+/**
+* Define a polymorphic hasOne relationship.
+*/
+function defineMorphOne(options) {
+	const base = defineMorphMany(options);
+	return {
+		...base,
+		type: "hasOne",
+		async getResults(parent) {
+			return (await base.getResults(parent))[0] ?? null;
+		},
+		match(models, results, relationName) {
+			const grouped = groupByArray(results, base.foreignKey);
+			for (const model of models) {
+				const related = grouped[String(model.get("id"))] ?? [];
+				model.$setRelation(relationName, related[0] ?? null);
+			}
+		}
+	};
+}
+function defName(instance) {
+	return instance.constructor?.name ?? "model";
+}
+//#endregion
+export { Attribute, DatabaseError, ModelNotFoundError, ModelNotRegisteredError, RelationNotAllowedError, RelationNotFoundError, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, eager_exports as i, manyToMany, relation_exports as n, normalizeError, delete_exports as r, resolveMorphRelation, softDeletes, t, timestamps, ulid };