@holo-js/db 0.1.4 → 0.1.5

package/dist/index.mjs

@@ -110,7 +110,7 @@ function redactBindings(bindings, policy) {
   if (policy.redactBindingsInLogs) {
     return limited.map(() => "[REDACTED]");
   }
-  return [...limited];
+  return limited;
 }
 function redactSql(sql, policy) {
   if (policy.debugSqlInLogs) {
@@ -278,13 +278,50 @@ function compareChunkValuesDescending(a, b) {
   return a < b ? 1 : -1;
 }
 
+// src/query/pagination.ts
+function assertPositiveInteger(value, kind, createError) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw createError(`${kind} must be a positive integer.`);
+  }
+}
+function normalizePaginationParameterName(value, fallback, createError) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  const trimmed = value.trim();
+  if (typeof value !== "string" || trimmed.length === 0) {
+    throw createError(
+      `${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`
+    );
+  }
+  return trimmed;
+}
+function encodeOffsetCursor(offset) {
+  return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
+}
+function decodeOffsetCursor(cursor, createError) {
+  if (cursor === null) {
+    return 0;
+  }
+  try {
+    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    const offset = decoded.offset;
+    if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
+      throw new Error("invalid offset");
+    }
+    return offset;
+  } catch {
+    throw createError("Cursor is malformed.");
+  }
+}
+
 // src/query/paginator.ts
 function createPaginator(data, meta) {
   const result = {
     data,
     meta: {
       ...meta,
-      pageName: normalizeParameterName(meta.pageName, "page")
+      pageName: normalizePaginationParameterName(meta.pageName, "page", (message) => new SecurityError(message))
     }
   };
   attachMethods(result, {
@@ -306,7 +343,7 @@ function createSimplePaginator(data, meta) {
     data,
     meta: {
       ...meta,
-      pageName: normalizeParameterName(meta.pageName, "page")
+      pageName: normalizePaginationParameterName(meta.pageName, "page", (message) => new SecurityError(message))
     }
   };
   attachMethods(result, {
@@ -327,7 +364,7 @@ function createCursorPaginator(data, meta) {
   const result = {
     data,
     perPage: meta.perPage,
-    cursorName: normalizeParameterName(meta.cursorName, "cursor"),
+    cursorName: normalizePaginationParameterName(meta.cursorName, "cursor", (message) => new SecurityError(message)),
     nextCursor: meta.nextCursor,
     prevCursor: meta.prevCursor
   };
@@ -347,15 +384,6 @@ function createCursorPaginator(data, meta) {
   });
   return result;
 }
-function normalizeParameterName(value, fallback) {
-  if (typeof value === "undefined") {
-    return fallback;
-  }
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new SecurityError(`${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`);
-  }
-  return value;
-}
 function attachMethods(target, methods) {
   Object.defineProperties(
     target,
@@ -373,43 +401,6 @@ function attachMethods(target, methods) {
   );
 }
 
-// src/query/pagination.ts
-function assertPositiveInteger(value, kind, createError) {
-  if (!Number.isInteger(value) || value <= 0) {
-    throw createError(`${kind} must be a positive integer.`);
-  }
-}
-function normalizePaginationParameterName(value, fallback, createError) {
-  if (typeof value === "undefined") {
-    return fallback;
-  }
-  const trimmed = value.trim();
-  if (typeof value !== "string" || trimmed.length === 0) {
-    throw createError(
-      `${fallback === "cursor" ? "Cursor" : "Page"} parameter name must be a non-empty string.`
-    );
-  }
-  return trimmed;
-}
-function encodeOffsetCursor(offset) {
-  return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
-}
-function decodeOffsetCursor(cursor, createError) {
-  if (cursor === null) {
-    return 0;
-  }
-  try {
-    const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-    const offset = decoded.offset;
-    if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
-      throw new Error("invalid offset");
-    }
-    return offset;
-  } catch {
-    throw createError("Cursor is malformed.");
-  }
-}
-
 // src/query/ast.ts
 function createTableSource(table) {
   if (typeof table === "string") {
@@ -1687,16 +1678,6 @@ var SQLQueryCompiler = class {
 function createSqliteJsonExtractExpression(column2, pathLiteral) {
   return `json_extract(${column2}, ${pathLiteral})`;
 }
-function compileSqliteJsonValuePredicate(extracted, predicate, bindings, createPlaceholder) {
-  bindings.push(predicate.value);
-  const operator = predicate.operator.toUpperCase();
-  const placeholder = createPlaceholder(bindings.length);
-  return `${extracted} ${operator} ${placeholder}`;
-}
-var SQLITE_JSON_HELPERS = Object.freeze({
-  compileValuePredicate: compileSqliteJsonValuePredicate,
-  createExtractExpression: createSqliteJsonExtractExpression
-});
 var SQLITE_EMPTY_JSON_OBJECT = "json('{}')";
 var SQLiteQueryCompiler = class extends SQLQueryCompiler {
   compileLockClause(_lockMode) {
@@ -1705,16 +1686,12 @@ var SQLiteQueryCompiler = class extends SQLQueryCompiler {
   compileJsonPredicate(predicate, bindings) {
     const column2 = this.compileColumnReference(predicate.column);
     const pathLiteral = this.createJsonPathLiteral(predicate.path);
+    const extracted = createSqliteJsonExtractExpression(column2, pathLiteral);
     if (predicate.jsonMode === "value") {
-      return SQLITE_JSON_HELPERS.compileValuePredicate(
-        SQLITE_JSON_HELPERS.createExtractExpression(column2, pathLiteral),
-        predicate,
-        bindings,
-        (index) => this.createPlaceholder(index)
-      );
+      bindings.push(predicate.value);
+      return `${extracted} ${predicate.operator.toUpperCase()} ${this.createPlaceholder(bindings.length)}`;
     }
     if (predicate.jsonMode === "contains") {
-      const extracted = SQLITE_JSON_HELPERS.createExtractExpression(column2, pathLiteral);
       if (predicate.value === null || ["string", "number", "boolean"].includes(typeof predicate.value)) {
         bindings.push(predicate.value);
         return `EXISTS (SELECT 1 FROM json_each(${extracted}) WHERE value = ${this.createPlaceholder(bindings.length)})`;
@@ -1723,7 +1700,7 @@ var SQLiteQueryCompiler = class extends SQLQueryCompiler {
       return `${extracted} = json(${this.createPlaceholder(bindings.length)})`;
     }
     bindings.push(predicate.value);
-    return `json_array_length(${SQLITE_JSON_HELPERS.createExtractExpression(column2, pathLiteral)}) ${predicate.operator.toUpperCase()} ${this.createPlaceholder(bindings.length)}`;
+    return `json_array_length(${extracted}) ${predicate.operator.toUpperCase()} ${this.createPlaceholder(bindings.length)}`;
   }
   compileJsonUpdateOperations(column2, operations, bindings) {
     let expression = `COALESCE(${this.compileColumnReference(column2)}, ${SQLITE_EMPTY_JSON_OBJECT})`;
@@ -1878,23 +1855,6 @@ var MySQLQueryCompiler = class extends SQLQueryCompiler {
     const modifier = predicate.mode === "boolean" ? " IN BOOLEAN MODE" : " IN NATURAL LANGUAGE MODE";
     return `MATCH (${columns}) AGAINST (${this.createPlaceholder(bindings.length)}${modifier})`;
   }
-  compileDatePredicate(predicate, placeholder) {
-    const column2 = this.compileColumnReference(predicate.column);
-    switch (predicate.part) {
-      case "date":
-        return `DATE(${column2}) ${predicate.operator.toUpperCase()} ${placeholder}`;
-      case "time":
-        return `TIME(${column2}) ${predicate.operator.toUpperCase()} ${placeholder}`;
-      case "year":
-        return `EXTRACT(YEAR FROM ${column2}) ${predicate.operator.toUpperCase()} ${placeholder}`;
-      case "month":
-        return `EXTRACT(MONTH FROM ${column2}) ${predicate.operator.toUpperCase()} ${placeholder}`;
-      case "day":
-        return `EXTRACT(DAY FROM ${column2}) ${predicate.operator.toUpperCase()} ${placeholder}`;
-      default:
-        return super.compileDatePredicate(predicate, placeholder);
-    }
-  }
 };
 
 // src/schema/normalization.ts
@@ -3246,14 +3206,9 @@ function sanitizeIdentifierForGeneratedName(identifier) {
 }
 
 // src/schema/pluralize.ts
+import { pluralize } from "inflection";
 function pluralizeTableName(word) {
-  if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  if (/(?:[sxz]|ch|sh)$/i.test(word)) {
-    return `${word}es`;
-  }
-  return `${word}s`;
+  return pluralize(word);
 }
 function inferConstrainedTableName(columnName) {
   if (columnName.endsWith("_id")) {
@@ -3559,7 +3514,11 @@ function defineTable(name, columns, options = {}) {
 }
 
 // src/schema/generated.ts
-var generatedTables = /* @__PURE__ */ new Map();
+var generatedTables = (() => {
+  const runtime = globalThis;
+  runtime.__holoGeneratedTables__ ??= /* @__PURE__ */ new Map();
+  return runtime.__holoGeneratedTables__;
+})();
 function registerGeneratedTables(tables) {
   for (const table of Object.values(tables)) {
     generatedTables.set(table.tableName, table);
@@ -3707,22 +3666,7 @@ function renderColumnBuilder(table, columnDefinition) {
 function renderIndex(index) {
   return `{ columns: ${JSON.stringify([...index.columns])}, unique: ${index.unique}${index.name ? `, name: ${JSON.stringify(index.name)}` : ""} }`;
 }
-function renderGeneratedSchemaPlaceholder() {
-  return [
-    "/* eslint-disable @typescript-eslint/no-empty-object-type */",
-    "import { registerGeneratedTables } from '@holo-js/db'",
-    "",
-    "declare module '@holo-js/db' {",
-    "  interface GeneratedSchemaTables {}",
-    "}",
-    "",
-    "export const tables = {} as const",
-    "",
-    "registerGeneratedTables(tables)",
-    ""
-  ].join("\n");
-}
-function renderGeneratedSchemaModule(tables) {
+function buildGeneratedSchemaModuleLines(tables, options) {
   const renderedTables = [...tables].sort((left, right) => left.tableName.localeCompare(right.tableName));
   const declarations = [
     "import { column, defineGeneratedTable, registerGeneratedTables } from '@holo-js/db'",
@@ -3741,24 +3685,146 @@ function renderGeneratedSchemaModule(tables) {
     declarations.push(`}${table.indexes.length > 0 ? `, { indexes: [${table.indexes.map(renderIndex).join(", ")}] }` : ""})`);
     declarations.push("");
   }
-  declarations.push("declare module '@holo-js/db' {");
-  declarations.push("  interface GeneratedSchemaTables {");
-  declarations.push(...interfaceLines);
-  declarations.push("  }");
-  declarations.push("}");
-  declarations.push("");
-  declarations.push(`export const tables = { ${exportedTableEntries.join(", ")} } as const`);
+  if (options.withTypeAugmentation) {
+    declarations.push("declare module '@holo-js/db' {");
+    declarations.push("  interface GeneratedSchemaTables {");
+    declarations.push(...interfaceLines);
+    declarations.push("  }");
+    declarations.push("}");
+    declarations.push("");
+  }
+  declarations.push(
+    options.withTypeAugmentation ? `export const tables = { ${exportedTableEntries.join(", ")} } as const` : `export const tables = Object.freeze({ ${exportedTableEntries.join(", ")} })`
+  );
   declarations.push("");
   declarations.push("registerGeneratedTables(tables)");
   declarations.push("");
-  return declarations.join("\n");
+  return declarations;
+}
+function renderGeneratedSchemaPlaceholder() {
+  return [
+    "/* eslint-disable @typescript-eslint/no-empty-object-type */",
+    "import { registerGeneratedTables } from '@holo-js/db'",
+    "",
+    "declare module '@holo-js/db' {",
+    "  interface GeneratedSchemaTables {}",
+    "}",
+    "",
+    "export const tables = {} as const",
+    "",
+    "registerGeneratedTables(tables)",
+    ""
+  ].join("\n");
+}
+function renderGeneratedSchemaModule(tables) {
+  return buildGeneratedSchemaModuleLines(tables, { withTypeAugmentation: true }).join("\n");
+}
+function renderGeneratedSchemaRuntimeModule(tables) {
+  return buildGeneratedSchemaModuleLines(tables, { withTypeAugmentation: false }).join("\n");
+}
+
+// src/schema/foreignKeyBuilderState.ts
+var ForeignKeyBuilderState = class {
+  constructor(columnName, referenceColumn = "id") {
+    this.columnName = columnName;
+    this.referenceColumn = referenceColumn;
+  }
+  referenceTable;
+  referenceColumn;
+  onDeleteAction;
+  onUpdateAction;
+  references(columnName) {
+    this.referenceColumn = columnName;
+  }
+  on(table) {
+    this.referenceTable = table;
+  }
+  constrained(table, columnName = "id") {
+    this.referenceTable = table ?? inferConstrainedTableName(this.columnName);
+    this.referenceColumn = columnName;
+  }
+  onDelete(action) {
+    this.onDeleteAction = action;
+  }
+  onUpdate(action) {
+    this.onUpdateAction = action;
+  }
+  toReference(defaultTable = "") {
+    return {
+      table: this.referenceTable ?? defaultTable,
+      column: this.referenceColumn,
+      onDelete: this.onDeleteAction,
+      onUpdate: this.onUpdateAction
+    };
+  }
+  applyToColumnBuilder(builder) {
+    let next = builder.references(this.referenceColumn);
+    if (this.referenceTable) {
+      next = next.on(this.referenceTable);
+    }
+    if (this.onDeleteAction) {
+      next = next.onDelete(this.onDeleteAction);
+    }
+    if (this.onUpdateAction) {
+      next = next.onUpdate(this.onUpdateAction);
+    }
+    return next;
+  }
+};
+
+// src/schema/generatedNames.ts
+var DEFAULT_INDEX_NAME_LENGTH_POLICY = Object.freeze({
+  maxBytes: 63,
+  label: "portable PostgreSQL-compatible (NAMEDATALEN-1)"
+});
+function assertValidIndexName(indexName, policy = DEFAULT_INDEX_NAME_LENGTH_POLICY) {
+  assertValidIdentifierSegment(indexName, "Index name");
+  const byteLength = new TextEncoder().encode(indexName).length;
+  if (byteLength > policy.maxBytes) {
+    throw new SchemaError(
+      `Index name "${indexName}" is ${byteLength} bytes long; ${policy.label} index names must be ${policy.maxBytes} bytes or fewer. Provide a shorter explicit index name.`
+    );
+  }
+}
+function assertUniqueResolvedIndexNames(tableName, indexes) {
+  const names = /* @__PURE__ */ new Set();
+  for (const index of indexes) {
+    const indexName = resolveGeneratedIndexName(tableName, index);
+    if (names.has(indexName)) {
+      throw new SchemaError(
+        `Index name "${indexName}" is used by multiple indexes on table "${tableName}". Provide explicit unique index names.`
+      );
+    }
+    names.add(indexName);
+  }
+}
+function resolveGeneratedIndexName(tableName, index) {
+  const suffix = index.unique ? "unique" : "index";
+  const indexName = index.name ?? createConventionalIndexName(tableName, index.columns, suffix);
+  assertValidIndexName(indexName);
+  return indexName;
+}
+function createConventionalIndexName(tableName, columns, suffix) {
+  const columnsName = columns.map((column2) => sanitizeIdentifierForGeneratedName(column2)).join("_");
+  return `${sanitizeIdentifierForGeneratedName(tableName)}_${columnsName}_${suffix}`;
+}
+function resolveConventionalIndexName(tableName, columns, suffix = "index") {
+  const indexName = createConventionalIndexName(tableName, columns, suffix);
+  assertValidIndexName(indexName);
+  return indexName;
+}
+function resolveGeneratedForeignKeyName(tableName, columnName, constraintName) {
+  const resolvedName = constraintName ?? `${sanitizeIdentifierForGeneratedName(tableName)}_${sanitizeIdentifierForGeneratedName(columnName)}_foreign`;
+  assertValidIdentifierSegment(resolvedName, "Foreign key name");
+  return resolvedName;
 }
 
 // src/schema/TableDefinitionBuilder.ts
 var TableCreateColumnBuilder = class {
-  constructor(root, builderRef) {
+  constructor(root, builderRef, columnName) {
     this.root = root;
     this.builderRef = builderRef;
+    this.columnName = columnName;
   }
   build() {
     return this.root.build();
@@ -3794,6 +3860,16 @@ var TableCreateColumnBuilder = class {
     this.builderRef.builder = this.builderRef.builder.unique();
     return this;
   }
+  index(nameOrColumns, name) {
+    if (typeof nameOrColumns !== "string" && nameOrColumns !== void 0) {
+      return this.root.index(nameOrColumns, name);
+    }
+    this.root.index(
+      [this.columnName],
+      nameOrColumns ?? resolveConventionalIndexName(this.root.tableName, [this.columnName])
+    );
+    return this;
+  }
   foreign(columnName) {
     return this.root.foreign(columnName);
   }
@@ -3866,9 +3942,6 @@ var TableCreateColumnBuilder = class {
   enum(columnName, values) {
     return this.root.enum(columnName, values);
   }
-  index(columns, name) {
-    return this.root.index(columns, name);
-  }
   timestamps() {
     return this.root.timestamps();
   }
@@ -3901,33 +3974,29 @@ var TableCreateColumnBuilder = class {
   }
 };
 var TableCreateForeignIdBuilder = class extends TableCreateColumnBuilder {
+  foreignKeyState;
   constructor(root, builderRef, columnName) {
-    super(root, builderRef);
-    this.columnName = columnName;
+    super(root, builderRef, columnName);
+    this.foreignKeyState = new ForeignKeyBuilderState(columnName);
   }
-  referenceTable;
-  referenceColumn = "id";
-  onDeleteAction;
-  onUpdateAction;
   references(columnName) {
-    this.referenceColumn = columnName;
+    this.foreignKeyState.references(columnName);
     return this.applyReference();
   }
   on(table) {
-    this.referenceTable = table;
+    this.foreignKeyState.on(table);
     return this.applyReference();
   }
   constrained(table, columnName = "id") {
-    this.referenceTable = table ?? inferConstrainedTableName(this.columnName);
-    this.referenceColumn = columnName;
+    this.foreignKeyState.constrained(table, columnName);
     return this.applyReference();
   }
   onDelete(action) {
-    this.onDeleteAction = action;
+    this.foreignKeyState.onDelete(action);
     return this.applyReference();
   }
   onUpdate(action) {
-    this.onUpdateAction = action;
+    this.foreignKeyState.onUpdate(action);
     return this.applyReference();
   }
   cascadeOnDelete() {
@@ -3955,17 +4024,7 @@ var TableCreateForeignIdBuilder = class extends TableCreateColumnBuilder {
     return this.onUpdate("no action");
   }
   applyReference() {
-    let builder = this.builderRef.builder.references(this.referenceColumn);
-    if (this.referenceTable) {
-      builder = builder.on(this.referenceTable);
-    }
-    if (this.onDeleteAction) {
-      builder = builder.onDelete(this.onDeleteAction);
-    }
-    if (this.onUpdateAction) {
-      builder = builder.onUpdate(this.onUpdateAction);
-    }
-    this.builderRef.builder = builder;
+    this.builderRef.builder = this.foreignKeyState.applyToColumnBuilder(this.builderRef.builder);
     return this;
   }
 };
@@ -3973,31 +4032,27 @@ var TableCreateForeignKeyBuilder = class {
   constructor(root, builderRef, columnName) {
     this.root = root;
     this.builderRef = builderRef;
-    this.columnName = columnName;
+    this.foreignKeyState = new ForeignKeyBuilderState(columnName);
   }
-  referenceTable;
-  referenceColumn = "id";
-  onDeleteAction;
-  onUpdateAction;
+  foreignKeyState;
   references(columnName) {
-    this.referenceColumn = columnName;
+    this.foreignKeyState.references(columnName);
     return this.applyReference();
   }
   on(table) {
-    this.referenceTable = table;
+    this.foreignKeyState.on(table);
     return this.applyReference();
   }
   constrained(table, columnName = "id") {
-    this.referenceTable = table ?? inferConstrainedTableName(this.columnName);
-    this.referenceColumn = columnName;
+    this.foreignKeyState.constrained(table, columnName);
     return this.applyReference();
   }
   onDelete(action) {
-    this.onDeleteAction = action;
+    this.foreignKeyState.onDelete(action);
     return this.applyReference();
   }
   onUpdate(action) {
-    this.onUpdateAction = action;
+    this.foreignKeyState.onUpdate(action);
     return this.applyReference();
   }
   cascadeOnDelete() {
@@ -4028,17 +4083,7 @@ var TableCreateForeignKeyBuilder = class {
     return this.root.build();
   }
   applyReference() {
-    let builder = this.builderRef.builder.references(this.referenceColumn);
-    if (this.referenceTable) {
-      builder = builder.on(this.referenceTable);
-    }
-    if (this.onDeleteAction) {
-      builder = builder.onDelete(this.onDeleteAction);
-    }
-    if (this.onUpdateAction) {
-      builder = builder.onUpdate(this.onUpdateAction);
-    }
-    this.builderRef.builder = builder;
+    this.builderRef.builder = this.foreignKeyState.applyToColumnBuilder(this.builderRef.builder);
     return this;
   }
 };
@@ -4180,7 +4225,8 @@ var TableDefinitionBuilder = class {
     };
     return new TableCreateColumnBuilder(
       this,
-      builderRef
+      builderRef,
+      columnName
     );
   }
   foreignColumn(columnName, initialBuilder) {
@@ -4202,7 +4248,10 @@ var TableDefinitionBuilder = class {
     const idBuilder = nullable ? createIdBuilder().nullable() : createIdBuilder();
     this.column(typeColumn, typeBuilder);
     this.column(idColumn, idBuilder);
-    this.index([typeColumn, idColumn], indexName);
+    this.index(
+      [typeColumn, idColumn],
+      indexName ?? resolveConventionalIndexName(this.tableName, [typeColumn, idColumn])
+    );
     return this;
   }
 };
@@ -4211,36 +4260,32 @@ var TableDefinitionBuilder = class {
 var TableForeignKeyBuilder = class {
   constructor(operation) {
     this.operation = operation;
+    this.foreignKeyState = new ForeignKeyBuilderState(operation.columnName, operation.reference.column);
   }
+  foreignKeyState;
   references(columnName) {
-    this.operation.reference = {
-      ...this.operation.reference,
-      column: columnName
-    };
+    this.foreignKeyState.references(columnName);
+    this.applyReference();
     return this;
   }
   on(table) {
-    this.operation.reference = {
-      ...this.operation.reference,
-      table
-    };
+    this.foreignKeyState.on(table);
+    this.applyReference();
     return this;
   }
   constrained(table, columnName = "id") {
-    return this.on(table ?? inferConstrainedTableName(this.operation.columnName)).references(columnName);
+    this.foreignKeyState.constrained(table, columnName);
+    this.applyReference();
+    return this;
   }
   onDelete(action) {
-    this.operation.reference = {
-      ...this.operation.reference,
-      onDelete: action
-    };
+    this.foreignKeyState.onDelete(action);
+    this.applyReference();
     return this;
   }
   onUpdate(action) {
-    this.operation.reference = {
-      ...this.operation.reference,
-      onUpdate: action
-    };
+    this.foreignKeyState.onUpdate(action);
+    this.applyReference();
     return this;
   }
   cascadeOnDelete() {
@@ -4267,6 +4312,9 @@ var TableForeignKeyBuilder = class {
   noActionOnUpdate() {
     return this.onUpdate("no action");
   }
+  applyReference() {
+    this.operation.reference = this.foreignKeyState.toReference();
+  }
 };
 var TableColumnMutationBuilder = class {
   constructor(root, operation) {
@@ -4301,6 +4349,13 @@ var TableColumnMutationBuilder = class {
     this.operation.column = this.operation.column.unique();
     return this;
   }
+  index(name) {
+    this.root.index(
+      [this.operation.columnName],
+      name ?? resolveConventionalIndexName(this.root.table, [this.operation.columnName])
+    );
+    return this;
+  }
   foreignId(columnName) {
     return this.root.foreignId(columnName);
   }
@@ -4347,31 +4402,28 @@ var TableForeignIdMutationBuilder = class extends TableColumnMutationBuilder {
     super(root, operation);
     this.operations = operations;
     this.columnName = columnName;
+    this.foreignKeyState = new ForeignKeyBuilderState(columnName);
   }
+  foreignKeyState;
   foreignOperation;
-  referenceTable;
-  referenceColumn = "id";
-  onDeleteAction;
-  onUpdateAction;
   references(columnName) {
-    this.referenceColumn = columnName;
+    this.foreignKeyState.references(columnName);
     return this.applyForeignKey();
   }
   on(table) {
-    this.referenceTable = table;
+    this.foreignKeyState.on(table);
     return this.applyForeignKey();
   }
   constrained(table, columnName = "id") {
-    this.referenceTable = table ?? inferConstrainedTableName(this.columnName);
-    this.referenceColumn = columnName;
+    this.foreignKeyState.constrained(table, columnName);
     return this.applyForeignKey();
   }
   onDelete(action) {
-    this.onDeleteAction = action;
+    this.foreignKeyState.onDelete(action);
     return this.applyForeignKey();
   }
   onUpdate(action) {
-    this.onUpdateAction = action;
+    this.foreignKeyState.onUpdate(action);
     return this.applyForeignKey();
   }
   cascadeOnDelete() {
@@ -4400,12 +4452,7 @@ var TableForeignIdMutationBuilder = class extends TableColumnMutationBuilder {
   }
   applyForeignKey() {
     const operation = this.ensureForeignOperation();
-    operation.reference = {
-      table: this.referenceTable ?? "",
-      column: this.referenceColumn,
-      onDelete: this.onDeleteAction,
-      onUpdate: this.onUpdateAction
-    };
+    operation.reference = this.foreignKeyState.toReference();
     return this;
   }
   ensureForeignOperation() {
@@ -4413,12 +4460,7 @@ var TableForeignIdMutationBuilder = class extends TableColumnMutationBuilder {
       this.foreignOperation = {
         kind: "createForeignKey",
         columnName: this.columnName,
-        reference: {
-          table: this.referenceTable ?? "",
-          column: this.referenceColumn,
-          onDelete: this.onDeleteAction,
-          onUpdate: this.onUpdateAction
-        }
+        reference: this.foreignKeyState.toReference()
       };
       this.operations.push(this.foreignOperation);
     }
@@ -4586,7 +4628,10 @@ var TableMutationBuilder = class {
     const idColumn = `${name}_id`;
     this.columnMutation(typeColumn, () => nullable ? column.string().nullable() : column.string());
     this.columnMutation(idColumn, () => nullable ? createIdBuilder().nullable() : createIdBuilder());
-    this.index([typeColumn, idColumn], indexName);
+    this.index(
+      [typeColumn, idColumn],
+      indexName ?? resolveConventionalIndexName(this.table, [typeColumn, idColumn])
+    );
     return this;
   }
 };
@@ -4766,6 +4811,7 @@ var SQLSchemaCompiler = class {
   }
   compileCreateTable(table) {
     assertValidIdentifierPath(table.tableName, "Table name");
+    assertUniqueResolvedIndexNames(table.tableName, table.indexes);
     const columnSql = Object.values(table.columns).map((column2) => this.compileColumn(column2));
     const sql = `CREATE TABLE IF NOT EXISTS ${this.compileIdentifierPath(table.tableName)} (${columnSql.join(", ")})`;
     const statements = [{
@@ -4857,7 +4903,7 @@ var SQLSchemaCompiler = class {
   }
   compileDropIndex(tableName, indexName) {
     assertValidIdentifierPath(tableName, "Table name");
-    assertValidIdentifierSegment(indexName, "Index name");
+    assertValidIndexName(indexName);
     return {
       sql: `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`,
       source: `schema:dropIndex:${tableName}:${indexName}`
@@ -4873,8 +4919,8 @@ var SQLSchemaCompiler = class {
   }
   compileRenameIndex(tableName, fromIndexName, toIndexName) {
     assertValidIdentifierPath(tableName, "Table name");
-    assertValidIdentifierSegment(fromIndexName, "Index name");
-    assertValidIdentifierSegment(toIndexName, "Index name");
+    assertValidIndexName(fromIndexName);
+    assertValidIndexName(toIndexName);
     return {
       sql: `ALTER INDEX ${this.quoteIdentifier(fromIndexName)} RENAME TO ${this.quoteIdentifier(toIndexName)}`,
       source: `schema:renameIndex:${tableName}:${fromIndexName}:${toIndexName}`
@@ -4964,14 +5010,10 @@ var SQLSchemaCompiler = class {
     return false;
   }
   resolveIndexName(tableName, index) {
-    const indexName = index.name ?? `${sanitizeIdentifierForGeneratedName(tableName)}_${index.columns.join("_")}_${index.unique ? "unique" : "index"}`;
-    assertValidIdentifierSegment(indexName, "Index name");
-    return indexName;
+    return resolveGeneratedIndexName(tableName, index);
   }
   resolveForeignKeyName(tableName, columnName, constraintName) {
-    const resolvedName = constraintName ?? `${sanitizeIdentifierForGeneratedName(tableName)}_${columnName}_foreign`;
-    assertValidIdentifierSegment(resolvedName, "Foreign key name");
-    return resolvedName;
+    return resolveGeneratedForeignKeyName(tableName, columnName, constraintName);
   }
   assertSupportedAlterColumnDefinition(column2) {
     if (column2.primaryKey || column2.unique || column2.references || column2.kind === "id") {
@@ -5130,6 +5172,41 @@ function resolveDialectColumnType(dialect, column2) {
   }
   return typeof entry === "function" ? entry(column2) : entry;
 }
+function resolveDialectComparisonColumnType(dialect, column2) {
+  const compiledType = resolveDialectColumnType(dialect, column2);
+  const normalized = compiledType.toLowerCase();
+  if (dialect === "sqlite") {
+    return normalized.split(/\s+/, 1)[0].toUpperCase();
+  }
+  if (dialect === "postgres") {
+    if (normalized.startsWith("varchar")) {
+      return "character varying";
+    }
+    if (normalized.startsWith("bigint")) {
+      return "bigint";
+    }
+    return normalized;
+  }
+  if (normalized.startsWith("varchar")) {
+    return "varchar";
+  }
+  if (normalized.startsWith("char")) {
+    return "char";
+  }
+  if (normalized.startsWith("tinyint")) {
+    return "tinyint";
+  }
+  if (normalized.startsWith("decimal")) {
+    return "decimal";
+  }
+  if (normalized.startsWith("enum")) {
+    return "enum";
+  }
+  if (normalized.startsWith("bigint")) {
+    return "bigint";
+  }
+  return normalized;
+}
 
 // src/schema/SQLiteSchemaCompiler.ts
 var SQLiteSchemaCompiler = class extends SQLSchemaCompiler {
@@ -5211,6 +5288,8 @@ var MySQLSchemaCompiler = class extends SQLSchemaCompiler {
     };
   }
   compileRenameIndex(tableName, fromIndexName, toIndexName) {
+    assertValidIndexName(fromIndexName);
+    assertValidIndexName(toIndexName);
     return {
       sql: `ALTER TABLE ${this.compileIdentifierPath(tableName)} RENAME INDEX ${this.quoteIdentifier(fromIndexName)} TO ${this.quoteIdentifier(toIndexName)}`,
       source: `schema:renameIndex:${tableName}:${fromIndexName}:${toIndexName}`
@@ -5225,6 +5304,7 @@ var MySQLSchemaCompiler = class extends SQLSchemaCompiler {
     };
   }
   compileDropIndex(tableName, indexName) {
+    assertValidIndexName(indexName);
     return {
       sql: `DROP INDEX ${this.quoteIdentifier(indexName)} ON ${this.compileIdentifierPath(tableName)}`,
       source: `schema:dropIndex:${tableName}:${indexName}`
@@ -5268,7 +5348,9 @@ var SchemaService = class {
     assertValidIdentifierPath(tableName, "Table name");
     const builder = new TableMutationBuilder(tableName);
     await callback(builder);
-    for (const operation of builder.getOperations()) {
+    const operations = builder.getOperations();
+    this.assertTableMutationIndexNames(tableName, operations);
+    for (const operation of operations) {
       await this.executeTableMutation(tableName, operation);
     }
   }
@@ -5556,10 +5638,31 @@ var SchemaService = class {
     return column2.toDefinition({ name: columnName });
   }
   async createDefinedTable(table) {
+    const statements = this.createCompiler().compile(createTableOperation(table));
     if (!this.connection.getSchemaRegistry().has(table.tableName)) {
       this.register(table);
     }
-    await this.execute(this.createCompiler().compile(createTableOperation(table)));
+    await this.execute(statements);
+  }
+  assertTableMutationIndexNames(tableName, operations) {
+    const indexes = [];
+    for (const operation of operations) {
+      switch (operation.kind) {
+        case "createIndex":
+          indexes.push(operation.index);
+          this.resolveIndexName(tableName, operation.index);
+          break;
+        case "dropIndex":
+          assertValidIndexName(operation.indexName);
+          break;
+        case "renameIndex":
+          assertValidIndexName(operation.fromIndexName);
+          assertValidIndexName(operation.toIndexName);
+          indexes.push({ columns: [], name: operation.toIndexName, unique: false });
+          break;
+      }
+    }
+    assertUniqueResolvedIndexNames(tableName, indexes);
   }
   async executeTableMutation(tableName, operation) {
     switch (operation.kind) {
@@ -5757,10 +5860,10 @@ var SchemaService = class {
     return defineTable(table.tableName, nextColumns, { indexes: table.indexes });
   }
   resolveIndexName(tableName, index) {
-    return index.name ?? `${tableName.replaceAll(".", "_")}_${index.columns.join("_")}_${index.unique ? "unique" : "index"}`;
+    return resolveGeneratedIndexName(tableName, index);
   }
   resolveForeignKeyName(tableName, columnName) {
-    return `${tableName.replaceAll(".", "_")}_${columnName}_foreign`;
+    return resolveGeneratedForeignKeyName(tableName, columnName);
   }
   createForeignKeyConstraintStatement(enable) {
     if (this.isSqlite()) {
@@ -5969,117 +6072,15 @@ async function diffTable(schema, table) {
 }
 function lowerLogicalColumnType(column2, dialectName) {
   if (dialectName.startsWith("postgres")) {
-    return lowerPostgresLogicalColumnType(column2);
+    return resolveDialectComparisonColumnType("postgres", column2);
   }
   if (dialectName.startsWith("mysql")) {
-    return lowerMySqlLogicalColumnType(column2);
-  }
-  switch (column2.kind) {
-    case "id":
-    case "integer":
-    case "bigInteger":
-    case "boolean":
-      return "INTEGER";
-    case "string":
-    case "uuid":
-    case "ulid":
-    case "snowflake":
-    case "date":
-    case "datetime":
-    case "timestamp":
-    case "text":
-    case "json":
-    case "enum":
-      return "TEXT";
-    case "real":
-      return "REAL";
-    case "decimal":
-      return "NUMERIC";
-    case "blob":
-      return "BLOB";
-    case "vector":
-      throw new SchemaError("SQLite schema diffing does not support logical vector columns.");
-    default:
-      throw new SchemaError(`Unsupported logical column kind "${String(column2.kind)}" for SQLite schema diffing.`);
-  }
-}
-function lowerPostgresLogicalColumnType(column2) {
-  switch (column2.kind) {
-    case "id":
-    case "bigInteger":
-      return "bigint";
-    case "integer":
-      return "integer";
-    case "boolean":
-      return "boolean";
-    case "string":
-      return "character varying";
-    case "text":
-    case "enum":
-      return "text";
-    case "uuid":
-      return "uuid";
-    case "ulid":
-    case "snowflake":
-      return "character varying";
-    case "date":
-      return "date";
-    case "datetime":
-    case "timestamp":
-      return "timestamp";
-    case "json":
-      return "jsonb";
-    case "real":
-      return "double precision";
-    case "decimal":
-      return "numeric";
-    case "blob":
-      return "bytea";
-    case "vector":
-      return `vector(${column2.vectorDimensions})`;
-    default:
-      throw new SchemaError(`Unsupported logical column kind "${String(column2.kind)}" for Postgres schema diffing.`);
+    return resolveDialectComparisonColumnType("mysql", column2);
   }
-}
-function lowerMySqlLogicalColumnType(column2) {
-  switch (column2.kind) {
-    case "id":
-    case "bigInteger":
-      return "bigint";
-    case "integer":
-      return "int";
-    case "boolean":
-      return "tinyint";
-    case "string":
-      return "varchar";
-    case "text":
-      return "text";
-    case "uuid":
-    case "ulid":
-      return "char";
-    case "snowflake":
-      return "varchar";
-    case "date":
-      return "date";
-    case "datetime":
-      return "datetime";
-    case "timestamp":
-      return "timestamp";
-    case "enum":
-      return "enum";
-    case "json":
-      return "json";
-    case "real":
-      return "double";
-    case "decimal":
-      return "decimal";
-    case "blob":
-      return "blob";
-    case "vector":
-      throw new SchemaError("MySQL schema diffing does not support logical vector columns.");
-    default:
-      throw new SchemaError(`Unsupported logical column kind "${String(column2.kind)}" for MySQL schema diffing.`);
+  if (dialectName.startsWith("sqlite")) {
+    return resolveDialectComparisonColumnType("sqlite", column2);
   }
+  return resolveDialectComparisonColumnType(dialectName, column2);
 }
 function normalizeExpectedIndex(table, index) {
   return {
@@ -6105,10 +6106,8 @@ function normalizeActualForeignKeyName(foreignKey) {
 // src/migrations/defineMigration.ts
 var MIGRATION_NAME_PATTERN = /^\d{4}_\d{2}_\d{2}_\d{6}_[a-z0-9_]+$/;
 function defineMigration(definition) {
-  if (definition.name && !MIGRATION_NAME_PATTERN.test(definition.name)) {
-    throw new ConfigurationError(
-      `Migration name "${definition.name}" must match YYYY_MM_DD_HHMMSS_description.`
-    );
+  if (definition.name) {
+    assertMigrationName(definition.name);
   }
   return Object.freeze(definition);
 }
@@ -6206,9 +6205,7 @@ var MigrationService = class {
       const executed = [];
       for (const migration of pending) {
         const log = this.createMigrationLog(migration.name, "up", nextBatch);
-        const startedAt = Date.now();
-        await this.connection.getLogger()?.onMigrationStart?.(log);
-        try {
+        await this.runMigrationLifecycle(log, async () => {
           await this.connection.transaction(async (tx) => {
             const context = this.createContext(tx);
             await migration.up(context);
@@ -6218,18 +6215,7 @@ var MigrationService = class {
               migrated_at: (/* @__PURE__ */ new Date()).toISOString()
             });
           });
-          await this.connection.getLogger()?.onMigrationSuccess?.({
-            ...log,
-            durationMs: Date.now() - startedAt
-          });
-        } catch (error) {
-          await this.connection.getLogger()?.onMigrationError?.({
-            ...log,
-            durationMs: Date.now() - startedAt,
-            error
-          });
-          throw error;
-        }
+        });
         executed.push(migration);
       }
       return executed;
@@ -6252,9 +6238,7 @@ var MigrationService = class {
           continue;
         }
         const log = this.createMigrationLog(record.name, "down", record.batch);
-        const startedAt = Date.now();
-        await this.connection.getLogger()?.onMigrationStart?.(log);
-        try {
+        await this.runMigrationLifecycle(log, async () => {
           await this.connection.transaction(async (tx) => {
             const context = this.createContext(tx);
             if (migration.down) {
@@ -6262,18 +6246,7 @@ var MigrationService = class {
             }
             await new TableQueryBuilder(migrationsTable, tx).where("name", record.name).delete();
           });
-          await this.connection.getLogger()?.onMigrationSuccess?.({
-            ...log,
-            durationMs: Date.now() - startedAt
-          });
-        } catch (error) {
-          await this.connection.getLogger()?.onMigrationError?.({
-            ...log,
-            durationMs: Date.now() - startedAt,
-            error
-          });
-          throw error;
-        }
+        });
         rolledBack.push(migration);
       }
       return rolledBack;
@@ -6312,6 +6285,25 @@ var MigrationService = class {
       schema: createSchemaService(connection)
     };
   }
+  async runMigrationLifecycle(log, callback) {
+    const startedAt = Date.now();
+    await this.connection.getLogger()?.onMigrationStart?.(log);
+    try {
+      const result = await callback();
+      await this.connection.getLogger()?.onMigrationSuccess?.({
+        ...log,
+        durationMs: Date.now() - startedAt
+      });
+      return result;
+    } catch (error) {
+      await this.connection.getLogger()?.onMigrationError?.({
+        ...log,
+        durationMs: Date.now() - startedAt,
+        error
+      });
+      throw error;
+    }
+  }
   normalizeMigratedAt(value) {
     const normalized = value instanceof Date ? value : new Date(value);
     if (Number.isNaN(normalized.getTime())) {
@@ -6412,15 +6404,101 @@ function unsafeSql(sql, bindings = [], source) {
   };
 }
 
+// src/model/ModelRegistry.ts
+function resolveDefinition(reference) {
+  return "definition" in reference ? reference.definition : reference;
+}
+function isMissingGeneratedSchemaModelError(error) {
+  return error instanceof Error && error.message.includes("is not present in the generated schema registry");
+}
+function tryGetDefinitionTableName(definition) {
+  try {
+    return definition.table.tableName;
+  } catch (error) {
+    if (isMissingGeneratedSchemaModelError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function definitionsReferToSameModel(left, right) {
+  if (left === right) {
+    return true;
+  }
+  const leftTableName = tryGetDefinitionTableName(left);
+  const rightTableName = tryGetDefinitionTableName(right);
+  if (!leftTableName || !rightTableName) {
+    return left.name === right.name && left.primaryKey === right.primaryKey && left.morphClass === right.morphClass;
+  }
+  return leftTableName === rightTableName && left.primaryKey === right.primaryKey && left.morphClass === right.morphClass;
+}
+function getGlobalModels() {
+  const runtime = globalThis;
+  runtime.__holoDbGlobalModels__ ??= /* @__PURE__ */ new Map();
+  return runtime.__holoDbGlobalModels__;
+}
+var ModelRegistry = class {
+  models = /* @__PURE__ */ new Map();
+  register(reference) {
+    const definition = resolveDefinition(reference);
+    const existing = this.models.get(definition.name);
+    if (existing && !definitionsReferToSameModel(existing, definition)) {
+      throw new DatabaseError(`Model "${definition.name}" is already registered.`, "DUPLICATE_MODEL");
+    }
+    this.models.set(definition.name, definition);
+    return definition;
+  }
+  has(name) {
+    return this.models.has(name);
+  }
+  get(name) {
+    return this.models.get(name);
+  }
+  list() {
+    return [...this.models.values()];
+  }
+  clear() {
+    this.models.clear();
+  }
+};
+function createModelRegistry() {
+  return new ModelRegistry();
+}
+function registerGlobalModel(reference) {
+  const definition = resolveDefinition(reference);
+  const globalModels = getGlobalModels();
+  const existing = globalModels.get(definition.name);
+  if (existing) {
+    const existingDefinition = resolveDefinition(existing);
+    if (!definitionsReferToSameModel(existingDefinition, definition)) {
+      throw new DatabaseError(`Model "${definition.name}" is already registered globally.`, "DUPLICATE_MODEL");
+    }
+    return existing;
+  }
+  globalModels.set(definition.name, reference);
+  return reference;
+}
+function getGlobalModel(name) {
+  return getGlobalModels().get(name);
+}
+function resetGlobalModelRegistry() {
+  getGlobalModels().clear();
+}
+
 // src/model/morphRegistry.ts
-var morphRegistry = /* @__PURE__ */ new Map();
+function getMorphRegistry() {
+  const runtime = globalThis;
+  runtime.__holoDbMorphRegistry__ ??= /* @__PURE__ */ new Map();
+  return runtime.__holoDbMorphRegistry__;
+}
 function registerMorphModel(type, reference) {
-  morphRegistry.set(type, reference);
+  getMorphRegistry().set(type, reference);
 }
 function resolveMorphModel(type) {
-  return morphRegistry.get(type);
+  return getMorphRegistry().get(type);
 }
 function resolveMorphSelector(label) {
+  const morphRegistry = getMorphRegistry();
   const exact = morphRegistry.get(label);
   if (exact) {
     return exact;
@@ -6440,10 +6518,10 @@ function resolveMorphSelector(label) {
   return void 0;
 }
 function listMorphModels() {
-  return [...morphRegistry.values()];
+  return [...getMorphRegistry().values()];
 }
 function resetMorphRegistry() {
-  morphRegistry.clear();
+  getMorphRegistry().clear();
 }
 
 // src/facade/DB.ts
@@ -6505,13 +6583,11 @@ function configureDB(manager) {
 }
 function resetDB() {
   DB.reset();
+  resetGlobalModelRegistry();
   resetMorphRegistry();
 }
 
-// src/model/Entity.ts
-function isEntity(value) {
-  return value instanceof EntityBase;
-}
+// src/model/entityRuntime.ts
 function valuesAreEqual(left, right) {
   if (Object.is(left, right)) {
     return true;
@@ -6534,15 +6610,76 @@ function valuesAreEqual(left, right) {
     return left.length === right.length && left.every((value, index) => valuesAreEqual(value, right[index]));
   }
   if (left && right && typeof left === "object" && typeof right === "object" && Object.getPrototypeOf(left) === Object.getPrototypeOf(right)) {
-    const leftEntries = Object.entries(left);
-    const rightEntries = Object.entries(right);
-    if (leftEntries.length !== rightEntries.length) {
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (leftKeys.length !== rightKeys.length) {
       return false;
     }
-    return leftEntries.every(([key, value]) => valuesAreEqual(value, right[key]));
+    if (leftKeys.some((key) => !Object.prototype.hasOwnProperty.call(rightRecord, key)) || rightKeys.some((key) => !Object.prototype.hasOwnProperty.call(leftRecord, key))) {
+      return false;
+    }
+    return leftKeys.every((key) => valuesAreEqual(leftRecord[key], rightRecord[key]));
   }
   return false;
 }
+function initializeEntityModelProperties(entity, repo) {
+  const columns = repo?.definition?.table?.columns;
+  if (columns && typeof columns === "object") {
+    for (const key of Object.keys(columns)) {
+      if (key in entity) {
+        continue;
+      }
+      Object.defineProperty(entity, key, {
+        configurable: true,
+        enumerable: true,
+        get: () => entity.get(key),
+        set: (value) => {
+          entity.set(key, value);
+        }
+      });
+    }
+  }
+  const relationNames = typeof repo?.getRelationNames === "function" ? repo.getRelationNames() : Object.keys(repo?.definition?.relations ?? {});
+  for (const key of relationNames) {
+    if (key in entity) {
+      continue;
+    }
+    Object.defineProperty(entity, key, {
+      configurable: true,
+      enumerable: false,
+      get: () => {
+        if (entity.hasRelation(key)) {
+          return entity.getRelation(key);
+        }
+        const relationMethod = (() => entity.relation(key));
+        const loadRelation = () => {
+          if (typeof repo?.resolveRelationProperty !== "function") {
+            return Promise.resolve(void 0);
+          }
+          try {
+            return Promise.resolve(repo.resolveRelationProperty(entity, key));
+          } catch (error) {
+            return Promise.reject(error);
+          }
+        };
+        relationMethod.then = (onFulfilled, onRejected) => loadRelation().then(onFulfilled, onRejected);
+        relationMethod.catch = (onRejected) => loadRelation().catch(onRejected);
+        relationMethod.finally = (onFinally) => loadRelation().finally(onFinally);
+        return relationMethod;
+      },
+      set: (value) => {
+        entity.setRelation(key, value);
+      }
+    });
+  }
+}
+
+// src/model/Entity.ts
+function isEntity(value) {
+  return value instanceof EntityBase;
+}
 var EntityBase = class _EntityBase {
   constructor(repository, attributes, exists = true) {
     this.repository = repository;
@@ -6551,7 +6688,7 @@ var EntityBase = class _EntityBase {
     this.changes = exists ? {} : { ...attributes };
     this.persisted = exists;
     this.relations = {};
-    this.initializeModelProperties();
+    initializeEntityModelProperties(this, this.getRepositoryRuntime());
   }
   attributes;
   original;
@@ -6613,6 +6750,10 @@ var EntityBase = class _EntityBase {
     Object.assign(this.attributes, values);
     return this;
   }
+  async update(values) {
+    this.fill(values);
+    return await this.save();
+  }
   forceFill(values) {
     Object.assign(this.attributes, values);
     return this;
@@ -6744,6 +6885,75 @@ var EntityBase = class _EntityBase {
     Reflect.deleteProperty(this.relations, name);
     return this;
   }
+  relation(name) {
+    const repo = this.getRepositoryRuntime();
+    const relationDef = typeof repo.getRelationDefinition === "function" ? repo.getRelationDefinition(name) : repo.definition.relations[name];
+    if (!relationDef) {
+      throw new Error(`Relation '${name}' is not defined on this model`);
+    }
+    if (relationDef.kind === "belongsTo") {
+      return {
+        associate: (related) => {
+          this.associate(name, related);
+        },
+        dissociate: () => {
+          this.dissociate(name);
+        }
+      };
+    }
+    if (relationDef.kind === "hasOne" || relationDef.kind === "hasOneOfMany" || relationDef.kind === "hasOneThrough" || relationDef.kind === "morphOne" || relationDef.kind === "morphOneOfMany") {
+      return {
+        create: async (values) => {
+          return this.createRelated(name, values);
+        },
+        save: async (related) => {
+          return this.saveRelated(name, related);
+        }
+      };
+    }
+    if (relationDef.kind === "hasMany" || relationDef.kind === "hasManyThrough" || relationDef.kind === "morphMany") {
+      return {
+        create: async (values) => {
+          return this.createRelated(name, values);
+        },
+        createMany: async (values) => {
+          return this.createManyRelated(name, values);
+        },
+        save: async (related) => {
+          return this.saveRelated(name, related);
+        },
+        saveMany: async (related) => {
+          return this.saveManyRelated(name, related);
+        }
+      };
+    }
+    if (relationDef.kind === "belongsToMany" || relationDef.kind === "morphToMany" || relationDef.kind === "morphedByMany") {
+      return {
+        attach: async (ids, attributes) => {
+          await this.attach(name, ids, attributes ?? {});
+        },
+        detach: async (ids) => {
+          return this.detach(name, ids);
+        },
+        sync: async (ids) => {
+          return this.sync(name, ids);
+        },
+        toggle: async (ids) => {
+          return this.toggle(name, ids);
+        },
+        updateExistingPivot: async (id, attributes) => {
+          return this.updateExistingPivot(name, id, attributes);
+        },
+        create: async (values) => {
+          return this.createRelated(name, values);
+        },
+        save: async (related) => {
+          return this.saveRelated(name, related);
+        }
+      };
+    }
+    return {};
+  }
   toJSON() {
     const repo = this.getRepositoryRuntime();
     if (typeof repo.serializeEntity === "function") {
@@ -6751,19 +6961,68 @@ var EntityBase = class _EntityBase {
     }
     return this.toAttributes();
   }
-  async save() {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.saveEntity !== "function") {
-      throw new HydrationError("The bound repository cannot persist entities.");
-    }
-    const pendingChanges = this.persisted ? this.getDirty() : this.toAttributes();
-    const persisted = await repo.saveEntity(this);
+  applyPersistedEntity(persisted, changes) {
     this.attributes = { ...persisted.toAttributes() };
     this.original = { ...persisted.toAttributes() };
-    this.changes = { ...pendingChanges };
+    this.changes = { ...changes };
     this.persisted = true;
+  }
+  async persistEntity(methodName, errorMessage) {
+    const repo = this.getRepositoryRuntime();
+    const method = repo[methodName];
+    if (typeof method !== "function") {
+      throw new HydrationError(errorMessage);
+    }
+    const pendingChanges = this.persisted ? this.getDirty() : this.toAttributes();
+    const persisted = await method.call(repo, this);
+    this.applyPersistedEntity(persisted, pendingChanges);
+    return this;
+  }
+  async deletePersistedEntity(methodName, errorMessage) {
+    if (!this.persisted) {
+      throw new HydrationError("Cannot delete an entity that has not been persisted yet.");
+    }
+    const repo = this.getRepositoryRuntime();
+    const method = repo[methodName];
+    if (typeof method !== "function") {
+      throw new HydrationError(errorMessage);
+    }
+    await method.call(repo, this);
+    this.persisted = typeof repo.shouldKeepEntityPersistedOnDelete === "function" ? repo.shouldKeepEntityPersistedOnDelete(this) : false;
+  }
+  async restoreEntity(methodName, errorMessage) {
+    const repo = this.getRepositoryRuntime();
+    const method = repo[methodName];
+    if (typeof method !== "function") {
+      throw new HydrationError(errorMessage);
+    }
+    const restored = await method.call(repo, this);
+    this.applyPersistedEntity(restored, restored.getChanges());
+    return this;
+  }
+  async forceDeletePersistedEntity(methodName, errorMessage) {
+    if (!this.persisted) {
+      throw new HydrationError("Cannot force-delete an entity that has not been persisted yet.");
+    }
+    const repo = this.getRepositoryRuntime();
+    const method = repo[methodName];
+    if (typeof method !== "function") {
+      throw new HydrationError(errorMessage);
+    }
+    await method.call(repo, this);
+    this.persisted = false;
+  }
+  async loadAggregateDefinitions(aggregates) {
+    const repo = this.getRepositoryRuntime();
+    if (typeof repo.loadRelationAggregates !== "function") {
+      throw new HydrationError("The bound repository cannot load relation aggregates.");
+    }
+    await repo.loadRelationAggregates([this], aggregates);
     return this;
   }
+  async save() {
+    return this.persistEntity("saveEntity", "The bound repository cannot persist entities.");
+  }
   async push() {
     const repo = this.getRepositoryRuntime();
     if (typeof repo.getRelationDefinition !== "function") {
@@ -6801,85 +7060,25 @@ var EntityBase = class _EntityBase {
     return this;
   }
   async saveQuietly() {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.saveEntityQuietly !== "function") {
-      throw new HydrationError("The bound repository cannot persist entities quietly.");
-    }
-    const pendingChanges = this.persisted ? this.getDirty() : this.toAttributes();
-    const persisted = await repo.saveEntityQuietly(this);
-    this.attributes = { ...persisted.toAttributes() };
-    this.original = { ...persisted.toAttributes() };
-    this.changes = { ...pendingChanges };
-    this.persisted = true;
-    return this;
+    return this.persistEntity("saveEntityQuietly", "The bound repository cannot persist entities quietly.");
   }
   async delete() {
-    if (!this.persisted) {
-      throw new HydrationError("Cannot delete an entity that has not been persisted yet.");
-    }
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.deleteEntity !== "function") {
-      throw new HydrationError("The bound repository cannot delete entities.");
-    }
-    await repo.deleteEntity(this);
-    this.persisted = typeof repo.shouldKeepEntityPersistedOnDelete === "function" ? repo.shouldKeepEntityPersistedOnDelete(this) : false;
+    await this.deletePersistedEntity("deleteEntity", "The bound repository cannot delete entities.");
   }
   async deleteQuietly() {
-    if (!this.persisted) {
-      throw new HydrationError("Cannot delete an entity that has not been persisted yet.");
-    }
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.deleteEntityQuietly !== "function") {
-      throw new HydrationError("The bound repository cannot delete entities quietly.");
-    }
-    await repo.deleteEntityQuietly(this);
-    this.persisted = typeof repo.shouldKeepEntityPersistedOnDelete === "function" ? repo.shouldKeepEntityPersistedOnDelete(this) : false;
+    await this.deletePersistedEntity("deleteEntityQuietly", "The bound repository cannot delete entities quietly.");
   }
   async restore() {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.restoreEntity !== "function") {
-      throw new HydrationError("The bound repository cannot restore entities.");
-    }
-    const restored = await repo.restoreEntity(this);
-    this.attributes = { ...restored.toAttributes() };
-    this.original = { ...restored.toAttributes() };
-    this.changes = { ...restored.getChanges() };
-    this.persisted = true;
-    return this;
+    return this.restoreEntity("restoreEntity", "The bound repository cannot restore entities.");
   }
   async restoreQuietly() {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.restoreEntityQuietly !== "function") {
-      throw new HydrationError("The bound repository cannot restore entities quietly.");
-    }
-    const restored = await repo.restoreEntityQuietly(this);
-    this.attributes = { ...restored.toAttributes() };
-    this.original = { ...restored.toAttributes() };
-    this.changes = { ...restored.getChanges() };
-    this.persisted = true;
-    return this;
+    return this.restoreEntity("restoreEntityQuietly", "The bound repository cannot restore entities quietly.");
   }
   async forceDelete() {
-    if (!this.persisted) {
-      throw new HydrationError("Cannot force-delete an entity that has not been persisted yet.");
-    }
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.forceDeleteEntity !== "function") {
-      throw new HydrationError("The bound repository cannot force-delete entities.");
-    }
-    await repo.forceDeleteEntity(this);
-    this.persisted = false;
+    await this.forceDeletePersistedEntity("forceDeleteEntity", "The bound repository cannot force-delete entities.");
   }
   async forceDeleteQuietly() {
-    if (!this.persisted) {
-      throw new HydrationError("Cannot force-delete an entity that has not been persisted yet.");
-    }
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.forceDeleteEntityQuietly !== "function") {
-      throw new HydrationError("The bound repository cannot force-delete entities quietly.");
-    }
-    await repo.forceDeleteEntityQuietly(this);
-    this.persisted = false;
+    await this.forceDeletePersistedEntity("forceDeleteEntityQuietly", "The bound repository cannot force-delete entities quietly.");
   }
   async fresh() {
     const repo = this.getRepositoryRuntime();
@@ -6936,52 +7135,22 @@ var EntityBase = class _EntityBase {
     return this;
   }
   async loadCount(...relations) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], relations.map((relation) => ({ relation, kind: "count" })));
-    return this;
+    return this.loadAggregateDefinitions(relations.map((relation) => ({ relation, kind: "count" })));
   }
   async loadExists(...relations) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], relations.map((relation) => ({ relation, kind: "exists" })));
-    return this;
+    return this.loadAggregateDefinitions(relations.map((relation) => ({ relation, kind: "exists" })));
   }
   async loadSum(relation, column2) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], [{ relation, kind: "sum", column: column2 }]);
-    return this;
+    return this.loadAggregateDefinitions([{ relation, kind: "sum", column: column2 }]);
   }
   async loadAvg(relation, column2) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], [{ relation, kind: "avg", column: column2 }]);
-    return this;
+    return this.loadAggregateDefinitions([{ relation, kind: "avg", column: column2 }]);
   }
   async loadMin(relation, column2) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], [{ relation, kind: "min", column: column2 }]);
-    return this;
+    return this.loadAggregateDefinitions([{ relation, kind: "min", column: column2 }]);
   }
   async loadMax(relation, column2) {
-    const repo = this.getRepositoryRuntime();
-    if (typeof repo.loadRelationAggregates !== "function") {
-      throw new HydrationError("The bound repository cannot load relation aggregates.");
-    }
-    await repo.loadRelationAggregates([this], [{ relation, kind: "max", column: column2 }]);
-    return this;
+    return this.loadAggregateDefinitions([{ relation, kind: "max", column: column2 }]);
   }
   associate(relation, related) {
     const repo = this.getRepositoryRuntime();
@@ -7108,47 +7277,6 @@ var EntityBase = class _EntityBase {
     this.forgetRelation(relation);
     return result;
   }
-  initializeModelProperties() {
-    const repo = this.getRepositoryRuntime();
-    const columns = repo?.definition?.table?.columns;
-    if (columns && typeof columns === "object") {
-      for (const key of Object.keys(columns)) {
-        if (key in this) {
-          continue;
-        }
-        Object.defineProperty(this, key, {
-          configurable: true,
-          enumerable: true,
-          get: () => this.get(key),
-          set: (value) => {
-            this.set(key, value);
-          }
-        });
-      }
-    }
-    const relationNames = typeof repo?.getRelationNames === "function" ? repo.getRelationNames() : Object.keys(repo?.definition?.relations ?? {});
-    for (const key of relationNames) {
-      if (key in this) {
-        continue;
-      }
-      Object.defineProperty(this, key, {
-        configurable: true,
-        enumerable: false,
-        get: () => {
-          if (this.hasRelation(key)) {
-            return this.getRelation(key);
-          }
-          if (typeof repo?.resolveRelationProperty === "function") {
-            return repo.resolveRelationProperty(this, key);
-          }
-          return void 0;
-        },
-        set: (value) => {
-          this.setRelation(key, value);
-        }
-      });
-    }
-  }
 };
 var Entity = EntityBase;
 
@@ -7156,6 +7284,14 @@ var Entity = EntityBase;
 function createModelCollection(items) {
   const collection = [...items];
   const getRepository = (entity) => entity.getRepository();
+  const loadRelationAggregates = async (aggregates) => {
+    const first = collection[0];
+    if (!first || aggregates.length === 0) {
+      return collection;
+    }
+    await getRepository(first).loadRelationAggregates(collection, aggregates);
+    return collection;
+  };
   const methods = {
     modelKeys() {
       return collection.map((entity) => {
@@ -7171,6 +7307,9 @@ function createModelCollection(items) {
       const repo = getRepository(first);
       return repo.query().where(repo.definition.primaryKey, "in", this.modelKeys());
     },
+    toJSON() {
+      return collection.map((item) => item.toJSON());
+    },
     async load(...relations) {
       const first = collection[0];
       if (!first || relations.length === 0) {
@@ -7202,58 +7341,22 @@ function createModelCollection(items) {
       return collection;
     },
     async loadCount(...relations) {
-      const first = collection[0];
-      if (!first || relations.length === 0) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, relations.map((relation) => ({ relation, kind: "count" })));
-      return collection;
+      return loadRelationAggregates(relations.map((relation) => ({ relation, kind: "count" })));
     },
     async loadExists(...relations) {
-      const first = collection[0];
-      if (!first || relations.length === 0) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, relations.map((relation) => ({ relation, kind: "exists" })));
-      return collection;
+      return loadRelationAggregates(relations.map((relation) => ({ relation, kind: "exists" })));
     },
     async loadSum(relation, column2) {
-      const first = collection[0];
-      if (!first || !relation) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, [{ relation, kind: "sum", column: column2 }]);
-      return collection;
+      return loadRelationAggregates(relation ? [{ relation, kind: "sum", column: column2 }] : []);
     },
     async loadAvg(relation, column2) {
-      const first = collection[0];
-      if (!first || !relation) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, [{ relation, kind: "avg", column: column2 }]);
-      return collection;
+      return loadRelationAggregates(relation ? [{ relation, kind: "avg", column: column2 }] : []);
     },
     async loadMin(relation, column2) {
-      const first = collection[0];
-      if (!first || !relation) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, [{ relation, kind: "min", column: column2 }]);
-      return collection;
+      return loadRelationAggregates(relation ? [{ relation, kind: "min", column: column2 }] : []);
     },
     async loadMax(relation, column2) {
-      const first = collection[0];
-      if (!first || !relation) {
-        return collection;
-      }
-      const repo = getRepository(first);
-      await repo.loadRelationAggregates(collection, [{ relation, kind: "max", column: column2 }]);
-      return collection;
+      return loadRelationAggregates(relation ? [{ relation, kind: "max", column: column2 }] : []);
     },
     async fresh() {
       const refreshed = await Promise.all(
@@ -7361,118 +7464,65 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
   getTableQueryBuilder() {
     return this.tableQuery;
   }
+  collectNestedPredicates(callback) {
+    const nested = new _ModelQueryBuilder(
+      this.repository,
+      new TableQueryBuilder(this.repository.definition.table, this.getConnection())
+    );
+    const callbackResult = callback(nested);
+    const result = callbackResult instanceof _ModelQueryBuilder ? callbackResult : nested;
+    return result.getTableQueryBuilder().getPlan().predicates;
+  }
+  replayNestedPredicates(query, predicates) {
+    let next = query;
+    for (const predicate of predicates) {
+      next = new TableQueryBuilder(
+        this.repository.definition.table,
+        this.getConnection(),
+        {
+          ...next.getPlan(),
+          predicates: Object.freeze([...next.getPlan().predicates, predicate])
+        }
+      );
+    }
+    return next;
+  }
   from(table) {
     return this.clone(this.tableQuery.from(table));
   }
   where(columnOrCallback, operator, value) {
     if (typeof columnOrCallback === "function") {
-      const nested = new _ModelQueryBuilder(
-        this.repository,
-        new TableQueryBuilder(this.repository.definition.table, this.getConnection())
-      );
-      const callbackResult = columnOrCallback(nested);
-      const result = callbackResult instanceof _ModelQueryBuilder ? callbackResult : nested;
-      const predicates = result.getTableQueryBuilder().getPlan().predicates;
+      const predicates = this.collectNestedPredicates(columnOrCallback);
       if (predicates.length === 0) {
         return this;
       }
-      return this.clone(this.tableQuery.where((query) => {
-        let next = query;
-        for (const predicate of predicates) {
-          next = new TableQueryBuilder(
-            this.repository.definition.table,
-            this.getConnection(),
-            {
-              ...next.getPlan(),
-              predicates: Object.freeze([...next.getPlan().predicates, predicate])
-            }
-          );
-        }
-        return next;
-      }));
+      return this.clone(this.tableQuery.where((query) => this.replayNestedPredicates(query, predicates)));
     }
     return this.clone(this.tableQuery.where(columnOrCallback, operator, value));
   }
   orWhere(columnOrCallback, operator, value) {
     if (typeof columnOrCallback === "function") {
-      const nested = new _ModelQueryBuilder(
-        this.repository,
-        new TableQueryBuilder(this.repository.definition.table, this.getConnection())
-      );
-      const callbackResult = columnOrCallback(nested);
-      const result = callbackResult instanceof _ModelQueryBuilder ? callbackResult : nested;
-      const predicates = result.getTableQueryBuilder().getPlan().predicates;
+      const predicates = this.collectNestedPredicates(columnOrCallback);
       if (predicates.length === 0) {
         return this;
       }
-      return this.clone(this.tableQuery.orWhere((query) => {
-        let next = query;
-        for (const predicate of predicates) {
-          next = new TableQueryBuilder(
-            this.repository.definition.table,
-            this.getConnection(),
-            {
-              ...next.getPlan(),
-              predicates: Object.freeze([...next.getPlan().predicates, predicate])
-            }
-          );
-        }
-        return next;
-      }));
+      return this.clone(this.tableQuery.orWhere((query) => this.replayNestedPredicates(query, predicates)));
     }
     return this.clone(this.tableQuery.orWhere(columnOrCallback, operator, value));
   }
   whereNot(callback) {
-    const nested = new _ModelQueryBuilder(
-      this.repository,
-      new TableQueryBuilder(this.repository.definition.table, this.getConnection())
-    );
-    const callbackResult = callback(nested);
-    const result = callbackResult instanceof _ModelQueryBuilder ? callbackResult : nested;
-    const predicates = result.getTableQueryBuilder().getPlan().predicates;
+    const predicates = this.collectNestedPredicates(callback);
     if (predicates.length === 0) {
       return this;
     }
-    return this.clone(this.tableQuery.whereNot((query) => {
-      let next = query;
-      for (const predicate of predicates) {
-        next = new TableQueryBuilder(
-          this.repository.definition.table,
-          this.getConnection(),
-          {
-            ...next.getPlan(),
-            predicates: Object.freeze([...next.getPlan().predicates, predicate])
-          }
-        );
-      }
-      return next;
-    }));
+    return this.clone(this.tableQuery.whereNot((query) => this.replayNestedPredicates(query, predicates)));
   }
   orWhereNot(callback) {
-    const nested = new _ModelQueryBuilder(
-      this.repository,
-      new TableQueryBuilder(this.repository.definition.table, this.getConnection())
-    );
-    const callbackResult = callback(nested);
-    const result = callbackResult instanceof _ModelQueryBuilder ? callbackResult : nested;
-    const predicates = result.getTableQueryBuilder().getPlan().predicates;
+    const predicates = this.collectNestedPredicates(callback);
     if (predicates.length === 0) {
       return this;
     }
-    return this.clone(this.tableQuery.orWhereNot((query) => {
-      let next = query;
-      for (const predicate of predicates) {
-        next = new TableQueryBuilder(
-          this.repository.definition.table,
-          this.getConnection(),
-          {
-            ...next.getPlan(),
-            predicates: Object.freeze([...next.getPlan().predicates, predicate])
-          }
-        );
-      }
-      return next;
-    }));
+    return this.clone(this.tableQuery.orWhereNot((query) => this.replayNestedPredicates(query, predicates)));
   }
   whereExists(subquery) {
     return this.clone(this.tableQuery.whereExists(this.normalizeExistsSubquery(subquery)));
@@ -7846,10 +7896,16 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     await this.repository.loadRelationAggregates(entities, this.aggregateLoads);
     return this.repository.createCollection(entities);
   }
+  async getJson() {
+    return (await this.get()).toJSON();
+  }
   async first() {
     const [entity] = await this.limit(1).get();
     return entity;
   }
+  async firstJson() {
+    return (await this.first())?.toJSON();
+  }
   async sole() {
     const entities = await this.limit(2).get();
     if (entities.length === 0) {
@@ -7860,6 +7916,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
     return entities[0];
   }
+  async soleJson() {
+    return (await this.sole()).toJSON();
+  }
   async paginate(perPage = 15, page = 1, options = {}) {
     assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
     assertPositiveInteger(page, "Page", (message) => new HydrationError(message));
@@ -7881,6 +7940,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
       hasMorePages: offset + data.length < total
     });
   }
+  async paginateJson(perPage = 15, page = 1, options = {}) {
+    return (await this.paginate(perPage, page, options)).toJSON();
+  }
   async simplePaginate(perPage = 15, page = 1, options = {}) {
     assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
     assertPositiveInteger(page, "Page", (message) => new HydrationError(message));
@@ -7901,6 +7963,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
       hasMorePages
     });
   }
+  async simplePaginateJson(perPage = 15, page = 1, options = {}) {
+    return (await this.simplePaginate(perPage, page, options)).toJSON();
+  }
   async cursorPaginate(perPage = 15, cursor = null, options = {}) {
     assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
     const cursorName = normalizePaginationParameterName(options.cursorName, "cursor", (message) => new HydrationError(message));
@@ -7917,6 +7982,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
       prevCursor: cursor
     });
   }
+  async cursorPaginateJson(perPage = 15, cursor = null, options = {}) {
+    return (await this.cursorPaginate(perPage, cursor, options)).toJSON();
+  }
   async chunk(size, callback) {
     assertPositiveInteger(size, "Chunk size", (message) => new HydrationError(message));
     const entities = await this.getUnpaginatedEntities();
@@ -8062,6 +8130,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
     return entity;
   }
+  async findOrFailJson(value, column2) {
+    return (await this.findOrFail(value, column2)).toJSON();
+  }
   async update(values) {
     return this.tableQuery.update(this.repository.sanitizeWritePayload(values, "update"));
   }
@@ -8168,6 +8239,9 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     );
   }
   normalizeEagerLoads(first, second, rest = []) {
+    if (Array.isArray(first)) {
+      return first.map((relation) => ({ relation }));
+    }
     if (typeof first === "string") {
       if (typeof second === "function") {
         return [{ relation: first, constraint: second }];
@@ -8432,6 +8506,13 @@ function resolveModelConnection(definition) {
   }
   return DB.connection(definition.connectionName);
 }
+function resolveActiveConnection(connection) {
+  const active = connectionAsyncContext.getActive();
+  if (active && active.connectionName === connection.getConnectionName() && active.connection.getContextId() === connection.getContextId()) {
+    return active.connection;
+  }
+  return connection;
+}
 var ModelRepository = class _ModelRepository {
   constructor(definition, connection) {
     this.connection = connection;
@@ -8443,10 +8524,10 @@ var ModelRepository = class _ModelRepository {
     return new _ModelRepository(definition, connection ?? resolveModelConnection(definition));
   }
   getConnection() {
-    return this.connection;
+    return resolveActiveConnection(this.connection);
   }
   getConnectionName() {
-    return this.connection.getConnectionName();
+    return this.getConnection().getConnectionName();
   }
   getDeletedAtColumn() {
     return this.definition.deletedAtColumn;
@@ -8550,7 +8631,18 @@ var ModelRepository = class _ModelRepository {
     if (existing) {
       return existing;
     }
-    return this.create({ ...match, ...values });
+    try {
+      return await this.create({ ...match, ...values });
+    } catch (error) {
+      if (!isUniqueConstraintError(error)) {
+        throw error;
+      }
+      const concurrent = await query.first();
+      if (concurrent) {
+        return concurrent;
+      }
+      throw error;
+    }
   }
   make(values = {}) {
     return new Entity(this, this.sanitizeWritePayload(this.applyPendingAttributes(values), "create"), false);
@@ -9229,10 +9321,11 @@ var ModelRepository = class _ModelRepository {
     });
   }
   async runWriteUnit(callback) {
-    if (this.connection.getScope().kind !== "root") {
+    const connection = this.getConnection();
+    if (connection.getScope().kind !== "root") {
       return callback();
     }
-    return this.connection.transaction(async () => callback());
+    return connection.transaction(async () => callback());
   }
   async forceDeleteEntityQuietly(entity) {
     return withoutModelEvents(() => this.forceDeleteEntity(entity));
@@ -9266,7 +9359,7 @@ var ModelRepository = class _ModelRepository {
     if (entries.length === 0) {
       return;
     }
-    await this.connection.transaction(async (tx) => {
+    await this.getConnection().transaction(async (tx) => {
       const currentRows = await this.getPivotRows(context, tx, entries.map((entry) => entry.id));
       const currentMap = this.indexPivotRows(currentRows, this.getPivotRelatedIdColumn(context.relation));
       for (const entry of entries) {
@@ -9283,7 +9376,7 @@ var ModelRepository = class _ModelRepository {
   }
   async detachRelation(entity, relationName, ids) {
     const context = this.getPivotMutationContext(entity, relationName);
-    return this.connection.transaction(async (tx) => {
+    return this.getConnection().transaction(async (tx) => {
       if (typeof ids === "undefined" || ids === null) {
         return this.deletePivotRows(context, tx);
       }
@@ -9300,7 +9393,7 @@ var ModelRepository = class _ModelRepository {
     this.assertValidPivotEntries(relationName, entries, context.relation);
     const desiredMap = new Map(entries.map((entry) => [String(entry.id), entry]));
     const result = { attached: [], detached: [], updated: [] };
-    await this.connection.transaction(async (tx) => {
+    await this.getConnection().transaction(async (tx) => {
       const currentRows = await this.getPivotRows(context, tx);
       const currentMap = this.indexPivotRows(currentRows, this.getPivotRelatedIdColumn(context.relation));
       for (const entry of entries) {
@@ -9329,10 +9422,10 @@ var ModelRepository = class _ModelRepository {
     const context = this.getPivotMutationContext(entity, relationName);
     this.assertValidPivotAttributes(relationName, attributes, context.relation);
     if (Object.keys(attributes).length === 0) return 0;
-    const [existing] = await this.getPivotRows(context, this.connection, [id]);
+    const [existing] = await this.getPivotRows(context, this.getConnection(), [id]);
     if (!existing) return 0;
     if (!this.pivotAttributesChanged(existing, attributes, context.relation)) return 0;
-    await this.updatePivotRow(context, this.connection, id, attributes);
+    await this.updatePivotRow(context, this.getConnection(), id, attributes);
     return 1;
   }
   async toggleRelation(entity, relationName, ids) {
@@ -9343,7 +9436,7 @@ var ModelRepository = class _ModelRepository {
     if (entries.length === 0) {
       return result;
     }
-    await this.connection.transaction(async (tx) => {
+    await this.getConnection().transaction(async (tx) => {
       const currentRows = await this.getPivotRows(context, tx, entries.map((entry) => entry.id));
       const currentMap = this.indexPivotRows(currentRows, this.getPivotRelatedIdColumn(context.relation));
       for (const entry of entries) {
@@ -9404,7 +9497,7 @@ var ModelRepository = class _ModelRepository {
   createQuery(applySoftDeletes, applyGlobalScopes, applyDefaultRelations, excludedGlobalScopes = /* @__PURE__ */ new Set()) {
     let query = new ModelQueryBuilder(
       this,
-      new TableQueryBuilder(this.definition.table, this.connection)
+      new TableQueryBuilder(this.definition.table, this.getConnection())
     );
     const deletedAtColumn = this.getDeletedAtColumn();
     if (applySoftDeletes && deletedAtColumn) {
@@ -9554,7 +9647,7 @@ var ModelRepository = class _ModelRepository {
       }
       return;
     }
-    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.connection).where(relation.foreignPivotKey, "in", parentKeys).get();
+    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.getConnection()).where(relation.foreignPivotKey, "in", parentKeys).get();
     if (pivotRows.length === 0) {
       for (const entity of entities) {
         entity.setRelation(relationName, []);
@@ -9731,17 +9824,17 @@ var ModelRepository = class _ModelRepository {
       }
       case "belongsToMany": {
         const related = this.resolveRelatedRepository(relation.related);
-        const pivotSubquery = this.createBelongsToManyPivotQuery(relation, this.connection).select(relation.relatedPivotKey).whereColumn(relation.foreignPivotKey, "=", this.qualifyParentColumn(relation.parentKey));
+        const pivotSubquery = this.createBelongsToManyPivotQuery(relation, this.getConnection()).select(relation.relatedPivotKey).whereColumn(relation.foreignPivotKey, "=", this.qualifyParentColumn(relation.parentKey));
         return [this.applyRelationConstraint(relation, related, constraint).getTableQueryBuilder().whereInSub(relation.relatedKey, pivotSubquery)];
       }
       case "morphToMany": {
         const related = this.resolveRelatedRepository(relation.related);
-        const pivotSubquery = this.createMorphToManyPivotQuery(relation, this.connection).select(relation.foreignPivotKey).where(relation.morphTypeColumn, this.getMorphTypeValue()).whereColumn(relation.morphIdColumn, "=", this.qualifyParentColumn(relation.parentKey));
+        const pivotSubquery = this.createMorphToManyPivotQuery(relation, this.getConnection()).select(relation.foreignPivotKey).where(relation.morphTypeColumn, this.getMorphTypeValue()).whereColumn(relation.morphIdColumn, "=", this.qualifyParentColumn(relation.parentKey));
         return [this.applyRelationConstraint(relation, related, constraint).getTableQueryBuilder().whereInSub(relation.relatedKey, pivotSubquery)];
       }
       case "morphedByMany": {
         const related = this.resolveRelatedRepository(relation.related);
-        const pivotSubquery = this.createMorphedByManyPivotQuery(relation, related.definition.morphClass, this.connection).select(relation.morphIdColumn).whereColumn(relation.foreignPivotKey, "=", this.qualifyParentColumn(relation.parentKey));
+        const pivotSubquery = this.createMorphedByManyPivotQuery(relation, related.definition.morphClass, this.getConnection()).select(relation.morphIdColumn).whereColumn(relation.foreignPivotKey, "=", this.qualifyParentColumn(relation.parentKey));
         return [this.applyRelationConstraint(relation, related, constraint).getTableQueryBuilder().whereInSub(relation.relatedKey, pivotSubquery)];
       }
     }
@@ -10305,7 +10398,7 @@ var ModelRepository = class _ModelRepository {
     if (parentKeys.length === 0) {
       return /* @__PURE__ */ new Set();
     }
-    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.connection).where(relation.foreignPivotKey, "in", parentKeys).get();
+    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.getConnection()).where(relation.foreignPivotKey, "in", parentKeys).get();
     const relatedIds = [...new Set(
       pivotRows.map((row) => row[relation.relatedPivotKey]).filter((value) => value !== null && typeof value !== "undefined")
     )];
@@ -10338,7 +10431,7 @@ var ModelRepository = class _ModelRepository {
     if (parentKeys.length === 0) {
       return /* @__PURE__ */ new Map();
     }
-    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.connection).where(relation.foreignPivotKey, "in", parentKeys).get();
+    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.getConnection()).where(relation.foreignPivotKey, "in", parentKeys).get();
     const relatedIds = [...new Set(
       pivotRows.map((row) => row[relation.relatedPivotKey]).filter((value) => value !== null && typeof value !== "undefined")
     )];
@@ -10381,7 +10474,7 @@ var ModelRepository = class _ModelRepository {
     if (parentKeys.length === 0) {
       return /* @__PURE__ */ new Map();
     }
-    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.connection).where(relation.foreignPivotKey, "in", parentKeys).get();
+    const pivotRows = await this.createBelongsToManyPivotQuery(relation, this.getConnection()).where(relation.foreignPivotKey, "in", parentKeys).get();
     const relatedIds = [...new Set(
       pivotRows.map((row) => row[relation.relatedPivotKey]).filter((value) => value !== null && typeof value !== "undefined")
     )];
@@ -10414,7 +10507,7 @@ var ModelRepository = class _ModelRepository {
     if (parentKeys.length === 0) {
       return /* @__PURE__ */ new Map();
     }
-    const pivotRows = await this.createMorphToManyPivotQuery(relation, this.connection).where(relation.morphTypeColumn, this.getMorphTypeValue()).where(relation.morphIdColumn, "in", parentKeys).get();
+    const pivotRows = await this.createMorphToManyPivotQuery(relation, this.getConnection()).where(relation.morphTypeColumn, this.getMorphTypeValue()).where(relation.morphIdColumn, "in", parentKeys).get();
     const relatedIds = [...new Set(
       pivotRows.map((row) => row[relation.foreignPivotKey]).filter((value) => value !== null && typeof value !== "undefined")
     )];
@@ -10448,7 +10541,7 @@ var ModelRepository = class _ModelRepository {
       return /* @__PURE__ */ new Map();
     }
     const related = this.resolveRelatedRepository(relation.related);
-    const pivotRows = await this.createMorphedByManyPivotQuery(relation, related.definition.morphClass, this.connection).where(relation.foreignPivotKey, "in", parentKeys).get();
+    const pivotRows = await this.createMorphedByManyPivotQuery(relation, related.definition.morphClass, this.getConnection()).where(relation.foreignPivotKey, "in", parentKeys).get();
     const relatedIds = [...new Set(
       pivotRows.map((row) => row[relation.morphIdColumn]).filter((value) => value !== null && typeof value !== "undefined")
     )];
@@ -10943,7 +11036,7 @@ var ModelRepository = class _ModelRepository {
     return normalizeDialectWriteValue(this.getSchemaDialectName(), column2, value);
   }
   getSchemaDialectName() {
-    return this.connection.getDriver();
+    return this.getConnection().getDriver();
   }
   applyCastGet(cast, value) {
     const builtInCast = this.parseBuiltInCast(cast);
@@ -11093,37 +11186,25 @@ var ModelRepository = class _ModelRepository {
     return parameter.replaceAll(/[YmdHis]/g, (token) => parts[token]);
   }
 };
-
-// src/model/ModelRegistry.ts
-function resolveDefinition(reference) {
-  return "definition" in reference ? reference.definition : reference;
+function getErrorCode(error) {
+  return error && typeof error === "object" && "code" in error ? error.code : void 0;
 }
-var ModelRegistry = class {
-  models = /* @__PURE__ */ new Map();
-  register(reference) {
-    const definition = resolveDefinition(reference);
-    const existing = this.models.get(definition.name);
-    if (existing && existing !== definition) {
-      throw new DatabaseError(`Model "${definition.name}" is already registered.`, "DUPLICATE_MODEL");
+function getErrorCause(error) {
+  return error && typeof error === "object" && "cause" in error ? error.cause : void 0;
+}
+function isUniqueConstraintError(error) {
+  let current = error;
+  while (current) {
+    const code = getErrorCode(current);
+    if (code === "23505" || code === 1062 || code === "1062" || code === "ER_DUP_ENTRY" || code === "SQLITE_CONSTRAINT" || code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+      return true;
     }
-    this.models.set(definition.name, definition);
-    return definition;
-  }
-  has(name) {
-    return this.models.has(name);
-  }
-  get(name) {
-    return this.models.get(name);
-  }
-  list() {
-    return [...this.models.values()];
-  }
-  clear() {
-    this.models.clear();
+    if (current instanceof Error && /unique constraint|duplicate entry|unique constraint failed/i.test(current.message)) {
+      return true;
+    }
+    current = getErrorCause(current);
   }
-};
-function createModelRegistry() {
-  return new ModelRegistry();
+  return false;
 }
 
 // src/core/QueryScheduler.ts
@@ -11152,22 +11233,26 @@ var QueryScheduler = class {
     this.concurrentState = {
       active: 0,
       queued: 0,
-      limit: concurrencyLimit
+      limit: concurrencyLimit,
+      waiters: []
     };
     this.serializedState = {
       active: 0,
       queued: 0,
-      limit: 1
+      limit: 1,
+      waiters: []
     };
     this.workerState = {
       active: 0,
       queued: 0,
-      limit: concurrencyLimit
+      limit: concurrencyLimit,
+      waiters: []
     };
   }
   async schedule(options, callback) {
     const schedulingMode = this.preview(options);
     const state = this.resolveState(schedulingMode);
+    let slotReserved = false;
     if (state.active >= state.limit) {
       if (state.queued >= this.queueLimit) {
         throw new DatabaseError(
@@ -11175,20 +11260,12 @@ var QueryScheduler = class {
           "QUERY_SCHEDULER_BACKPRESSURE"
         );
       }
-      await new Promise((resolve) => {
-        state.queued += 1;
-        const poll = () => {
-          if (state.active < state.limit) {
-            state.queued -= 1;
-            resolve();
-            return;
-          }
-          queueMicrotask(poll);
-        };
-        queueMicrotask(poll);
-      });
+      await this.waitForSlot(state);
+      slotReserved = true;
+    }
+    if (!slotReserved) {
+      state.active += 1;
     }
-    state.active += 1;
     try {
       return {
         result: await callback(schedulingMode),
@@ -11196,6 +11273,7 @@ var QueryScheduler = class {
       };
     } finally {
       state.active -= 1;
+      this.wakeNext(state);
     }
   }
   preview(options) {
@@ -11222,6 +11300,22 @@ var QueryScheduler = class {
     }
     return this.serializedState;
   }
+  waitForSlot(state) {
+    state.queued += 1;
+    return new Promise((resolve) => {
+      state.waiters.push(() => {
+        state.queued -= 1;
+        state.active += 1;
+        resolve();
+      });
+    });
+  }
+  wakeNext(state) {
+    if (state.active >= state.limit) {
+      return;
+    }
+    state.waiters.shift()?.();
+  }
 };
 function createQueryScheduler(options) {
   return new QueryScheduler(options);
@@ -11251,7 +11345,9 @@ function createCapabilities(overrides = {}) {
 }
 
 // src/core/DatabaseContext.ts
+var nextDatabaseContextId = 0;
 var DatabaseContext = class _DatabaseContext {
+  _contextId;
   _connectionName;
   _schemaName;
   _adapter;
@@ -11271,6 +11367,7 @@ var DatabaseContext = class _DatabaseContext {
   constructor(options) {
     if (!options.adapter) throw new ConfigurationError("DatabaseContext requires an adapter.");
     if (!options.dialect) throw new ConfigurationError("DatabaseContext requires a dialect.");
+    this._contextId = "contextId" in options ? options.contextId : nextDatabaseContextId += 1;
     this._connectionName = options.connectionName || "default";
     this._schemaName = "schemaName" in options ? options.schemaName : void 0;
     this._adapter = options.adapter;
@@ -11286,6 +11383,7 @@ var DatabaseContext = class _DatabaseContext {
     this._modelRegistry = ("modelRegistry" in options ? options.modelRegistry : void 0) ?? createModelRegistry();
     this._runtime = "runtime" in options ? options.runtime : {
       savepointCounter: 0,
+      rootTransactionTail: Promise.resolve(),
       scheduler: createQueryScheduler({
         connectionName: this._connectionName,
         supportsConcurrentQueries: this._dialect.capabilities.concurrentQueries,
@@ -11316,6 +11414,9 @@ var DatabaseContext = class _DatabaseContext {
   getConnectionName() {
     return this._connectionName;
   }
+  getContextId() {
+    return this._contextId;
+  }
   getSchemaName() {
     return this._schemaName;
   }
@@ -11438,40 +11539,72 @@ var DatabaseContext = class _DatabaseContext {
   }
   async _runRootTransaction(callback, options) {
     const runWithinScope = this._adapter.runWithTransactionScope?.bind(this._adapter) ?? (async (runner) => runner());
-    return runWithinScope(async () => {
-      const entry = {
-        scope: "transaction",
-        depth: 1
-      };
+    const entry = {
+      scope: "transaction",
+      depth: 1
+    };
+    let tx;
+    let committed = false;
+    const runTransaction = async () => {
       await this._logger?.onTransactionStart?.(entry);
-      await this._callTransactionHook("begin", () => this._adapter.beginTransaction(options), options);
-      const tx = this._createChildContext(
-        { kind: "transaction", depth: 1 },
-        this._createTransactionCallbackState()
-      );
-      let committed = false;
       try {
-        const result = await this._runTransactionCallback(tx, callback);
-        await this._callTransactionHook("commit", () => this._adapter.commit(options), options);
-        committed = true;
-        await tx._flushTransactionCallbacks("afterCommit");
+        const result = await runWithinScope(async () => {
+          await this._callTransactionHook("begin", () => this._adapter.beginTransaction(options), options);
+          tx = this._createChildContext(
+            { kind: "transaction", depth: 1 },
+            this._createTransactionCallbackState()
+          );
+          try {
+            const value = await this._runTransactionCallback(tx, callback);
+            await this._callTransactionHook("commit", () => this._adapter.commit(options), options);
+            committed = true;
+            return value;
+          } catch (error) {
+            if (committed) {
+              throw error;
+            }
+            try {
+              await this._callTransactionHook("rollback", () => this._adapter.rollback(options), options);
+            } catch (rollbackError) {
+              await this._logger?.onTransactionRollback?.({ ...entry, error: rollbackError });
+              throw rollbackError;
+            }
+            throw error;
+          }
+        });
+        await tx?._flushTransactionCallbacks("afterCommit");
         await this._logger?.onTransactionCommit?.(entry);
         return result;
       } catch (error) {
         if (committed) {
           throw error;
         }
-        try {
-          await this._callTransactionHook("rollback", () => this._adapter.rollback(options), options);
-        } catch (rollbackError) {
-          await this._logger?.onTransactionRollback?.({ ...entry, error: rollbackError });
-          throw rollbackError;
-        }
-        await tx._flushTransactionCallbacks("afterRollback");
+        await tx?._flushTransactionCallbacks("afterRollback");
         await this._logger?.onTransactionRollback?.({ ...entry, error });
         throw error;
       }
-    });
+    };
+    if (this._adapter.runWithTransactionScope) {
+      return runTransaction();
+    }
+    return this._runSerializedRootTransaction(runTransaction);
+  }
+  async _runSerializedRootTransaction(callback) {
+    const previous = this._runtime.rootTransactionTail;
+    let release;
+    const current = previous.then(() => new Promise((resolve) => {
+      release = resolve;
+    }));
+    this._runtime.rootTransactionTail = current;
+    await previous;
+    try {
+      return await callback();
+    } finally {
+      release();
+      if (this._runtime.rootTransactionTail === current) {
+        this._runtime.rootTransactionTail = Promise.resolve();
+      }
+    }
   }
   async _runNestedTransaction(callback, options) {
     if (!this._dialect.capabilities.savepoints) {
@@ -11538,6 +11671,7 @@ var DatabaseContext = class _DatabaseContext {
   }
   _createChildContext(scope, transactionCallbacks) {
     return new _DatabaseContext({
+      contextId: this._contextId,
       adapter: this._adapter,
       dialect: this._dialect,
       driver: this._driver,
@@ -11828,6 +11962,15 @@ function createConnectionManager(options) {
   return new ConnectionManager(options);
 }
 
+// src/drivers/savepoints.ts
+var SAVEPOINT_NAME_PATTERN = /^[A-Z_]\w*$/i;
+function normalizeSavepointName(name) {
+  if (!SAVEPOINT_NAME_PATTERN.test(name)) {
+    throw new TransactionError(`Invalid savepoint name "${name}".`);
+  }
+  return name;
+}
+
 // src/drivers/index.ts
 function isModuleNotFoundError(error) {
   return !!error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
@@ -11953,22 +12096,13 @@ var SQLiteAdapter = class extends LazyDriverAdapter {
     return module.createSQLiteAdapter(this.options);
   }
   async createSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.createSavepoint(name, options);
+    await super.createSavepoint(normalizeSavepointName(name), options);
   }
   async rollbackToSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.rollbackToSavepoint(name, options);
+    await super.rollbackToSavepoint(normalizeSavepointName(name), options);
   }
   async releaseSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.releaseSavepoint(name, options);
+    await super.releaseSavepoint(normalizeSavepointName(name), options);
   }
 };
 function createSQLiteAdapter(options = {}) {
@@ -11991,32 +12125,14 @@ var PostgresAdapter = class extends LazyDriverAdapter {
     const createPostgresAdapter2 = module.createPostgresAdapter;
     return createPostgresAdapter2(this.options);
   }
-  releaseScopedTransaction(state) {
-    if (state.released) {
-      return;
-    }
-    if (state.leased) {
-      state.client.release?.();
-    }
-    state.released = true;
-  }
   async createSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.createSavepoint(name, options);
+    await super.createSavepoint(normalizeSavepointName(name), options);
   }
   async rollbackToSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.rollbackToSavepoint(name, options);
+    await super.rollbackToSavepoint(normalizeSavepointName(name), options);
   }
   async releaseSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.releaseSavepoint(name, options);
+    await super.releaseSavepoint(normalizeSavepointName(name), options);
   }
 };
 function createPostgresAdapter(options = {}) {
@@ -12039,32 +12155,14 @@ var MySQLAdapter = class extends LazyDriverAdapter {
     const createMySQLAdapter2 = module.createMySQLAdapter;
     return createMySQLAdapter2(this.options);
   }
-  releaseScopedTransaction(state) {
-    if (state.released) {
-      return;
-    }
-    if (state.leased) {
-      state.client.release?.();
-    }
-    state.released = true;
-  }
   async createSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.createSavepoint(name, options);
+    await super.createSavepoint(normalizeSavepointName(name), options);
   }
   async rollbackToSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.rollbackToSavepoint(name, options);
+    await super.rollbackToSavepoint(normalizeSavepointName(name), options);
   }
   async releaseSavepoint(name, options) {
-    if (!/^[A-Z_]\w*$/i.test(name)) {
-      throw new TransactionError(`Invalid savepoint name "${name}".`);
-    }
-    await super.releaseSavepoint(name, options);
+    await super.releaseSavepoint(normalizeSavepointName(name), options);
   }
 };
 function createMySQLAdapter(options = {}) {
@@ -12075,7 +12173,6 @@ function createMySQLAdapter(options = {}) {
 var DEFAULT_RUNTIME_CONNECTION = Object.freeze({
   driver: "sqlite",
   url: "./data/database.sqlite",
-  schema: "public",
   logging: false
 });
 function asRecord(value) {
@@ -12087,6 +12184,9 @@ function normalizeConnectionInput(input) {
   }
   return input ?? {};
 }
+function hasRuntimeConnectionEntries(entries) {
+  return entries.length > 0;
+}
 function inferDatabaseDriver(value) {
   if (!value) return void 0;
   const normalized = value.trim().toLowerCase();
@@ -12159,31 +12259,6 @@ function resolveConnectionConfig(name, input) {
   };
   return createRuntimeConnectionOptions(driver, connection, logging, schemaName, name);
 }
-function mergeConnectionGroups(...groups) {
-  const merged = {};
-  for (const group of groups) {
-    if (!group?.connections) {
-      continue;
-    }
-    Object.assign(merged, group.connections);
-  }
-  return merged;
-}
-function resolveConfiguredDefaultConnection(...groups) {
-  for (const group of groups) {
-    const configured = group?.defaultConnection;
-    if (configured) {
-      return configured;
-    }
-  }
-  return void 0;
-}
-function resolveImplicitDefaultConnectionName(connectionNames) {
-  if (connectionNames.includes("default")) {
-    return "default";
-  }
-  return connectionNames[0] ?? "default";
-}
 function isSupportedDatabaseDriver(value) {
   return value === "sqlite" || value === "postgres" || value === "mysql";
 }
@@ -12340,9 +12415,9 @@ function createRuntimeConnectionOptions(driver, connection, dbLogging, schemaNam
 }
 function resolveRuntimeConnectionManagerOptions(config) {
   const topLevelDb = asRecord(config.db);
-  const mergedConnections = mergeConnectionGroups(topLevelDb);
-  const connectionNames = Object.keys(mergedConnections);
-  if (connectionNames.length === 0) {
+  const connections = topLevelDb?.connections ?? {};
+  const connectionEntries = Object.entries(connections);
+  if (!hasRuntimeConnectionEntries(connectionEntries)) {
     return createConnectionManager({
       defaultConnection: "default",
       connections: {
@@ -12350,15 +12425,15 @@ function resolveRuntimeConnectionManagerOptions(config) {
       }
     });
   }
-  const configuredDefault = resolveConfiguredDefaultConnection(topLevelDb);
-  const defaultConnection = configuredDefault ?? resolveImplicitDefaultConnectionName(connectionNames);
-  const connectionEntries = Object.entries(mergedConnections).map(([name, input]) => [
+  const configuredDefault = topLevelDb?.defaultConnection;
+  const defaultConnection = configuredDefault ? configuredDefault : Object.hasOwn(connections, "default") ? "default" : connectionEntries[0][0];
+  const resolvedConnections = connectionEntries.map(([name, input]) => [
     name,
     resolveConnectionConfig(name, input)
   ]);
   return createConnectionManager({
     defaultConnection,
-    connections: Object.fromEntries(connectionEntries)
+    connections: Object.fromEntries(resolvedConnections)
   });
 }
 
@@ -12431,12 +12506,12 @@ function generateMigrationTemplate(name, options = {}) {
   };
 }
 function renderMigrationTemplate(options) {
+  return wrapMigrationTemplate(renderMigrationBody(options));
+}
+function renderMigrationBody(options) {
   switch (options.kind) {
     case "create_table":
       return [
-        "import { defineMigration, type MigrationContext } from '@holo-js/db'",
-        "",
-        "export default defineMigration({",
         "  async up({ schema }: MigrationContext) {",
         `    await schema.createTable('${options.tableName}', (table) => {`,
         "      table.id()",
@@ -12445,15 +12520,10 @@ function renderMigrationTemplate(options) {
         "  },",
         "  async down({ schema }: MigrationContext) {",
         `    await schema.dropTable('${options.tableName}')`,
-        "  },",
-        "})",
-        ""
-      ].join("\n");
+        "  },"
+      ];
     case "alter_table":
       return [
-        "import { defineMigration, type MigrationContext } from '@holo-js/db'",
-        "",
-        "export default defineMigration({",
         "  async up({ schema }: MigrationContext) {",
         `    await schema.table('${options.tableName}', (table) => {`,
         "      void table",
@@ -12463,29 +12533,19 @@ function renderMigrationTemplate(options) {
         `    await schema.table('${options.tableName}', (table) => {`,
         "      void table",
         "    })",
-        "  },",
-        "})",
-        ""
-      ].join("\n");
+        "  },"
+      ];
     case "drop_table":
       return [
-        "import { defineMigration, type MigrationContext } from '@holo-js/db'",
-        "",
-        "export default defineMigration({",
         "  async up({ schema }: MigrationContext) {",
         `    await schema.dropTable('${options.tableName}')`,
         "  },",
         "  async down() {",
         `    throw new Error('Recreate "${options.tableName}" manually in this migration if rollback support is required.')`,
-        "  },",
-        "})",
-        ""
-      ].join("\n");
+        "  },"
+      ];
     case "blank":
       return [
-        "import { defineMigration, type MigrationContext } from '@holo-js/db'",
-        "",
-        "export default defineMigration({",
         "  async up({ schema, db }: MigrationContext) {",
         "    void schema",
         "    void db",
@@ -12493,12 +12553,20 @@ function renderMigrationTemplate(options) {
         "  async down({ schema, db }: MigrationContext) {",
         "    void schema",
         "    void db",
-        "  },",
-        "})",
-        ""
-      ].join("\n");
+        "  },"
+      ];
   }
 }
+function wrapMigrationTemplate(body) {
+  return [
+    "import { defineMigration, type MigrationContext } from '@holo-js/db'",
+    "",
+    "export default defineMigration({",
+    ...body,
+    "})",
+    ""
+  ].join("\n");
+}
 
 // src/seeders/defineSeeder.ts
 function defineSeeder(seeder) {
@@ -13197,12 +13265,14 @@ function validateUniqueIdConfig(table, _modelName, config) {
   }
 }
 
-// src/model/defineModel.ts
+// src/model/defineModelHelpers.ts
+import { singularize } from "inflection";
 function buildModelTable(tableName, builder) {
   return builder(new TableDefinitionBuilder(tableName)).build();
 }
 function inferModelName(tableName) {
-  const singular = tableName.endsWith("s") ? tableName.slice(0, -1) : tableName;
+  const unqualifiedName = tableName.split(".").at(-1) ?? tableName;
+  const singular = singularize(unqualifiedName);
   return singular.split(/[_-]/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function inferPrimaryKey(table) {
@@ -13212,6 +13282,25 @@ function inferPrimaryKey(table) {
   }
   return primaryKey.name;
 }
+function getRuntimeSchemaTable(tableName, connectionName) {
+  try {
+    return DB.getManager().connection(connectionName).getSchemaRegistry().get(tableName);
+  } catch (error) {
+    if (error instanceof ConfigurationError && error.code === "CONFIGURATION_ERROR" && error.message.includes("ConnectionManager") && error.message.includes("not configured")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function resolveGeneratedModelTable(tableName, connectionName) {
+  const table = getGeneratedTableDefinition(tableName) ?? getRuntimeSchemaTable(tableName, connectionName);
+  if (!table) {
+    throw new SchemaError(
+      `Model "${tableName}" is not present in the generated schema registry. Run "holo migrate" to refresh the internal generated schema metadata.`
+    );
+  }
+  return table;
+}
 function resolveDeletedAtColumn(table, options) {
   if (!options.softDeletes) {
     return void 0;
@@ -13247,6 +13336,45 @@ function validateTouches(modelName, relations, touches) {
   }
   return Object.freeze([...touches]);
 }
+
+// src/model/defineModel.ts
+var HOLO_MODEL_REFERENCE_REGISTRY = /* @__PURE__ */ Symbol.for("holo-js.db.model-reference-registry");
+function createSharedModelDefinitionFields(inferredName, relations, touches, options) {
+  return {
+    kind: "model",
+    name: inferredName,
+    connectionName: options.connectionName,
+    morphClass: options.morphClass ?? inferredName,
+    with: Object.freeze([...options.with ?? []]),
+    pendingAttributes: Object.freeze({ ...options.pendingAttributes ?? {} }),
+    preventLazyLoading: options.preventLazyLoading ?? false,
+    preventAccessingMissingAttributes: options.preventAccessingMissingAttributes ?? false,
+    automaticEagerLoading: options.automaticEagerLoading ?? false,
+    timestamps: options.timestamps ?? true,
+    fillable: Object.freeze([...options.fillable ?? []]),
+    hasExplicitFillable: typeof options.fillable !== "undefined",
+    guarded: Object.freeze([...options.guarded ?? []]),
+    scopes: options.scopes ?? {},
+    globalScopes: { ...options.globalScopes ?? {} },
+    relations,
+    casts: { ...options.casts ?? {} },
+    accessors: { ...options.accessors ?? {} },
+    mutators: { ...options.mutators ?? {} },
+    hidden: Object.freeze([...options.hidden ?? []]),
+    visible: Object.freeze([...options.visible ?? []]),
+    appended: Object.freeze([...options.appended ?? []]),
+    serializeDate: options.serializeDate,
+    collection: options.collection,
+    prunable: options.prunable,
+    massPrunable: options.massPrunable ?? false,
+    touches,
+    traits: Object.freeze([...options.traits ?? []]),
+    replicationExcludes: Object.freeze([...options.replicationExcludes ?? []]),
+    softDeletes: options.softDeletes ?? false,
+    events: normalizeEventHandlers(options.events),
+    observers: Object.freeze([...options.observers ?? []])
+  };
+}
 function defineModel(tableOrName, builderOrOptions, options) {
   if (typeof tableOrName !== "string") {
     return defineModelFromResolvedTable(tableOrName, builderOrOptions ?? {});
@@ -13257,13 +13385,73 @@ function defineModel(tableOrName, builderOrOptions, options) {
       options ?? {}
     );
   }
-  const table = getGeneratedTableDefinition(tableOrName);
-  if (!table) {
-    throw new SchemaError(
-      `Model "${tableOrName}" is not present in the generated schema registry. Import your generated schema module and run "holo migrate" to refresh it.`
+  return defineModelFromGeneratedTableName(
+    tableOrName,
+    builderOrOptions ?? {}
+  );
+}
+function defineModelFromGeneratedTableName(tableName, options = {}) {
+  const inferredName = options.name ?? inferModelName(tableName);
+  const relations = { ...options.relations ?? {} };
+  const touches = validateTouches(inferredName, relations, options.touches ?? []);
+  const resolveTableDefinition = () => resolveGeneratedModelTable(tableName, options.connectionName);
+  const resolvePrimaryKeyFromTable = (table) => options.primaryKey ?? inferPrimaryKey(table);
+  const resolveUniqueIdFromTable = (table) => {
+    return resolveUniqueIdConfig(
+      options.traits,
+      resolvePrimaryKeyFromTable(table),
+      options.uniqueIds,
+      options.newUniqueId
     );
-  }
-  return defineModelFromResolvedTable(table, builderOrOptions ?? {});
+  };
+  const resolveTable = () => {
+    const table = resolveTableDefinition();
+    validateUniqueIdConfig(table, inferredName, resolveUniqueIdFromTable(table));
+    return table;
+  };
+  const resolvePrimaryKey = () => resolvePrimaryKeyFromTable(resolveTable());
+  const resolveCreatedAtColumn = () => {
+    const timestamps = options.timestamps ?? true;
+    return timestamps ? resolveTimestampColumn(resolveTable(), options.createdAtColumn, "created_at") : void 0;
+  };
+  const resolveUpdatedAtColumn = () => {
+    const timestamps = options.timestamps ?? true;
+    return timestamps ? resolveTimestampColumn(resolveTable(), options.updatedAtColumn, "updated_at") : void 0;
+  };
+  const resolveDeletedAt = () => resolveDeletedAtColumn(resolveTable(), options);
+  const resolveUniqueId = () => {
+    return resolveUniqueIdFromTable(resolveTable());
+  };
+  const definition = {
+    ...createSharedModelDefinitionFields(inferredName, relations, touches, options)
+  };
+  Object.defineProperties(definition, {
+    table: {
+      enumerable: true,
+      get: resolveTable
+    },
+    primaryKey: {
+      enumerable: true,
+      get: resolvePrimaryKey
+    },
+    createdAtColumn: {
+      enumerable: true,
+      get: resolveCreatedAtColumn
+    },
+    updatedAtColumn: {
+      enumerable: true,
+      get: resolveUpdatedAtColumn
+    },
+    deletedAtColumn: {
+      enumerable: true,
+      get: resolveDeletedAt
+    },
+    uniqueIdConfig: {
+      enumerable: true,
+      get: resolveUniqueId
+    }
+  });
+  return createStaticModelApi(Object.freeze(definition));
 }
 function defineModelFromResolvedTable(table, options = {}) {
   const deletedAtColumn = resolveDeletedAtColumn(table, options);
@@ -13282,45 +13470,17 @@ function defineModelFromResolvedTable(table, options = {}) {
   const relations = { ...options.relations ?? {} };
   const touches = validateTouches(inferredName, relations, options.touches ?? []);
   const definition = Object.freeze({
-    kind: "model",
+    ...createSharedModelDefinitionFields(inferredName, relations, touches, options),
     table,
-    name: inferredName,
     primaryKey,
-    connectionName: options.connectionName,
-    morphClass: options.morphClass ?? inferredName,
-    with: Object.freeze([...options.with ?? []]),
-    pendingAttributes: Object.freeze({ ...options.pendingAttributes ?? {} }),
-    preventLazyLoading: options.preventLazyLoading ?? false,
-    preventAccessingMissingAttributes: options.preventAccessingMissingAttributes ?? false,
-    automaticEagerLoading: options.automaticEagerLoading ?? false,
-    timestamps,
     createdAtColumn,
     updatedAtColumn,
-    fillable: Object.freeze([...options.fillable ?? []]),
-    hasExplicitFillable: typeof options.fillable !== "undefined",
-    guarded: Object.freeze([...options.guarded ?? []]),
-    scopes: options.scopes ?? {},
-    globalScopes: { ...options.globalScopes ?? {} },
-    relations,
-    casts: { ...options.casts ?? {} },
-    accessors: { ...options.accessors ?? {} },
-    mutators: { ...options.mutators ?? {} },
-    hidden: Object.freeze([...options.hidden ?? []]),
-    visible: Object.freeze([...options.visible ?? []]),
-    appended: Object.freeze([...options.appended ?? []]),
-    serializeDate: options.serializeDate,
-    collection: options.collection,
-    prunable: options.prunable,
-    massPrunable: options.massPrunable ?? false,
-    touches,
-    traits: Object.freeze([...options.traits ?? []]),
     uniqueIdConfig,
-    replicationExcludes: Object.freeze([...options.replicationExcludes ?? []]),
-    softDeletes: options.softDeletes ?? false,
-    deletedAtColumn,
-    events: normalizeEventHandlers(options.events),
-    observers: Object.freeze([...options.observers ?? []])
+    deletedAtColumn
   });
+  return createStaticModelApi(definition);
+}
+function createStaticModelApi(definition) {
   const model = {
     definition,
     query() {
@@ -13338,8 +13498,8 @@ function defineModelFromResolvedTable(table, options = {}) {
     newQueryWithoutRelationships() {
       return this.getRepository().newQueryWithoutRelationships();
     },
-    from(table2) {
-      return this.query().from(table2);
+    from(table) {
+      return this.query().from(table);
     },
     debug() {
       return this.query().debug();
@@ -13467,17 +13627,17 @@ function defineModelFromResolvedTable(table, options = {}) {
     whereNone(columns, operator, value) {
       return this.query().whereNone(columns, operator, value);
     },
-    join(table2, leftColumn, operator, rightColumn) {
-      return this.query().join(table2, leftColumn, operator, rightColumn);
+    join(table, leftColumn, operator, rightColumn) {
+      return this.query().join(table, leftColumn, operator, rightColumn);
     },
-    leftJoin(table2, leftColumn, operator, rightColumn) {
-      return this.query().leftJoin(table2, leftColumn, operator, rightColumn);
+    leftJoin(table, leftColumn, operator, rightColumn) {
+      return this.query().leftJoin(table, leftColumn, operator, rightColumn);
     },
-    rightJoin(table2, leftColumn, operator, rightColumn) {
-      return this.query().rightJoin(table2, leftColumn, operator, rightColumn);
+    rightJoin(table, leftColumn, operator, rightColumn) {
+      return this.query().rightJoin(table, leftColumn, operator, rightColumn);
     },
-    crossJoin(table2) {
-      return this.query().crossJoin(table2);
+    crossJoin(table) {
+      return this.query().crossJoin(table);
     },
     joinSub(query, alias, leftColumn, operator, rightColumn) {
       return this.query().joinSub(query, alias, leftColumn, operator, rightColumn);
@@ -13548,11 +13708,11 @@ function defineModelFromResolvedTable(table, options = {}) {
     orWhereJsonLength(columnPath, operator, value) {
       return this.query().orWhereJsonLength(columnPath, operator, value);
     },
-    whereFullText(columns, value, options2 = {}) {
-      return this.query().whereFullText(columns, value, options2);
+    whereFullText(columns, value, options = {}) {
+      return this.query().whereFullText(columns, value, options);
     },
-    orWhereFullText(columns, value, options2 = {}) {
-      return this.query().orWhereFullText(columns, value, options2);
+    orWhereFullText(columns, value, options = {}) {
+      return this.query().orWhereFullText(columns, value, options);
     },
     whereVectorSimilarTo(column2, vector, minSimilarity = 0) {
       return this.query().whereVectorSimilarTo(column2, vector, minSimilarity);
@@ -13560,6 +13720,9 @@ function defineModelFromResolvedTable(table, options = {}) {
     orWhereVectorSimilarTo(column2, vector, minSimilarity = 0) {
       return this.query().orWhereVectorSimilarTo(column2, vector, minSimilarity);
     },
+    orderBy(column2, direction = "asc") {
+      return this.query().orderBy(column2, direction);
+    },
     latest(column2) {
       return this.query().latest(column2);
     },
@@ -13585,7 +13748,10 @@ function defineModelFromResolvedTable(table, options = {}) {
       return this.query().sharedLock();
     },
     with(first, second, ...rest) {
-      if (typeof first !== "string") {
+      if (Array.isArray(first)) {
+        return this.query().with(first);
+      }
+      if (typeof first === "object") {
         return this.query().with(first);
       }
       if (typeof second === "function") {
@@ -13671,32 +13837,53 @@ function defineModelFromResolvedTable(table, options = {}) {
     findOrFail(value) {
       return this.getRepository().findOrFail(value);
     },
+    findOrFailJson(value) {
+      return this.query().findOrFailJson(value);
+    },
     first() {
       return this.getRepository().first();
     },
+    firstJson() {
+      return this.query().firstJson();
+    },
     firstOrFail() {
       return this.getRepository().firstOrFail();
     },
     sole() {
       return this.getRepository().sole();
     },
+    soleJson() {
+      return this.query().soleJson();
+    },
     firstWhere(column2, operator, value) {
       return this.getRepository().firstWhere(column2, operator, value);
     },
     get() {
       return this.getRepository().get();
     },
+    getJson() {
+      return this.query().getJson();
+    },
     all() {
       return this.getRepository().all();
     },
-    paginate(perPage = 15, page = 1, options2 = {}) {
-      return this.query().paginate(perPage, page, options2);
+    paginate(perPage = 15, page = 1, options = {}) {
+      return this.query().paginate(perPage, page, options);
+    },
+    paginateJson(perPage = 15, page = 1, options = {}) {
+      return this.query().paginateJson(perPage, page, options);
+    },
+    simplePaginate(perPage = 15, page = 1, options = {}) {
+      return this.query().simplePaginate(perPage, page, options);
+    },
+    simplePaginateJson(perPage = 15, page = 1, options = {}) {
+      return this.query().simplePaginateJson(perPage, page, options);
     },
-    simplePaginate(perPage = 15, page = 1, options2 = {}) {
-      return this.query().simplePaginate(perPage, page, options2);
+    cursorPaginate(perPage = 15, cursor = null, options = {}) {
+      return this.query().cursorPaginate(perPage, cursor, options);
     },
-    cursorPaginate(perPage = 15, cursor = null, options2 = {}) {
-      return this.query().cursorPaginate(perPage, cursor, options2);
+    cursorPaginateJson(perPage = 15, cursor = null, options = {}) {
+      return this.query().cursorPaginateJson(perPage, cursor, options);
     },
     chunk(size, callback) {
       return this.query().chunk(size, callback);
@@ -13824,9 +14011,94 @@ function defineModelFromResolvedTable(table, options = {}) {
     const scoped = scope;
     model[name] = (...args) => scoped(model.query(), ...args);
   }
+  registerGlobalModel(model);
   registerMorphModel(definition.morphClass, model);
+  getHoloModelReferenceRegistry().add(model);
   return Object.freeze(model);
 }
+function getHoloModelReferenceRegistry() {
+  const registryGlobal = globalThis;
+  const existing = registryGlobal[HOLO_MODEL_REFERENCE_REGISTRY];
+  if (existing) {
+    return existing;
+  }
+  const registry = /* @__PURE__ */ new WeakSet();
+  Object.defineProperty(globalThis, HOLO_MODEL_REFERENCE_REGISTRY, {
+    value: registry
+  });
+  return registry;
+}
+
+// src/model/serialize.ts
+function isSerializableModel(value) {
+  return Boolean(value && typeof value === "object" && typeof value.toJSON === "function");
+}
+function serializeModels(value) {
+  if (value instanceof Date || value === null || typeof value !== "object") {
+    return value;
+  }
+  if (isSerializableModel(value)) {
+    return value.toJSON();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeModels(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, serializeModels(entry)])
+  );
+}
+
+// src/model/slug.ts
+var reservedSlugs = /* @__PURE__ */ new Map();
+var slugReservationQueues = /* @__PURE__ */ new Map();
+function slugify(value, separator, fallback) {
+  const normalized = value.toLowerCase().trim().replace(/[^a-z0-9]+/g, separator).replace(new RegExp(`^${escapeRegExp(separator)}+|${escapeRegExp(separator)}+$`, "g"), "");
+  return normalized || fallback;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function reserveNextSlug(key, callback) {
+  const previous = slugReservationQueues.get(key) ?? Promise.resolve();
+  let release;
+  const current = previous.then(() => new Promise((resolve) => {
+    release = resolve;
+  }));
+  slugReservationQueues.set(key, current);
+  await previous;
+  try {
+    return await callback();
+  } finally {
+    release();
+    if (slugReservationQueues.get(key) === current) {
+      slugReservationQueues.delete(key);
+    }
+  }
+}
+async function uniqueSlug(model, value, options = {}) {
+  const column2 = options.column ?? "slug";
+  const separator = options.separator ?? "-";
+  const fallback = options.fallback ?? "entry";
+  const base = slugify(value, separator, fallback);
+  const key = `${model.definition.connectionName ?? "default"}:${model.definition.name}:${column2}:${base}`;
+  return await reserveNextSlug(key, async () => {
+    const query = model.whereLike(column2, `${base}%`).when(typeof options.ignore !== "undefined", (builder) => builder.where(model.definition.primaryKey, "!=", options.ignore));
+    const existing = await query.pluck(column2);
+    const reserved = reservedSlugs.get(key) ?? /* @__PURE__ */ new Set();
+    const taken = new Set(reserved);
+    for (const slug of existing) {
+      taken.add(slug);
+    }
+    for (let index = 1; ; index += 1) {
+      const candidate = index === 1 ? base : `${base}${separator}${index}`;
+      if (!taken.has(candidate)) {
+        reserved.add(candidate);
+        reservedSlugs.set(key, reserved);
+        return candidate;
+      }
+    }
+  });
+}
 
 // src/model/relations.ts
 function defaultMorphTypeColumn(name) {
@@ -13835,6 +14107,21 @@ function defaultMorphTypeColumn(name) {
 function defaultMorphIdColumn(name) {
   return `${name}_id`;
 }
+function resolveRegisteredModel(name) {
+  const model = getGlobalModel(name);
+  if (!model) {
+    throw new RelationError(
+      `Relation target "${name}" is not registered. Import the related model once during boot or use your framework's model discovery.`
+    );
+  }
+  return model;
+}
+function normalizeRelatedResolver(related) {
+  if (typeof related === "string") {
+    return () => resolveRegisteredModel(related);
+  }
+  return related;
+}
 function decoratePivotRelation(relation) {
   const clone = (overrides) => {
     return decoratePivotRelation(Object.freeze({
@@ -13891,7 +14178,7 @@ function belongsTo(related, foreignKeyOrOptions, ownerKey = "id") {
   const resolvedOwnerKey = typeof foreignKeyOrOptions === "string" ? ownerKey : foreignKeyOrOptions.ownerKey ?? "id";
   return Object.freeze({
     kind: "belongsTo",
-    related,
+    related: normalizeRelatedResolver(related),
     foreignKey,
     ownerKey: resolvedOwnerKey
   });
@@ -13901,7 +14188,7 @@ function hasMany(related, foreignKeyOrOptions, localKey = "id") {
   const resolvedLocalKey = typeof foreignKeyOrOptions === "string" ? localKey : foreignKeyOrOptions.localKey ?? "id";
   return Object.freeze({
     kind: "hasMany",
-    related,
+    related: normalizeRelatedResolver(related),
     foreignKey,
     localKey: resolvedLocalKey
   });
@@ -13911,7 +14198,7 @@ function hasOne(related, foreignKeyOrOptions, localKey = "id") {
   const resolvedLocalKey = typeof foreignKeyOrOptions === "string" ? localKey : foreignKeyOrOptions.localKey ?? "id";
   return Object.freeze({
     kind: "hasOne",
-    related,
+    related: normalizeRelatedResolver(related),
     foreignKey,
     localKey: resolvedLocalKey
   });
@@ -13986,7 +14273,7 @@ function belongsToMany(related, pivotTableOrOptions, foreignPivotKey, relatedPiv
   const resolvedRelatedKey = typeof pivotTableOrOptions === "object" && "pivotTable" in pivotTableOrOptions ? pivotTableOrOptions.relatedKey ?? "id" : relatedKey;
   return decoratePivotRelation(Object.freeze({
     kind: "belongsToMany",
-    related,
+    related: normalizeRelatedResolver(related),
     pivotTable,
     foreignPivotKey: resolvedForeignPivotKey,
     relatedPivotKey: resolvedRelatedPivotKey,
@@ -14073,7 +14360,7 @@ function hasManyThrough(related, through, firstKey, secondKey, localKey = "id",
 var DEFAULT_HOLO_PROJECT_PATHS = Object.freeze({
   models: "server/models",
   migrations: "server/db/migrations",
-  generatedSchema: "server/db/schema.generated.ts",
+  generatedSchema: ".holo-js/generated/schema.generated.ts",
   seeders: "server/db/seeders",
   observers: "server/db/observers",
   factories: "server/db/factories",
@@ -14250,8 +14537,10 @@ export {
   renameTableOperation,
   renderGeneratedSchemaModule,
   renderGeneratedSchemaPlaceholder,
+  renderGeneratedSchemaRuntimeModule,
   resetDB,
   resetDatabaseQueryCacheBridge,
+  resetGlobalModelRegistry,
   resetMorphRegistry,
   resolveDialectColumnType,
   resolveDialectIdStrategyType,
@@ -14259,6 +14548,8 @@ export {
   resolveMorphModel,
   resolveRuntimeConnectionManagerOptions,
   scopeRelation,
+  serializeModels,
+  uniqueSlug,
   unsafeSql,
   validateQueryPlan,
   withLimit,