@vertz/db 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,10 +1,14 @@
 import {
+  PostgresDialect,
+  SqliteDialect,
   buildDelete,
   buildInsert,
   buildSelect,
   buildUpdate,
-  buildWhere
-} from "./shared/chunk-3f2grpak.js";
+  buildWhere,
+  defaultPostgresDialect,
+  defaultSqliteDialect
+} from "./shared/chunk-0e1vy9qd.js";
 import {
   CheckConstraintError,
   ConnectionError,
@@ -15,21 +19,87 @@ import {
   NotNullError,
   UniqueConstraintError,
   executeQuery,
+  getAutoUpdateColumns,
   getPrimaryKeyColumns,
+  getReadOnlyColumns,
   getTimestampColumns,
   mapRow,
   mapRows,
   parsePgError,
   resolveSelectColumns
-} from "./shared/chunk-xp022dyp.js";
+} from "./shared/chunk-agyds4jw.js";
+import"./shared/chunk-kb4tnn2k.js";
 import {
   camelToSnake
-} from "./shared/chunk-hrfdj0rr.js";
+} from "./shared/chunk-v2qm94qp.js";
+import {
+  sha256Hex
+} from "./shared/chunk-ssga2xea.js";
 import {
   diagnoseError,
   explainError,
   formatDiagnostic
-} from "./shared/chunk-wj026daz.js";
+} from "./shared/chunk-k04v1jjx.js";
+import {
+  createD1Adapter,
+  createD1Driver
+} from "./shared/chunk-ktbebkz5.js";
+import {
+  generateId
+} from "./shared/chunk-fwk49jvg.js";
+// src/adapters/database-bridge-adapter.ts
+function createDatabaseBridgeAdapter(db, tableName) {
+  const delegate = db[tableName];
+  return {
+    async get(id) {
+      const result = await delegate.get({ where: { id } });
+      if (!result.ok) {
+        return null;
+      }
+      return result.data;
+    },
+    async list(options) {
+      const dbOptions = {};
+      if (options?.where) {
+        dbOptions.where = options.where;
+      }
+      if (options?.orderBy) {
+        dbOptions.orderBy = options.orderBy;
+      }
+      if (options?.limit !== undefined) {
+        dbOptions.limit = options.limit;
+      }
+      const result = await delegate.listAndCount(dbOptions);
+      if (!result.ok) {
+        throw result.error;
+      }
+      return result.data;
+    },
+    async create(data) {
+      const result = await delegate.create({ data });
+      if (!result.ok) {
+        throw result.error;
+      }
+      return result.data;
+    },
+    async update(id, data) {
+      const result = await delegate.update({ where: { id }, data });
+      if (!result.ok) {
+        throw result.error;
+      }
+      return result.data;
+    },
+    async delete(id) {
+      const result = await delegate.delete({ where: { id } });
+      if (!result.ok) {
+        return null;
+      }
+      return result.data;
+    }
+  };
+}
+// src/migration/auto-migrate.ts
+import { isErr } from "@vertz/errors";
 
 // src/migration/differ.ts
 function columnSimilarity(a, b) {
@@ -189,10 +259,26 @@ function computeDiff(before, after) {
   }
   return { changes };
 }
+
 // src/migration/runner.ts
-import { createHash } from "node:crypto";
+import {
+  createMigrationQueryError,
+  err,
+  ok
+} from "@vertz/errors";
 var HISTORY_TABLE = "_vertz_migrations";
-var CREATE_HISTORY_SQL = `
+function buildCreateHistorySql(dialect) {
+  if (dialect.name === "sqlite") {
+    return `
+CREATE TABLE IF NOT EXISTS "${HISTORY_TABLE}" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "name" TEXT NOT NULL UNIQUE,
+  "checksum" TEXT NOT NULL,
+  "applied_at" TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+  }
+  return `
 CREATE TABLE IF NOT EXISTS "${HISTORY_TABLE}" (
   "id" serial PRIMARY KEY,
   "name" text NOT NULL UNIQUE,
@@ -200,8 +286,9 @@ CREATE TABLE IF NOT EXISTS "${HISTORY_TABLE}" (
   "applied_at" timestamp with time zone NOT NULL DEFAULT now()
 );
 `;
-function computeChecksum(sql) {
-  return createHash("sha256").update(sql).digest("hex");
+}
+async function computeChecksum(sql) {
+  return sha256Hex(sql);
 }
 function parseMigrationName(filename) {
   const match = filename.match(/^(\d+)_(.+)\.sql$/);
@@ -212,52 +299,75 @@ function parseMigrationName(filename) {
     name: filename
   };
 }
-function createMigrationRunner() {
+function createMigrationRunner(options) {
+  const dialect = options?.dialect ?? defaultPostgresDialect;
+  const createHistorySql = buildCreateHistorySql(dialect);
   return {
     async createHistoryTable(queryFn) {
-      await queryFn(CREATE_HISTORY_SQL, []);
+      try {
+        await queryFn(createHistorySql, []);
+        return ok(undefined);
+      } catch (cause) {
+        return err(createMigrationQueryError("Failed to create migration history table", {
+          sql: createHistorySql,
+          cause
+        }));
+      }
     },
-    async apply(queryFn, sql, name, options) {
-      const checksum = computeChecksum(sql);
-      const recordSql = `INSERT INTO "${HISTORY_TABLE}" ("name", "checksum") VALUES ($1, $2)`;
+    async apply(queryFn, sql, name, options2) {
+      const checksum = await computeChecksum(sql);
+      const recordSql = `INSERT INTO "${HISTORY_TABLE}" ("name", "checksum") VALUES (${dialect.param(1)}, ${dialect.param(2)})`;
       const statements = [sql, recordSql];
-      if (options?.dryRun) {
-        return {
+      if (options2?.dryRun) {
+        return ok({
           name,
           sql,
           checksum,
           dryRun: true,
           statements
-        };
+        });
+      }
+      try {
+        await queryFn(sql, []);
+        await queryFn(recordSql, [name, checksum]);
+        return ok({
+          name,
+          sql,
+          checksum,
+          dryRun: false,
+          statements
+        });
+      } catch (cause) {
+        return err(createMigrationQueryError(`Failed to apply migration: ${name}`, {
+          sql,
+          cause
+        }));
       }
-      await queryFn(sql, []);
-      await queryFn(recordSql, [name, checksum]);
-      return {
-        name,
-        sql,
-        checksum,
-        dryRun: false,
-        statements
-      };
     },
     async getApplied(queryFn) {
-      const result = await queryFn(`SELECT "name", "checksum", "applied_at" FROM "${HISTORY_TABLE}" ORDER BY "id" ASC`, []);
-      return result.rows.map((row) => ({
-        name: row.name,
-        checksum: row.checksum,
-        appliedAt: new Date(row.applied_at)
-      }));
+      try {
+        const result = await queryFn(`SELECT "name", "checksum", "applied_at" FROM "${HISTORY_TABLE}" ORDER BY "id" ASC`, []);
+        return ok(result.rows.map((row) => ({
+          name: row.name,
+          checksum: row.checksum,
+          appliedAt: new Date(row.applied_at)
+        })));
+      } catch (cause) {
+        return err(createMigrationQueryError("Failed to retrieve applied migrations", {
+          cause
+        }));
+      }
     },
     getPending(files, applied) {
       const appliedNames = new Set(applied.map((a) => a.name));
       return files.filter((f) => !appliedNames.has(f.name)).sort((a, b) => a.timestamp - b.timestamp);
     },
-    detectDrift(files, applied) {
+    async detectDrift(files, applied) {
       const drifted = [];
       const appliedMap = new Map(applied.map((a) => [a.name, a.checksum]));
       for (const file of files) {
         const appliedChecksum = appliedMap.get(file.name);
-        if (appliedChecksum && appliedChecksum !== computeChecksum(file.sql)) {
+        if (appliedChecksum && appliedChecksum !== await computeChecksum(file.sql)) {
           drifted.push(file.name);
         }
       }
@@ -278,27 +388,55 @@ function createMigrationRunner() {
   };
 }
 
-// src/migration/files.ts
-function formatMigrationFilename(num, description) {
-  return `${String(num).padStart(4, "0")}_${description}.sql`;
+// src/migration/sql-generator.ts
+function escapeSqlString(value) {
+  return value.replace(/'/g, "''");
 }
-function nextMigrationNumber(existingFiles) {
-  let max = 0;
-  for (const file of existingFiles) {
-    const parsed = parseMigrationName(file);
-    if (parsed && parsed.timestamp > max) {
-      max = parsed.timestamp;
+function isEnumType(col, enums) {
+  const typeLower = col.type.toLowerCase();
+  if (enums) {
+    for (const enumName of Object.keys(enums)) {
+      if (typeLower === enumName.toLowerCase() || typeLower === enumName) {
+        return true;
+      }
     }
   }
-  return max + 1;
+  return false;
 }
-// src/migration/sql-generator.ts
-function escapeSqlString(value) {
-  return value.replace(/'/g, "''");
+function getEnumValues(col, enums) {
+  if (!enums)
+    return;
+  for (const [enumName, values] of Object.entries(enums)) {
+    if (col.type.toLowerCase() === enumName.toLowerCase() || col.type === enumName) {
+      return values;
+    }
+  }
+  return;
 }
-function columnDef(name, col) {
+function columnDef(name, col, dialect, enums) {
   const snakeName = camelToSnake(name);
-  const parts = [`"${snakeName}" ${col.type}`];
+  const isEnum = isEnumType(col, enums);
+  let sqlType;
+  let checkConstraint;
+  if (isEnum && dialect.name === "sqlite") {
+    sqlType = dialect.mapColumnType("text");
+    const enumValues = getEnumValues(col, enums);
+    if (enumValues && enumValues.length > 0) {
+      const escapedValues = enumValues.map((v) => `'${escapeSqlString(v)}'`).join(", ");
+      checkConstraint = `CHECK("${snakeName}" IN (${escapedValues}))`;
+    }
+  } else {
+    if (dialect.name === "postgres" && col.type === col.type.toLowerCase()) {
+      sqlType = col.type;
+    } else {
+      const normalizedType = normalizeColumnType(col.type);
+      sqlType = dialect.mapColumnType(normalizedType);
+    }
+  }
+  const parts = [`"${snakeName}" ${sqlType}`];
+  if (checkConstraint) {
+    parts.push(checkConstraint);
+  }
   if (!col.nullable) {
     parts.push("NOT NULL");
   }
@@ -310,12 +448,44 @@ function columnDef(name, col) {
   }
   return parts.join(" ");
 }
-function generateMigrationSql(changes, ctx) {
+function normalizeColumnType(type) {
+  const typeUpper = type.toUpperCase();
+  const typeMap = {
+    UUID: "uuid",
+    TEXT: "text",
+    INTEGER: "integer",
+    SERIAL: "serial",
+    BOOLEAN: "boolean",
+    TIMESTAMPTZ: "timestamp",
+    TIMESTAMP: "timestamp",
+    "DOUBLE PRECISION": "float",
+    JSONB: "json",
+    JSON: "json",
+    NUMERIC: "decimal",
+    REAL: "float",
+    VARCHAR: "varchar"
+  };
+  return typeMap[typeUpper] || type.toLowerCase();
+}
+function generateMigrationSql(changes, ctx, dialect = defaultPostgresDialect) {
   const statements = [];
   const tables = ctx?.tables;
   const enums = ctx?.enums;
   for (const change of changes) {
     switch (change.type) {
+      case "enum_added": {
+        if (!change.enumName)
+          break;
+        if (dialect.name === "postgres") {
+          const values = enums?.[change.enumName];
+          if (!values || values.length === 0)
+            break;
+          const enumSnakeName = camelToSnake(change.enumName);
+          const valuesStr = values.map((v) => `'${escapeSqlString(v)}'`).join(", ");
+          statements.push(`CREATE TYPE "${enumSnakeName}" AS ENUM (${valuesStr});`);
+        }
+        break;
+      }
       case "table_added": {
         if (!change.table)
           break;
@@ -325,8 +495,23 @@ function generateMigrationSql(changes, ctx) {
         const tableName = camelToSnake(change.table);
         const cols = [];
         const primaryKeys = [];
+        if (dialect.name === "postgres" && enums) {
+          for (const [, col] of Object.entries(table.columns)) {
+            if (isEnumType(col, enums)) {
+              const enumValues = getEnumValues(col, enums);
+              if (enumValues && enumValues.length > 0) {
+                const enumSnakeName = camelToSnake(col.type);
+                const alreadyEmitted = statements.some((s) => s.includes(`CREATE TYPE "${enumSnakeName}"`));
+                if (!alreadyEmitted) {
+                  const valuesStr = enumValues.map((v) => `'${escapeSqlString(v)}'`).join(", ");
+                  statements.push(`CREATE TYPE "${enumSnakeName}" AS ENUM (${valuesStr});`);
+                }
+              }
+            }
+          }
+        }
         for (const [colName, col] of Object.entries(table.columns)) {
-          cols.push(`  ${columnDef(colName, col)}`);
+          cols.push(`  ${columnDef(colName, col, dialect, enums)}`);
           if (col.primary) {
             primaryKeys.push(`"${camelToSnake(colName)}"`);
           }
@@ -346,7 +531,7 @@ ${cols.join(`,
 );`);
         for (const idx of table.indexes) {
           const idxCols = idx.columns.map((c) => `"${camelToSnake(c)}"`).join(", ");
-          const idxName = `idx_${tableName}_${idx.columns.map(camelToSnake).join("_")}`;
+          const idxName = `idx_${tableName}_${idx.columns.map((c) => camelToSnake(c)).join("_")}`;
           statements.push(`CREATE INDEX "${idxName}" ON "${tableName}" (${idxCols});`);
         }
         break;
@@ -363,7 +548,7 @@ ${cols.join(`,
         const col = tables?.[change.table]?.columns[change.column];
         if (!col)
           break;
-        statements.push(`ALTER TABLE "${camelToSnake(change.table)}" ADD COLUMN ${columnDef(change.column, col)};`);
+        statements.push(`ALTER TABLE "${camelToSnake(change.table)}" ADD COLUMN ${columnDef(change.column, col, dialect, enums)};`);
         break;
       }
       case "column_removed": {
@@ -407,7 +592,7 @@ ${cols.join(`,
           break;
         const snakeTable = camelToSnake(change.table);
         const idxCols = change.columns.map((c) => `"${camelToSnake(c)}"`).join(", ");
-        const idxName = `idx_${snakeTable}_${change.columns.map(camelToSnake).join("_")}`;
+        const idxName = `idx_${snakeTable}_${change.columns.map((c) => camelToSnake(c)).join("_")}`;
         statements.push(`CREATE INDEX "${idxName}" ON "${snakeTable}" (${idxCols});`);
         break;
       }
@@ -415,33 +600,26 @@ ${cols.join(`,
         if (!change.table || !change.columns)
           break;
         const snakeTable = camelToSnake(change.table);
-        const idxName = `idx_${snakeTable}_${change.columns.map(camelToSnake).join("_")}`;
+        const idxName = `idx_${snakeTable}_${change.columns.map((c) => camelToSnake(c)).join("_")}`;
         statements.push(`DROP INDEX "${idxName}";`);
         break;
       }
-      case "enum_added": {
-        if (!change.enumName)
-          break;
-        const values = enums?.[change.enumName];
-        if (!values || values.length === 0)
-          break;
-        const enumSnakeName = camelToSnake(change.enumName);
-        const valuesStr = values.map((v) => `'${escapeSqlString(v)}'`).join(", ");
-        statements.push(`CREATE TYPE "${enumSnakeName}" AS ENUM (${valuesStr});`);
-        break;
-      }
       case "enum_removed": {
         if (!change.enumName)
           break;
-        statements.push(`DROP TYPE "${camelToSnake(change.enumName)}";`);
+        if (dialect.name === "postgres") {
+          statements.push(`DROP TYPE "${camelToSnake(change.enumName)}";`);
+        }
         break;
       }
       case "enum_altered": {
         if (!change.enumName || !change.addedValues)
           break;
-        const enumSnakeName = camelToSnake(change.enumName);
-        for (const val of change.addedValues) {
-          statements.push(`ALTER TYPE "${enumSnakeName}" ADD VALUE '${escapeSqlString(val)}';`);
+        if (dialect.name === "postgres") {
+          const enumSnakeName = camelToSnake(change.enumName);
+          for (const val of change.addedValues) {
+            statements.push(`ALTER TYPE "${enumSnakeName}" ADD VALUE '${escapeSqlString(val)}';`);
+          }
         }
         break;
       }
@@ -451,22 +629,391 @@ ${cols.join(`,
 
 `);
 }
+// src/migration/files.ts
+function formatMigrationFilename(num, description) {
+  return `${String(num).padStart(4, "0")}_${description}.sql`;
+}
+function nextMigrationNumber(existingFiles) {
+  let max = 0;
+  for (const file of existingFiles) {
+    const parsed = parseMigrationName(file);
+    if (parsed && parsed.timestamp > max) {
+      max = parsed.timestamp;
+    }
+  }
+  return max + 1;
+}
+// src/migration/introspect.ts
+var SQLITE_EXCLUDED_TABLES = new Set(["sqlite_sequence", "_vertz_migrations"]);
+function mapSqliteType(rawType) {
+  const upper = rawType.toUpperCase();
+  if (upper === "TEXT")
+    return "text";
+  if (upper === "INTEGER" || upper === "INT")
+    return "integer";
+  if (upper === "REAL")
+    return "float";
+  if (upper === "BLOB")
+    return "blob";
+  return rawType.toLowerCase();
+}
+async function introspectSqlite(queryFn) {
+  const snapshot = {
+    version: 1,
+    tables: {},
+    enums: {}
+  };
+  const { rows: tableRows } = await queryFn("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'", []);
+  for (const row of tableRows) {
+    const tableName = row.name;
+    if (SQLITE_EXCLUDED_TABLES.has(tableName))
+      continue;
+    const columns = {};
+    const { rows: colRows } = await queryFn(`PRAGMA table_info("${tableName}")`, []);
+    for (const col of colRows) {
+      const colName = col.name;
+      const colSnap = {
+        type: mapSqliteType(col.type),
+        nullable: col.notnull === 0 && col.pk === 0,
+        primary: col.pk > 0,
+        unique: false
+      };
+      if (col.dflt_value != null) {
+        colSnap.default = String(col.dflt_value);
+      }
+      columns[colName] = colSnap;
+    }
+    const indexes = [];
+    const { rows: indexRows } = await queryFn(`PRAGMA index_list("${tableName}")`, []);
+    for (const idx of indexRows) {
+      const idxName = idx.name;
+      const isUnique = idx.unique === 1;
+      const origin = idx.origin;
+      const { rows: idxInfoRows } = await queryFn(`PRAGMA index_info("${idxName}")`, []);
+      const idxColumns = idxInfoRows.map((r) => r.name);
+      if (isUnique && idxColumns.length === 1 && origin === "u") {
+        const colName = idxColumns[0];
+        if (colName && columns[colName]) {
+          columns[colName].unique = true;
+        }
+      }
+      if (origin === "c") {
+        indexes.push({
+          columns: idxColumns,
+          name: idxName,
+          unique: isUnique
+        });
+      }
+    }
+    const foreignKeys = [];
+    const { rows: fkRows } = await queryFn(`PRAGMA foreign_key_list("${tableName}")`, []);
+    for (const fk of fkRows) {
+      foreignKeys.push({
+        column: fk.from,
+        targetTable: fk.table,
+        targetColumn: fk.to
+      });
+    }
+    snapshot.tables[tableName] = {
+      columns,
+      indexes,
+      foreignKeys,
+      _metadata: {}
+    };
+  }
+  return snapshot;
+}
+var PG_EXCLUDED_TABLES = new Set(["_vertz_migrations"]);
+async function introspectPostgres(queryFn) {
+  const snapshot = {
+    version: 1,
+    tables: {},
+    enums: {}
+  };
+  const { rows: tableRows } = await queryFn("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_type = 'BASE TABLE'", []);
+  const { rows: pkRows } = await queryFn(`SELECT kcu.table_name, kcu.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+     WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'`, []);
+  const pkMap = new Map;
+  for (const pk of pkRows) {
+    const tbl = pk.table_name;
+    if (!pkMap.has(tbl))
+      pkMap.set(tbl, new Set);
+    pkMap.get(tbl)?.add(pk.column_name);
+  }
+  const { rows: uniqueRows } = await queryFn(`SELECT tc.table_name, kcu.column_name, tc.constraint_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+     WHERE tc.constraint_type = 'UNIQUE' AND tc.table_schema = 'public'`, []);
+  const uniqueConstraintCols = new Map;
+  for (const u of uniqueRows) {
+    const cName = u.constraint_name;
+    if (!uniqueConstraintCols.has(cName)) {
+      uniqueConstraintCols.set(cName, { table: u.table_name, columns: [] });
+    }
+    uniqueConstraintCols.get(cName)?.columns.push(u.column_name);
+  }
+  const uniqueColMap = new Map;
+  for (const [, val] of uniqueConstraintCols) {
+    if (val.columns.length === 1) {
+      if (!uniqueColMap.has(val.table))
+        uniqueColMap.set(val.table, new Set);
+      uniqueColMap.get(val.table)?.add(val.columns[0]);
+    }
+  }
+  for (const row of tableRows) {
+    const tableName = row.table_name;
+    if (PG_EXCLUDED_TABLES.has(tableName))
+      continue;
+    const columns = {};
+    const pkCols = pkMap.get(tableName) ?? new Set;
+    const uniqueCols = uniqueColMap.get(tableName) ?? new Set;
+    const { rows: colRows } = await queryFn(`SELECT column_name, data_type, is_nullable, column_default
+       FROM information_schema.columns
+       WHERE table_name = $1 AND table_schema = 'public'
+       ORDER BY ordinal_position`, [tableName]);
+    for (const col of colRows) {
+      const colName = col.column_name;
+      const isPrimary = pkCols.has(colName);
+      const isUnique = uniqueCols.has(colName);
+      const colSnap = {
+        type: col.data_type,
+        nullable: col.is_nullable === "YES",
+        primary: isPrimary,
+        unique: isUnique
+      };
+      if (col.column_default != null) {
+        colSnap.default = String(col.column_default);
+      }
+      columns[colName] = colSnap;
+    }
+    const foreignKeys = [];
+    const { rows: fkRows } = await queryFn(`SELECT
+         kcu.column_name,
+         ccu.table_name AS target_table,
+         ccu.column_name AS target_column
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+       JOIN information_schema.constraint_column_usage ccu
+         ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+       WHERE tc.constraint_type = 'FOREIGN KEY'
+         AND tc.table_name = $1
+         AND tc.table_schema = 'public'`, [tableName]);
+    for (const fk of fkRows) {
+      foreignKeys.push({
+        column: fk.column_name,
+        targetTable: fk.target_table,
+        targetColumn: fk.target_column
+      });
+    }
+    const indexes = [];
+    const { rows: idxRows } = await queryFn(`SELECT i.relname AS index_name,
+              array_agg(a.attname ORDER BY k.n) AS columns,
+              ix.indisunique AS is_unique
+       FROM pg_index ix
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN pg_class t ON t.oid = ix.indrelid
+       JOIN pg_namespace ns ON ns.oid = t.relnamespace
+       JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+       WHERE t.relname = $1
+         AND ns.nspname = 'public'
+         AND NOT ix.indisprimary
+         AND NOT ix.indisunique
+       GROUP BY i.relname, ix.indisunique`, [tableName]);
+    for (const idx of idxRows) {
+      indexes.push({
+        columns: idx.columns,
+        name: idx.index_name,
+        unique: idx.is_unique
+      });
+    }
+    snapshot.tables[tableName] = {
+      columns,
+      indexes,
+      foreignKeys,
+      _metadata: {}
+    };
+  }
+  const { rows: enumRows } = await queryFn(`SELECT t.typname AS enum_name, e.enumlabel AS enum_value
+     FROM pg_type t
+     JOIN pg_enum e ON t.oid = e.enumtypid
+     JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+     WHERE n.nspname = 'public'
+     ORDER BY t.typname, e.enumsortorder`, []);
+  for (const row of enumRows) {
+    const enumName = row.enum_name;
+    const enumValue = row.enum_value;
+    if (!snapshot.enums[enumName]) {
+      snapshot.enums[enumName] = [];
+    }
+    snapshot.enums[enumName].push(enumValue);
+  }
+  return snapshot;
+}
+// src/migration/journal.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+function createJournal() {
+  return {
+    version: 1,
+    migrations: []
+  };
+}
+function addJournalEntry(journal, entry) {
+  return {
+    ...journal,
+    migrations: [...journal.migrations, entry]
+  };
+}
+function detectCollisions(journal, existingFiles) {
+  const journalSeqNumbers = new Map;
+  for (const entry of journal.migrations) {
+    const parsed = parseMigrationName(entry.name);
+    if (parsed) {
+      journalSeqNumbers.set(parsed.timestamp, entry.name);
+    }
+  }
+  const allUsedSeqNumbers = new Set(journalSeqNumbers.keys());
+  for (const file of existingFiles) {
+    const parsed = parseMigrationName(file);
+    if (parsed) {
+      allUsedSeqNumbers.add(parsed.timestamp);
+    }
+  }
+  const collisions = [];
+  for (const file of existingFiles) {
+    const parsed = parseMigrationName(file);
+    if (!parsed)
+      continue;
+    const journalEntry = journalSeqNumbers.get(parsed.timestamp);
+    if (journalEntry && journalEntry !== file) {
+      let nextSeq = Math.max(...allUsedSeqNumbers) + 1;
+      for (const c of collisions) {
+        const suggestedParsed = parseMigrationName(c.suggestedName);
+        if (suggestedParsed && suggestedParsed.timestamp >= nextSeq) {
+          nextSeq = suggestedParsed.timestamp + 1;
+        }
+      }
+      const description = file.replace(/^\d+_/, "").replace(/\.sql$/, "");
+      collisions.push({
+        existingName: journalEntry,
+        conflictingName: file,
+        sequenceNumber: parsed.timestamp,
+        suggestedName: formatMigrationFilename(nextSeq, description)
+      });
+    }
+  }
+  return collisions;
+}
+// src/migration/snapshot.ts
+function createSnapshot(tables) {
+  const snapshot = {
+    version: 1,
+    tables: {},
+    enums: {}
+  };
+  for (const table of tables) {
+    const columns = {};
+    const foreignKeys = [];
+    const indexes = [];
+    for (const [colName, col] of Object.entries(table._columns)) {
+      const meta = col._meta;
+      const colSnap = {
+        type: meta.sqlType,
+        nullable: meta.nullable,
+        primary: meta.primary,
+        unique: meta.unique
+      };
+      if (meta.hasDefault && meta.defaultValue !== undefined) {
+        const rawDefault = String(meta.defaultValue);
+        colSnap.default = rawDefault === "now" ? "now()" : rawDefault;
+      }
+      const annotationNames = meta._annotations ? Object.keys(meta._annotations) : [];
+      if (annotationNames.length > 0) {
+        colSnap.annotations = annotationNames;
+      }
+      columns[colName] = colSnap;
+      if (meta.references) {
+        foreignKeys.push({
+          column: colName,
+          targetTable: meta.references.table,
+          targetColumn: meta.references.column
+        });
+      }
+      if (meta.enumName && meta.enumValues) {
+        snapshot.enums[meta.enumName] = [...meta.enumValues];
+      }
+    }
+    for (const idx of table._indexes) {
+      indexes.push({ columns: [...idx.columns] });
+    }
+    snapshot.tables[table._name] = {
+      columns,
+      indexes,
+      foreignKeys,
+      _metadata: {}
+    };
+  }
+  return snapshot;
+}
+// src/cli/baseline.ts
+async function baseline(options) {
+  const runner = createMigrationRunner({ dialect: options.dialect });
+  const createResult = await runner.createHistoryTable(options.queryFn);
+  if (!createResult.ok) {
+    return createResult;
+  }
+  const appliedResult = await runner.getApplied(options.queryFn);
+  if (!appliedResult.ok) {
+    return appliedResult;
+  }
+  const appliedNames = new Set(appliedResult.data.map((a) => a.name));
+  const recorded = [];
+  for (const file of options.migrationFiles) {
+    if (appliedNames.has(file.name)) {
+      continue;
+    }
+    const checksum = await computeChecksum(file.sql);
+    const dialect = options.dialect;
+    const param1 = dialect ? dialect.param(1) : "$1";
+    const param2 = dialect ? dialect.param(2) : "$2";
+    await options.queryFn(`INSERT INTO "_vertz_migrations" ("name", "checksum") VALUES (${param1}, ${param2})`, [file.name, checksum]);
+    recorded.push(file.name);
+  }
+  return {
+    ok: true,
+    data: { recorded }
+  };
+}
 // src/cli/migrate-deploy.ts
 async function migrateDeploy(options) {
   const runner = createMigrationRunner();
   const isDryRun = options.dryRun ?? false;
   if (!isDryRun) {
-    await runner.createHistoryTable(options.queryFn);
+    const createResult = await runner.createHistoryTable(options.queryFn);
+    if (!createResult.ok) {
+      return createResult;
+    }
   }
   let applied;
   if (isDryRun) {
-    try {
-      applied = await runner.getApplied(options.queryFn);
-    } catch {
+    const appliedResult = await runner.getApplied(options.queryFn);
+    if (!appliedResult.ok) {
       applied = [];
+    } else {
+      applied = appliedResult.data;
     }
   } else {
-    applied = await runner.getApplied(options.queryFn);
+    const appliedResult = await runner.getApplied(options.queryFn);
+    if (!appliedResult.ok) {
+      return appliedResult;
+    }
+    applied = appliedResult.data;
   }
   const pending = runner.getPending(options.migrationFiles, applied);
   const appliedNames = [];
@@ -475,17 +1022,72 @@ async function migrateDeploy(options) {
     const result = await runner.apply(options.queryFn, migration.sql, migration.name, {
       dryRun: isDryRun
     });
+    if (!result.ok) {
+      return result;
+    }
     appliedNames.push(migration.name);
-    migrationResults.push(result);
+    migrationResults.push(result.data);
   }
   return {
-    applied: appliedNames,
-    alreadyApplied: applied.map((a) => a.name),
-    dryRun: isDryRun,
-    migrations: migrationResults.length > 0 ? migrationResults : undefined
+    ok: true,
+    data: {
+      applied: appliedNames,
+      alreadyApplied: applied.map((a) => a.name),
+      dryRun: isDryRun,
+      migrations: migrationResults.length > 0 ? migrationResults : undefined
+    }
   };
 }
 // src/cli/migrate-dev.ts
+function toKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function generateMigrationName(changes) {
+  if (changes.length === 0)
+    return "empty-migration";
+  if (changes.length === 1) {
+    const change = changes[0];
+    switch (change.type) {
+      case "table_added":
+        return `add-${toKebab(change.table)}-table`;
+      case "table_removed":
+        return `drop-${toKebab(change.table)}-table`;
+      case "column_added":
+        return `add-${toKebab(change.column)}-to-${toKebab(change.table)}`;
+      case "column_removed":
+        return `drop-${toKebab(change.column)}-from-${toKebab(change.table)}`;
+      case "column_altered":
+        return `alter-${toKebab(change.column)}-in-${toKebab(change.table)}`;
+      case "column_renamed":
+        return `rename-${toKebab(change.oldColumn)}-to-${toKebab(change.newColumn)}-in-${toKebab(change.table)}`;
+      case "index_added":
+        return `add-index-to-${toKebab(change.table)}`;
+      case "index_removed":
+        return `drop-index-from-${toKebab(change.table)}`;
+      case "enum_added":
+        return `add-${toKebab(change.enumName)}-enum`;
+      case "enum_removed":
+        return `drop-${toKebab(change.enumName)}-enum`;
+      case "enum_altered":
+        return `alter-${toKebab(change.enumName)}-enum`;
+    }
+  }
+  const tables = new Set(changes.map((c) => c.table).filter(Boolean));
+  const types = new Set(changes.map((c) => c.type));
+  if (tables.size === 1 && types.size === 1) {
+    const table = [...tables][0];
+    const type = [...types][0];
+    switch (type) {
+      case "column_added":
+        return `add-columns-to-${toKebab(table)}`;
+      case "column_removed":
+        return `drop-columns-from-${toKebab(table)}`;
+      default:
+        return `update-${toKebab(table)}`;
+    }
+  }
+  return "update-schema";
+}
 async function migrateDev(options) {
   const diff = computeDiff(options.previousSnapshot, options.currentSnapshot);
   const sql = generateMigrationSql(diff.changes, {
@@ -498,19 +1100,40 @@ async function migrateDev(options) {
     newColumn: c.newColumn,
     confidence: c.confidence
   }));
+  const migrationName = options.migrationName ?? generateMigrationName(diff.changes);
   const num = nextMigrationNumber(options.existingFiles);
-  const filename = formatMigrationFilename(num, options.migrationName);
+  const filename = formatMigrationFilename(num, migrationName);
   const filePath = `${options.migrationsDir}/${filename}`;
+  const journalPath = `${options.migrationsDir}/_journal.json`;
+  let journal;
+  try {
+    const content = options.readFile ? await options.readFile(journalPath) : '{"version":1,"migrations":[]}';
+    journal = JSON.parse(content);
+  } catch {
+    journal = createJournal();
+  }
+  const collisions = detectCollisions(journal, options.existingFiles);
   if (options.dryRun) {
     return {
       migrationFile: filename,
       sql,
       dryRun: true,
       renames: renames.length > 0 ? renames : undefined,
+      collisions: collisions.length > 0 ? collisions : undefined,
       snapshot: options.currentSnapshot
     };
   }
   await options.writeFile(filePath, sql);
+  const checksum = await computeChecksum(sql);
+  journal = addJournalEntry(journal, {
+    name: filename,
+    description: migrationName,
+    createdAt: new Date().toISOString(),
+    checksum
+  });
+  await options.writeFile(journalPath, JSON.stringify(journal, null, 2));
+  const snapshotPath = `${options.migrationsDir}/_snapshot.json`;
+  await options.writeFile(snapshotPath, JSON.stringify(options.currentSnapshot, null, 2));
   const runner = createMigrationRunner();
   await runner.createHistoryTable(options.queryFn);
   await runner.apply(options.queryFn, sql, filename, { dryRun: false });
@@ -520,6 +1143,7 @@ async function migrateDev(options) {
     appliedAt: new Date,
     dryRun: false,
     renames: renames.length > 0 ? renames : undefined,
+    collisions: collisions.length > 0 ? collisions : undefined,
     snapshot: options.currentSnapshot
   };
 }
@@ -538,21 +1162,419 @@ async function push(options) {
   ];
   return { sql, tablesAffected };
 }
+// src/cli/reset.ts
+import { createMigrationQueryError as createMigrationQueryError2, err as err2 } from "@vertz/errors";
+var HISTORY_TABLE2 = "_vertz_migrations";
+function getUserTablesQuery(dialect) {
+  if (dialect.name === "sqlite") {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+  }
+  return `SELECT tablename AS name FROM pg_tables WHERE schemaname = 'public'`;
+}
+function buildDropTableSql(tableName, dialect) {
+  if (dialect.name === "postgres") {
+    return `DROP TABLE IF EXISTS "${tableName}" CASCADE`;
+  }
+  return `DROP TABLE IF EXISTS "${tableName}"`;
+}
+async function reset(options) {
+  const dialect = options.dialect ?? defaultPostgresDialect;
+  const runner = createMigrationRunner({ dialect });
+  let tableNames;
+  try {
+    const tablesResult = await options.queryFn(getUserTablesQuery(dialect), []);
+    tableNames = tablesResult.rows.map((row) => row.name);
+  } catch (cause) {
+    return err2(createMigrationQueryError2("Failed to list user tables", { cause }));
+  }
+  const tablesDropped = [];
+  for (const tableName of tableNames) {
+    try {
+      await options.queryFn(buildDropTableSql(tableName, dialect), []);
+      if (tableName !== HISTORY_TABLE2) {
+        tablesDropped.push(tableName);
+      }
+    } catch (cause) {
+      return err2(createMigrationQueryError2(`Failed to drop table: ${tableName}`, { cause }));
+    }
+  }
+  try {
+    await options.queryFn(buildDropTableSql(HISTORY_TABLE2, dialect), []);
+  } catch (cause) {
+    return err2(createMigrationQueryError2("Failed to drop history table", { cause }));
+  }
+  const createResult = await runner.createHistoryTable(options.queryFn);
+  if (!createResult.ok) {
+    return createResult;
+  }
+  const sorted = [...options.migrationFiles].sort((a, b) => a.timestamp - b.timestamp);
+  const migrationsApplied = [];
+  for (const file of sorted) {
+    const applyResult = await runner.apply(options.queryFn, file.sql, file.name);
+    if (!applyResult.ok) {
+      return applyResult;
+    }
+    migrationsApplied.push(file.name);
+  }
+  return {
+    ok: true,
+    data: { tablesDropped, migrationsApplied }
+  };
+}
 // src/cli/status.ts
+function diffChangeToCodeChange(change) {
+  switch (change.type) {
+    case "table_added":
+      return {
+        description: `Added table '${change.table}'`,
+        type: change.type,
+        table: change.table
+      };
+    case "table_removed":
+      return {
+        description: `Removed table '${change.table}'`,
+        type: change.type,
+        table: change.table
+      };
+    case "column_added":
+      return {
+        description: `Added column '${change.column}' to table '${change.table}'`,
+        type: change.type,
+        table: change.table,
+        column: change.column
+      };
+    case "column_removed":
+      return {
+        description: `Removed column '${change.column}' from table '${change.table}'`,
+        type: change.type,
+        table: change.table,
+        column: change.column
+      };
+    case "column_altered":
+      return {
+        description: `Altered column '${change.column}' in table '${change.table}'`,
+        type: change.type,
+        table: change.table,
+        column: change.column
+      };
+    case "column_renamed":
+      return {
+        description: `Renamed column in table '${change.table}'`,
+        type: change.type,
+        table: change.table
+      };
+    case "index_added":
+      return {
+        description: `Added index on table '${change.table}'`,
+        type: change.type,
+        table: change.table
+      };
+    case "index_removed":
+      return {
+        description: `Removed index on table '${change.table}'`,
+        type: change.type,
+        table: change.table
+      };
+    case "enum_added":
+      return {
+        description: `Added enum type`,
+        type: change.type
+      };
+    case "enum_removed":
+      return {
+        description: `Removed enum type`,
+        type: change.type
+      };
+    case "enum_altered":
+      return {
+        description: `Altered enum type`,
+        type: change.type
+      };
+  }
+}
+function detectSchemaDrift(expected, actual) {
+  const drift = [];
+  for (const tableName of Object.keys(actual.tables)) {
+    if (!(tableName in expected.tables)) {
+      drift.push({
+        description: `Table '${tableName}' exists in database but not in schema`,
+        type: "extra_table",
+        table: tableName
+      });
+    }
+  }
+  for (const tableName of Object.keys(expected.tables)) {
+    if (!(tableName in actual.tables)) {
+      drift.push({
+        description: `Table '${tableName}' exists in schema but not in database`,
+        type: "missing_table",
+        table: tableName
+      });
+    }
+  }
+  for (const tableName of Object.keys(expected.tables)) {
+    if (!(tableName in actual.tables))
+      continue;
+    const expectedTable = expected.tables[tableName];
+    const actualTable = actual.tables[tableName];
+    if (!expectedTable || !actualTable)
+      continue;
+    for (const colName of Object.keys(actualTable.columns)) {
+      if (!(colName in expectedTable.columns)) {
+        drift.push({
+          description: `Column '${colName}' exists in database table '${tableName}' but not in schema`,
+          type: "extra_column",
+          table: tableName,
+          column: colName
+        });
+      }
+    }
+    for (const colName of Object.keys(expectedTable.columns)) {
+      if (!(colName in actualTable.columns)) {
+        drift.push({
+          description: `Column '${colName}' exists in schema table '${tableName}' but not in database`,
+          type: "missing_column",
+          table: tableName,
+          column: colName
+        });
+      }
+    }
+    for (const colName of Object.keys(expectedTable.columns)) {
+      if (!(colName in actualTable.columns))
+        continue;
+      const expectedCol = expectedTable.columns[colName];
+      const actualCol = actualTable.columns[colName];
+      if (!expectedCol || !actualCol)
+        continue;
+      if (expectedCol.type !== actualCol.type) {
+        drift.push({
+          description: `Column '${colName}' in table '${tableName}' has type '${actualCol.type}' in database but '${expectedCol.type}' in schema`,
+          type: "column_type_mismatch",
+          table: tableName,
+          column: colName
+        });
+      }
+    }
+  }
+  return drift;
+}
 async function migrateStatus(options) {
   const runner = createMigrationRunner();
-  await runner.createHistoryTable(options.queryFn);
-  const applied = await runner.getApplied(options.queryFn);
+  const createResult = await runner.createHistoryTable(options.queryFn);
+  if (!createResult.ok) {
+    return createResult;
+  }
+  const appliedResult = await runner.getApplied(options.queryFn);
+  if (!appliedResult.ok) {
+    return appliedResult;
+  }
+  const applied = appliedResult.data;
   const pending = runner.getPending(options.migrationFiles, applied);
+  let codeChanges = [];
+  if (options.savedSnapshot && options.currentSnapshot) {
+    const diff = computeDiff(options.savedSnapshot, options.currentSnapshot);
+    codeChanges = diff.changes.map(diffChangeToCodeChange);
+  }
+  let drift = [];
+  if (options.dialect) {
+    const introspect = options.dialect.name === "sqlite" ? introspectSqlite : introspectPostgres;
+    const actualSchema = await introspect(options.queryFn);
+    const expectedSchema = options.savedSnapshot ?? options.currentSnapshot;
+    if (expectedSchema) {
+      drift = detectSchemaDrift(expectedSchema, actualSchema);
+    }
+  }
   return {
-    applied: applied.map((a) => ({
-      name: a.name,
-      checksum: a.checksum,
-      appliedAt: a.appliedAt
-    })),
-    pending: pending.map((p) => p.name)
+    ok: true,
+    data: {
+      applied: applied.map((a) => ({
+        name: a.name,
+        checksum: a.checksum,
+        appliedAt: a.appliedAt
+      })),
+      pending: pending.map((p) => p.name),
+      codeChanges,
+      drift
+    }
   };
 }
+// src/client/database.ts
+import { err as err3, ok as ok2 } from "@vertz/schema";
+// src/errors/error-codes.ts
+var DbErrorCode = {
+  UNIQUE_VIOLATION: "23505",
+  FOREIGN_KEY_VIOLATION: "23503",
+  NOT_NULL_VIOLATION: "23502",
+  CHECK_VIOLATION: "23514",
+  EXCLUSION_VIOLATION: "23P01",
+  SERIALIZATION_FAILURE: "40001",
+  DEADLOCK_DETECTED: "40P01",
+  CONNECTION_EXCEPTION: "08000",
+  CONNECTION_DOES_NOT_EXIST: "08003",
+  CONNECTION_FAILURE: "08006",
+  NotFound: "NotFound",
+  CONNECTION_ERROR: "CONNECTION_ERROR",
+  POOL_EXHAUSTED: "POOL_EXHAUSTED"
+};
+var PgCodeToName = Object.fromEntries(Object.entries(DbErrorCode).map(([name, pgCode]) => [pgCode, name]));
+function resolveErrorCode(pgCode) {
+  return PgCodeToName[pgCode];
+}
+// src/errors/http-adapter.ts
+function dbErrorToHttpError(error) {
+  const body = error.toJSON();
+  if (error instanceof UniqueConstraintError) {
+    return { status: 409, body };
+  }
+  if (error instanceof NotFoundError) {
+    return { status: 404, body };
+  }
+  if (error instanceof ForeignKeyError) {
+    return { status: 422, body };
+  }
+  if (error instanceof NotNullError) {
+    return { status: 422, body };
+  }
+  if (error instanceof CheckConstraintError) {
+    return { status: 422, body };
+  }
+  if (error instanceof ConnectionError) {
+    return { status: 503, body };
+  }
+  return { status: 500, body };
+}
+// src/errors.ts
+function toReadError(error, query) {
+  if (typeof error === "object" && error !== null && "code" in error) {
+    const errWithCode = error;
+    if (errWithCode.code === "NotFound") {
+      return {
+        code: "NotFound",
+        message: errWithCode.message,
+        table: errWithCode.table ?? "unknown",
+        cause: error
+      };
+    }
+    if (errWithCode.code.startsWith("08")) {
+      return {
+        code: "CONNECTION_ERROR",
+        message: errWithCode.message,
+        cause: error
+      };
+    }
+    return {
+      code: "QUERY_ERROR",
+      message: errWithCode.message,
+      sql: query,
+      cause: error
+    };
+  }
+  if (error instanceof Error) {
+    const message2 = error.message.toLowerCase();
+    if (message2.includes("connection") || message2.includes("ECONNREFUSED") || message2.includes("timeout")) {
+      return {
+        code: "CONNECTION_ERROR",
+        message: error.message,
+        cause: error
+      };
+    }
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    code: "QUERY_ERROR",
+    message,
+    sql: query,
+    cause: error
+  };
+}
+function toWriteError(error, query) {
+  if (error instanceof UniqueConstraintError) {
+    return {
+      code: "CONSTRAINT_ERROR",
+      message: error.message,
+      column: error.column,
+      table: error.table,
+      cause: error
+    };
+  }
+  if (error instanceof ForeignKeyError) {
+    return {
+      code: "CONSTRAINT_ERROR",
+      message: error.message,
+      constraint: error.constraint,
+      table: error.table,
+      cause: error
+    };
+  }
+  if (error instanceof NotNullError) {
+    return {
+      code: "CONSTRAINT_ERROR",
+      message: error.message,
+      column: error.column,
+      table: error.table,
+      cause: error
+    };
+  }
+  if (error instanceof CheckConstraintError) {
+    return {
+      code: "CONSTRAINT_ERROR",
+      message: error.message,
+      constraint: error.constraint,
+      table: error.table,
+      cause: error
+    };
+  }
+  if (error instanceof ConnectionError) {
+    return {
+      code: "CONNECTION_ERROR",
+      message: error.message,
+      cause: error
+    };
+  }
+  if (typeof error === "object" && error !== null && "code" in error) {
+    const pgError = error;
+    if (pgError.code.startsWith("08")) {
+      return {
+        code: "CONNECTION_ERROR",
+        message: pgError.message,
+        cause: error
+      };
+    }
+    if (pgError.code === "23505" || pgError.code === "23503" || pgError.code === "23502" || pgError.code === "23514") {
+      if (pgError.code === "23505" || pgError.code === "23502") {
+        return {
+          code: "CONSTRAINT_ERROR",
+          message: pgError.message,
+          table: pgError.table,
+          column: pgError.column,
+          cause: error
+        };
+      } else {
+        return {
+          code: "CONSTRAINT_ERROR",
+          message: pgError.message,
+          table: pgError.table,
+          constraint: pgError.constraint,
+          cause: error
+        };
+      }
+    }
+    return {
+      code: "QUERY_ERROR",
+      message: pgError.message,
+      sql: query,
+      cause: error
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    code: "QUERY_ERROR",
+    message,
+    sql: query,
+    cause: error
+  };
+}
+
 // src/query/aggregate.ts
 async function count(queryFn, table, options) {
   const allParams = [];
@@ -779,19 +1801,33 @@ async function groupBy(queryFn, table, options) {
 }
 
 // src/query/crud.ts
+function fillGeneratedIds(table, data) {
+  const filled = { ...data };
+  for (const [name, col] of Object.entries(table._columns)) {
+    const meta = col._meta;
+    if (meta.generate && filled[name] === undefined) {
+      if (meta.sqlType === "integer" || meta.sqlType === "serial" || meta.sqlType === "bigint") {
+        throw new Error(`Column "${name}" has generate: '${meta.generate}' but is type '${meta.sqlType}'. ` + `ID generation is only supported on string column types (text, uuid, varchar).`);
+      }
+      filled[name] = generateId(meta.generate);
+    }
+  }
+  return filled;
+}
 function assertNonEmptyWhere(where, operation) {
   if (Object.keys(where).length === 0) {
     throw new Error(`${operation} requires a non-empty where clause. ` + "Passing an empty where object would affect all rows.");
   }
 }
-async function get(queryFn, table, options) {
+async function get(queryFn, table, options, dialect = defaultPostgresDialect) {
   const columns = resolveSelectColumns(table, options?.select);
   const result = buildSelect({
     table: table._name,
     columns,
     where: options?.where,
     orderBy: options?.orderBy,
-    limit: 1
+    limit: 1,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   if (res.rows.length === 0) {
@@ -799,14 +1835,7 @@ async function get(queryFn, table, options) {
   }
   return mapRow(res.rows[0]);
 }
-async function getOrThrow(queryFn, table, options) {
-  const row = await get(queryFn, table, options);
-  if (row === null) {
-    throw new NotFoundError(table._name);
-  }
-  return row;
-}
-async function list(queryFn, table, options) {
+async function list(queryFn, table, options, dialect = defaultPostgresDialect) {
   const columns = resolveSelectColumns(table, options?.select);
   const result = buildSelect({
     table: table._name,
@@ -816,12 +1845,13 @@ async function list(queryFn, table, options) {
     limit: options?.limit,
     offset: options?.offset,
     cursor: options?.cursor,
-    take: options?.take
+    take: options?.take,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return mapRows(res.rows);
 }
-async function listAndCount(queryFn, table, options) {
+async function listAndCount(queryFn, table, options, dialect = defaultPostgresDialect) {
   const columns = resolveSelectColumns(table, options?.select);
   const result = buildSelect({
     table: table._name,
@@ -832,7 +1862,8 @@ async function listAndCount(queryFn, table, options) {
     offset: options?.offset,
     cursor: options?.cursor,
     take: options?.take,
-    withCount: true
+    withCount: true,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   const rows = res.rows;
@@ -847,55 +1878,97 @@ async function listAndCount(queryFn, table, options) {
   });
   return { data, total };
 }
-async function create(queryFn, table, options) {
+async function create(queryFn, table, options, dialect = defaultPostgresDialect) {
   const returningColumns = resolveSelectColumns(table, options.select);
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const withIds = fillGeneratedIds(table, options.data);
+  const filteredData = Object.fromEntries(Object.entries(withIds).filter(([key]) => {
+    const col = table._columns[key];
+    const meta = col ? col._meta : undefined;
+    if (meta?.generate)
+      return true;
+    return !readOnlyCols.includes(key);
+  }));
   const result = buildInsert({
     table: table._name,
-    data: options.data,
+    data: filteredData,
     returning: returningColumns,
-    nowColumns
+    nowColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return mapRow(res.rows[0]);
 }
-async function createMany(queryFn, table, options) {
+async function createMany(queryFn, table, options, dialect = defaultPostgresDialect) {
   if (options.data.length === 0) {
     return { count: 0 };
   }
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const filteredData = options.data.map((row) => {
+    const withIds = fillGeneratedIds(table, row);
+    return Object.fromEntries(Object.entries(withIds).filter(([key]) => {
+      const col = table._columns[key];
+      const meta = col ? col._meta : undefined;
+      if (meta?.generate)
+        return true;
+      return !readOnlyCols.includes(key);
+    }));
+  });
   const result = buildInsert({
     table: table._name,
-    data: options.data,
-    nowColumns
+    data: filteredData,
+    nowColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return { count: res.rowCount };
 }
-async function createManyAndReturn(queryFn, table, options) {
+async function createManyAndReturn(queryFn, table, options, dialect = defaultPostgresDialect) {
   if (options.data.length === 0) {
     return [];
   }
   const returningColumns = resolveSelectColumns(table, options.select);
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const filteredData = options.data.map((row) => {
+    const withIds = fillGeneratedIds(table, row);
+    return Object.fromEntries(Object.entries(withIds).filter(([key]) => {
+      const col = table._columns[key];
+      const meta = col ? col._meta : undefined;
+      if (meta?.generate)
+        return true;
+      return !readOnlyCols.includes(key);
+    }));
+  });
   const result = buildInsert({
     table: table._name,
-    data: options.data,
+    data: filteredData,
     returning: returningColumns,
-    nowColumns
+    nowColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return mapRows(res.rows);
 }
-async function update(queryFn, table, options) {
+async function update(queryFn, table, options, dialect = defaultPostgresDialect) {
   const returningColumns = resolveSelectColumns(table, options.select);
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const autoUpdateCols = getAutoUpdateColumns(table);
+  const filteredData = Object.fromEntries(Object.entries(options.data).filter(([key]) => !readOnlyCols.includes(key)));
+  for (const col of autoUpdateCols) {
+    filteredData[col] = "now";
+  }
+  const allNowColumns = [...new Set([...nowColumns, ...autoUpdateCols])];
   const result = buildUpdate({
     table: table._name,
-    data: options.data,
+    data: filteredData,
     where: options.where,
     returning: returningColumns,
-    nowColumns
+    nowColumns: allNowColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   if (res.rows.length === 0) {
@@ -903,44 +1976,69 @@ async function update(queryFn, table, options) {
   }
   return mapRow(res.rows[0]);
 }
-async function updateMany(queryFn, table, options) {
+async function updateMany(queryFn, table, options, dialect = defaultPostgresDialect) {
   assertNonEmptyWhere(options.where, "updateMany");
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const autoUpdateCols = getAutoUpdateColumns(table);
+  const filteredData = Object.fromEntries(Object.entries(options.data).filter(([key]) => !readOnlyCols.includes(key)));
+  for (const col of autoUpdateCols) {
+    filteredData[col] = "now";
+  }
+  const allNowColumns = [...new Set([...nowColumns, ...autoUpdateCols])];
   const result = buildUpdate({
     table: table._name,
-    data: options.data,
+    data: filteredData,
     where: options.where,
-    nowColumns
+    nowColumns: allNowColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return { count: res.rowCount };
 }
-async function upsert(queryFn, table, options) {
+async function upsert(queryFn, table, options, dialect = defaultPostgresDialect) {
   const returningColumns = resolveSelectColumns(table, options.select);
   const nowColumns = getTimestampColumns(table);
+  const readOnlyCols = getReadOnlyColumns(table);
+  const autoUpdateCols = getAutoUpdateColumns(table);
   const conflictColumns = Object.keys(options.where);
-  const updateColumns = Object.keys(options.update);
+  const createWithIds = fillGeneratedIds(table, options.create);
+  const filteredCreate = Object.fromEntries(Object.entries(createWithIds).filter(([key]) => {
+    const col = table._columns[key];
+    const meta = col ? col._meta : undefined;
+    if (meta?.generate)
+      return true;
+    return !readOnlyCols.includes(key);
+  }));
+  const filteredUpdate = Object.fromEntries(Object.entries(options.update).filter(([key]) => !readOnlyCols.includes(key)));
+  for (const col of autoUpdateCols) {
+    filteredUpdate[col] = "now";
+  }
+  const allNowColumns = [...new Set([...nowColumns, ...autoUpdateCols])];
+  const updateColumns = Object.keys(filteredUpdate);
   const result = buildInsert({
     table: table._name,
-    data: options.create,
+    data: filteredCreate,
     returning: returningColumns,
-    nowColumns,
+    nowColumns: allNowColumns,
     onConflict: {
       columns: conflictColumns,
       action: "update",
       updateColumns,
-      updateValues: options.update
-    }
+      updateValues: filteredUpdate
+    },
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return mapRow(res.rows[0]);
 }
-async function deleteOne(queryFn, table, options) {
+async function deleteOne(queryFn, table, options, dialect = defaultPostgresDialect) {
   const returningColumns = resolveSelectColumns(table, options.select);
   const result = buildDelete({
     table: table._name,
     where: options.where,
-    returning: returningColumns
+    returning: returningColumns,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   if (res.rows.length === 0) {
@@ -948,11 +2046,12 @@ async function deleteOne(queryFn, table, options) {
   }
   return mapRow(res.rows[0]);
 }
-async function deleteMany(queryFn, table, options) {
+async function deleteMany(queryFn, table, options, dialect = defaultPostgresDialect) {
   assertNonEmptyWhere(options.where, "deleteMany");
   const result = buildDelete({
     table: table._name,
-    where: options.where
+    where: options.where,
+    dialect
   });
   const res = await executeQuery(queryFn, result.sql, result.params);
   return { count: res.rowCount };
@@ -1187,60 +2286,95 @@ async function loadManyToManyRelation(queryFn, primaryRows, def, target, relName
   }
 }
 
-// src/client/postgres-driver.ts
-import postgresLib from "postgres";
-function isPostgresError(error) {
-  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && "message" in error && typeof error.message === "string";
-}
-function adaptPostgresError(error) {
-  if (isPostgresError(error)) {
-    const adapted = Object.assign(new Error(error.message), {
-      code: error.code,
-      message: error.message,
-      table: error.table_name,
-      column: error.column_name,
-      constraint: error.constraint_name,
-      detail: error.detail
-    });
-    throw adapted;
+// src/client/sqlite-value-converter.ts
+function fromSqliteValue(value, columnType) {
+  if (columnType === "boolean") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+  if ((columnType === "timestamp" || columnType === "timestamp with time zone") && typeof value === "string") {
+    return new Date(value);
   }
-  throw error;
+  return value;
 }
-function createPostgresDriver(url, pool) {
-  const sql = postgresLib(url, {
-    max: pool?.max ?? 10,
-    idle_timeout: pool?.idleTimeout !== undefined ? pool.idleTimeout / 1000 : 30,
-    connect_timeout: pool?.connectionTimeout !== undefined ? pool.connectionTimeout / 1000 : 10,
-    fetch_types: false
-  });
-  const queryFn = async (sqlStr, params) => {
-    try {
-      const result = await sql.unsafe(sqlStr, params);
-      const rows = result.map((row) => {
-        const mapped = {};
-        for (const [key, value] of Object.entries(row)) {
-          mapped[key] = coerceValue(value);
+
+// src/client/sqlite-driver.ts
+function buildTableSchema(models) {
+  const registry = new Map;
+  for (const [, entry] of Object.entries(models)) {
+    const tableName = entry.table._name;
+    const columnTypes = {};
+    for (const [colName, colBuilder] of Object.entries(entry.table._columns)) {
+      const meta = colBuilder._meta;
+      columnTypes[colName] = meta.sqlType;
+    }
+    registry.set(tableName, columnTypes);
+  }
+  return registry;
+}
+function extractTableName(sql) {
+  const fromMatch = sql.match(/\bFROM\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/i);
+  if (fromMatch) {
+    return fromMatch[1].toLowerCase();
+  }
+  const insertMatch = sql.match(/\bINSERT\s+INTO\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/i);
+  if (insertMatch) {
+    return insertMatch[1].toLowerCase();
+  }
+  const updateMatch = sql.match(/\bUPDATE\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/i);
+  if (updateMatch) {
+    return updateMatch[1].toLowerCase();
+  }
+  const deleteMatch = sql.match(/\bDELETE\s+FROM\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/i);
+  if (deleteMatch) {
+    return deleteMatch[1].toLowerCase();
+  }
+  return null;
+}
+function createSqliteDriver(d1, tableSchema) {
+  const query = async (sql, params) => {
+    const prepared = d1.prepare(sql);
+    const bound = params ? prepared.bind(...params) : prepared;
+    const result = await bound.all();
+    if (tableSchema && result.results.length > 0) {
+      const tableName = extractTableName(sql);
+      if (tableName) {
+        const schema = tableSchema.get(tableName);
+        if (schema) {
+          return result.results.map((row) => {
+            const convertedRow = {};
+            for (const [key, value] of Object.entries(row)) {
+              const columnType = schema[key];
+              if (columnType) {
+                convertedRow[key] = fromSqliteValue(value, columnType);
+              } else {
+                convertedRow[key] = value;
+              }
+            }
+            return convertedRow;
+          });
         }
-        return mapped;
-      });
-      return {
-        rows,
-        rowCount: result.count ?? rows.length
-      };
-    } catch (error) {
-      adaptPostgresError(error);
+      }
     }
+    return result.results;
+  };
+  const execute = async (sql, params) => {
+    const prepared = d1.prepare(sql);
+    const bound = params ? prepared.bind(...params) : prepared;
+    const result = await bound.run();
+    return { rowsAffected: result.meta.changes };
   };
   return {
-    queryFn,
-    async close() {
-      await sql.end();
-    },
-    async isHealthy() {
+    query,
+    execute,
+    close: async () => {},
+    isHealthy: async () => {
       try {
-        const healthCheckTimeout = pool?.healthCheckTimeout ?? 5000;
-        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Health check timed out")), healthCheckTimeout));
-        await Promise.race([sql`SELECT 1`, timeout]);
+        await query("SELECT 1");
         return true;
       } catch {
         return false;
@@ -1248,18 +2382,6 @@ function createPostgresDriver(url, pool) {
     }
   };
 }
-function coerceValue(value) {
-  if (typeof value === "string" && isTimestampString(value)) {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) {
-      return date;
-    }
-  }
-  return value;
-}
-function isTimestampString(value) {
-  return /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(value);
-}
 
 // src/client/tenant-graph.ts
 function computeTenantGraph(registry) {
@@ -1379,16 +2501,31 @@ function isReadQuery(sqlStr) {
   }
   return upper.startsWith("SELECT");
 }
-function resolveTable(tables, name) {
-  const entry = tables[name];
+function resolveModel(models, name) {
+  const entry = models[name];
   if (!entry) {
     throw new Error(`Table "${name}" is not registered in the database.`);
   }
   return entry;
 }
+var RESERVED_MODEL_NAMES = new Set(["query", "close", "isHealthy", "_internals"]);
 function createDb(options) {
-  const { tables, log } = options;
-  const tenantGraph = computeTenantGraph(tables);
+  const { models, log, dialect } = options;
+  for (const key of Object.keys(models)) {
+    if (RESERVED_MODEL_NAMES.has(key)) {
+      throw new Error(`Model name "${key}" is reserved. Choose a different name for this model. ` + `Reserved names: ${[...RESERVED_MODEL_NAMES].join(", ")}`);
+    }
+  }
+  if (dialect === "sqlite") {
+    if (!options.d1) {
+      throw new Error("SQLite dialect requires a D1 binding");
+    }
+    if (options.url) {
+      throw new Error("SQLite dialect uses D1, not a connection URL");
+    }
+  }
+  const dialectObj = dialect === "sqlite" ? defaultSqliteDialect : defaultPostgresDialect;
+  const tenantGraph = computeTenantGraph(models);
   if (log && tenantGraph.root !== null) {
     const allScoped = new Set([
       ...tenantGraph.root !== null ? [tenantGraph.root] : [],
@@ -1396,28 +2533,51 @@ function createDb(options) {
       ...tenantGraph.indirectlyScoped,
       ...tenantGraph.shared
     ]);
-    for (const [key, entry] of Object.entries(tables)) {
+    for (const [key, entry] of Object.entries(models)) {
       if (!allScoped.has(key)) {
         log(`[vertz/db] Table "${entry.table._name}" has no tenant path and is not marked .shared(). ` + "It will not be automatically scoped to a tenant.");
       }
     }
   }
-  const tablesRegistry = tables;
+  const modelsRegistry = models;
   let driver = null;
+  let sqliteDriver = null;
   let replicaDrivers = [];
   let replicaIndex = 0;
   const queryFn = (() => {
     if (options._queryFn) {
       return options._queryFn;
     }
+    if (dialect === "sqlite" && options.d1) {
+      const tableSchema = buildTableSchema(models);
+      sqliteDriver = createSqliteDriver(options.d1, tableSchema);
+      return async (sqlStr, params) => {
+        if (!sqliteDriver) {
+          throw new Error("SQLite driver not initialized");
+        }
+        const rows = await sqliteDriver.query(sqlStr, params);
+        return { rows, rowCount: rows.length };
+      };
+    }
     if (options.url) {
-      driver = createPostgresDriver(options.url, options.pool);
-      const replicas = options.pool?.replicas;
-      if (replicas && replicas.length > 0) {
-        replicaDrivers = replicas.map((replicaUrl) => createPostgresDriver(replicaUrl, options.pool));
-      }
+      let initialized = false;
+      const initPostgres = async () => {
+        if (initialized)
+          return;
+        const { createPostgresDriver } = await import("./shared/chunk-2gd1fqcw.js");
+        driver = createPostgresDriver(options.url, options.pool);
+        const replicas = options.pool?.replicas;
+        if (replicas && replicas.length > 0) {
+          replicaDrivers = replicas.map((replicaUrl) => createPostgresDriver(replicaUrl, options.pool));
+        }
+        initialized = true;
+      };
       return async (sqlStr, params) => {
+        await initPostgres();
         if (replicaDrivers.length === 0) {
+          if (!driver) {
+            throw new Error("Database driver not initialized");
+          }
           return driver.queryFn(sqlStr, params);
         }
         if (isReadQuery(sqlStr)) {
@@ -1425,127 +2585,260 @@ function createDb(options) {
           replicaIndex = (replicaIndex + 1) % replicaDrivers.length;
           try {
             return await targetReplica.queryFn(sqlStr, params);
-          } catch (err) {
-            console.warn("[vertz/db] replica query failed, falling back to primary:", err.message);
+          } catch (err4) {
+            console.warn("[vertz/db] replica query failed, falling back to primary:", err4.message);
           }
         }
+        if (!driver) {
+          throw new Error("Database driver not initialized");
+        }
         return driver.queryFn(sqlStr, params);
       };
     }
     return async () => {
-      throw new Error("db.query() requires a connected postgres driver. " + "Provide a `url` to connect to PostgreSQL, or `_queryFn` for testing.");
+      throw new Error("db.query() requires a connected database driver. Provide a `url` to connect to PostgreSQL, a `dialect` with D1 binding for SQLite, or `_queryFn` for testing.");
     };
   })();
-  return {
-    _tables: tables,
-    $tenantGraph: tenantGraph,
-    async query(fragment) {
-      return executeQuery(queryFn, fragment.sql, fragment.params);
-    },
-    async close() {
-      if (driver) {
-        await driver.close();
+  function implGet(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await get(queryFn, entry.table, opts, dialectObj);
+        if (result !== null && opts?.include) {
+          const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, modelsRegistry, entry.table);
+          return ok2(rows[0] ?? null);
+        }
+        return ok2(result);
+      } catch (e) {
+        return err3(toReadError(e));
       }
-      await Promise.all(replicaDrivers.map((r) => r.close()));
-    },
-    async isHealthy() {
-      if (driver) {
-        return driver.isHealthy();
+    })();
+  }
+  function implGetRequired(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await get(queryFn, entry.table, opts, dialectObj);
+        if (result === null) {
+          return err3({
+            code: "NotFound",
+            message: `Record not found in table ${name}`,
+            table: name
+          });
+        }
+        if (opts?.include) {
+          const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, modelsRegistry, entry.table);
+          return ok2(rows[0]);
+        }
+        return ok2(result);
+      } catch (e) {
+        return err3(toReadError(e));
       }
-      return true;
-    },
-    async get(name, opts) {
-      const entry = resolveTable(tables, name);
-      const result = await get(queryFn, entry.table, opts);
-      if (result !== null && opts?.include) {
-        const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, tablesRegistry, entry.table);
-        return rows[0] ?? null;
+    })();
+  }
+  function implList(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const results = await list(queryFn, entry.table, opts, dialectObj);
+        if (opts?.include && results.length > 0) {
+          const withRelations = await loadRelations(queryFn, results, entry.relations, opts.include, 0, modelsRegistry, entry.table);
+          return ok2(withRelations);
+        }
+        return ok2(results);
+      } catch (e) {
+        return err3(toReadError(e));
       }
-      return result;
-    },
-    async getOrThrow(name, opts) {
-      const entry = resolveTable(tables, name);
-      const result = await getOrThrow(queryFn, entry.table, opts);
-      if (opts?.include) {
-        const rows = await loadRelations(queryFn, [result], entry.relations, opts.include, 0, tablesRegistry, entry.table);
-        return rows[0];
+    })();
+  }
+  function implListAndCount(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const { data, total } = await listAndCount(queryFn, entry.table, opts, dialectObj);
+        if (opts?.include && data.length > 0) {
+          const withRelations = await loadRelations(queryFn, data, entry.relations, opts.include, 0, modelsRegistry, entry.table);
+          return ok2({ data: withRelations, total });
+        }
+        return ok2({ data, total });
+      } catch (e) {
+        return err3(toReadError(e));
       }
-      return result;
-    },
-    async list(name, opts) {
-      const entry = resolveTable(tables, name);
-      const results = await list(queryFn, entry.table, opts);
-      if (opts?.include && results.length > 0) {
-        return loadRelations(queryFn, results, entry.relations, opts.include, 0, tablesRegistry, entry.table);
+    })();
+  }
+  function implCreate(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await create(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
       }
-      return results;
-    },
-    async listAndCount(name, opts) {
-      const entry = resolveTable(tables, name);
-      const { data, total } = await listAndCount(queryFn, entry.table, opts);
-      if (opts?.include && data.length > 0) {
-        const withRelations = await loadRelations(queryFn, data, entry.relations, opts.include, 0, tablesRegistry, entry.table);
-        return { data: withRelations, total };
-      }
-      return { data, total };
-    },
-    get findOne() {
-      return this.get;
-    },
-    get findOneOrThrow() {
-      return this.getOrThrow;
-    },
-    get findMany() {
-      return this.list;
-    },
-    get findManyAndCount() {
-      return this.listAndCount;
-    },
-    async create(name, opts) {
-      const entry = resolveTable(tables, name);
-      return create(queryFn, entry.table, opts);
-    },
-    async createMany(name, opts) {
-      const entry = resolveTable(tables, name);
-      return createMany(queryFn, entry.table, opts);
-    },
-    async createManyAndReturn(name, opts) {
-      const entry = resolveTable(tables, name);
-      return createManyAndReturn(queryFn, entry.table, opts);
-    },
-    async update(name, opts) {
-      const entry = resolveTable(tables, name);
-      return update(queryFn, entry.table, opts);
-    },
-    async updateMany(name, opts) {
-      const entry = resolveTable(tables, name);
-      return updateMany(queryFn, entry.table, opts);
-    },
-    async upsert(name, opts) {
-      const entry = resolveTable(tables, name);
-      return upsert(queryFn, entry.table, opts);
-    },
-    async delete(name, opts) {
-      const entry = resolveTable(tables, name);
-      return deleteOne(queryFn, entry.table, opts);
-    },
-    async deleteMany(name, opts) {
-      const entry = resolveTable(tables, name);
-      return deleteMany(queryFn, entry.table, opts);
-    },
-    async count(name, opts) {
-      const entry = resolveTable(tables, name);
-      return count(queryFn, entry.table, opts);
-    },
-    async aggregate(name, opts) {
-      const entry = resolveTable(tables, name);
-      return aggregate(queryFn, entry.table, opts);
-    },
-    async groupBy(name, opts) {
-      const entry = resolveTable(tables, name);
-      return groupBy(queryFn, entry.table, opts);
+    })();
+  }
+  function implCreateMany(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await createMany(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implCreateManyAndReturn(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await createManyAndReturn(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implUpdate(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await update(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implUpdateMany(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await updateMany(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implUpsert(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await upsert(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implDelete(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await deleteOne(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implDeleteMany(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await deleteMany(queryFn, entry.table, opts, dialectObj);
+        return ok2(result);
+      } catch (e) {
+        return err3(toWriteError(e));
+      }
+    })();
+  }
+  function implCount(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await count(queryFn, entry.table, opts);
+        return ok2(result);
+      } catch (e) {
+        return err3(toReadError(e));
+      }
+    })();
+  }
+  function implAggregate(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await aggregate(queryFn, entry.table, opts);
+        return ok2(result);
+      } catch (e) {
+        return err3(toReadError(e));
+      }
+    })();
+  }
+  function implGroupBy(name, opts) {
+    return (async () => {
+      try {
+        const entry = resolveModel(models, name);
+        const result = await groupBy(queryFn, entry.table, opts);
+        return ok2(result);
+      } catch (e) {
+        return err3(toReadError(e));
+      }
+    })();
+  }
+  const client = {};
+  for (const name of Object.keys(models)) {
+    client[name] = {
+      get: (opts) => implGet(name, opts),
+      getOrThrow: (opts) => implGetRequired(name, opts),
+      list: (opts) => implList(name, opts),
+      listAndCount: (opts) => implListAndCount(name, opts),
+      create: (opts) => implCreate(name, opts),
+      createMany: (opts) => implCreateMany(name, opts),
+      createManyAndReturn: (opts) => implCreateManyAndReturn(name, opts),
+      update: (opts) => implUpdate(name, opts),
+      updateMany: (opts) => implUpdateMany(name, opts),
+      upsert: (opts) => implUpsert(name, opts),
+      delete: (opts) => implDelete(name, opts),
+      deleteMany: (opts) => implDeleteMany(name, opts),
+      count: (opts) => implCount(name, opts),
+      aggregate: (opts) => implAggregate(name, opts),
+      groupBy: (opts) => implGroupBy(name, opts)
+    };
+  }
+  client.query = async (fragment) => {
+    try {
+      const result = await executeQuery(queryFn, fragment.sql, fragment.params);
+      return ok2(result);
+    } catch (e) {
+      return err3(toReadError(e, fragment.sql));
+    }
+  };
+  client.close = async () => {
+    if (driver) {
+      await driver.close();
+    }
+    if (sqliteDriver) {
+      await sqliteDriver.close();
+    }
+    await Promise.all(replicaDrivers.map((r) => r.close()));
+  };
+  client.isHealthy = async () => {
+    if (driver) {
+      return driver.isHealthy();
     }
+    if (sqliteDriver) {
+      return sqliteDriver.isHealthy();
+    }
+    return true;
+  };
+  client._internals = {
+    models,
+    dialect: dialectObj,
+    tenantGraph
   };
+  return client;
 }
 // src/schema/column.ts
 function cloneWith(source, metaOverrides) {
@@ -1554,8 +2847,12 @@ function cloneWith(source, metaOverrides) {
 function createColumnWithMeta(meta) {
   const col = {
     _meta: meta,
-    primary() {
-      return cloneWith(this, { primary: true, hasDefault: true });
+    primary(options) {
+      const meta2 = { primary: true, hasDefault: true };
+      if (options?.generate) {
+        meta2.generate = options.generate;
+      }
+      return cloneWith(this, meta2);
     },
     unique() {
       return cloneWith(this, { unique: true });
@@ -1566,11 +2863,17 @@ function createColumnWithMeta(meta) {
     default(value) {
       return cloneWith(this, { hasDefault: true, defaultValue: value });
     },
-    sensitive() {
-      return cloneWith(this, { sensitive: true });
+    is(flag) {
+      return createColumnWithMeta({
+        ...this._meta,
+        _annotations: { ...this._meta._annotations, [flag]: true }
+      });
+    },
+    readOnly() {
+      return cloneWith(this, { isReadOnly: true });
     },
-    hidden() {
-      return cloneWith(this, { hidden: true });
+    autoUpdate() {
+      return cloneWith(this, { isAutoUpdate: true, isReadOnly: true });
     },
     check(sql) {
       return cloneWith(this, { check: sql });
@@ -1590,8 +2893,9 @@ function defaultMeta(sqlType) {
     unique: false,
     nullable: false,
     hasDefault: false,
-    sensitive: false,
-    hidden: false,
+    _annotations: {},
+    isReadOnly: false,
+    isAutoUpdate: false,
     isTenant: false,
     references: null,
     check: null
@@ -1610,8 +2914,9 @@ function createSerialColumn() {
     unique: false,
     nullable: false,
     hasDefault: true,
-    sensitive: false,
-    hidden: false,
+    _annotations: {},
+    isReadOnly: false,
+    isAutoUpdate: false,
     isTenant: false,
     references: null,
     check: null
@@ -1624,14 +2929,101 @@ function createTenantColumn(targetTableName) {
     unique: false,
     nullable: false,
     hasDefault: false,
-    sensitive: false,
-    hidden: false,
+    _annotations: {},
+    isReadOnly: false,
+    isAutoUpdate: false,
     isTenant: true,
     references: { table: targetTableName, column: "id" },
     check: null
   });
 }
 
+// src/schema/model-schemas.ts
+function deriveSchemas(table) {
+  const hiddenCols = getColumnNamesWithAnnotation(table, "hidden");
+  const readOnlyCols = getColumnNamesWhere(table, "isReadOnly");
+  const primaryCols = getColumnNamesWhere(table, "primary");
+  const allCols = new Set(Object.keys(table._columns));
+  const defaultCols = getColumnNamesWhere(table, "hasDefault");
+  const responseCols = setDifference(allCols, hiddenCols);
+  const inputCols = setDifference(setDifference(allCols, readOnlyCols), primaryCols);
+  const requiredCols = getRequiredInputColumns(table, inputCols, defaultCols);
+  return {
+    response: {
+      parse(value) {
+        return { ok: true, data: pickKeys(value, responseCols) };
+      }
+    },
+    createInput: {
+      parse(value) {
+        const data = value;
+        const missing = requiredCols.filter((col) => !(col in data) || data[col] === undefined);
+        if (missing.length > 0) {
+          return {
+            ok: false,
+            error: new Error(`Missing required fields: ${missing.join(", ")}`)
+          };
+        }
+        return { ok: true, data: pickKeys(value, inputCols) };
+      }
+    },
+    updateInput: {
+      parse(value) {
+        return { ok: true, data: pickKeys(value, inputCols) };
+      }
+    }
+  };
+}
+function pickKeys(value, allowed) {
+  const data = value;
+  const result = {};
+  for (const [key, val] of Object.entries(data)) {
+    if (allowed.has(key)) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function setDifference(a, b) {
+  const result = new Set;
+  for (const item of a) {
+    if (!b.has(item)) {
+      result.add(item);
+    }
+  }
+  return result;
+}
+function getRequiredInputColumns(_table, allowed, defaults) {
+  return [...allowed].filter((key) => !defaults.has(key));
+}
+function getColumnNamesWhere(table, flag) {
+  const result = new Set;
+  for (const [key, col] of Object.entries(table._columns)) {
+    if (col._meta[flag]) {
+      result.add(key);
+    }
+  }
+  return result;
+}
+function getColumnNamesWithAnnotation(table, annotation) {
+  const result = new Set;
+  for (const [key, col] of Object.entries(table._columns)) {
+    if (col._meta._annotations[annotation]) {
+      result.add(key);
+    }
+  }
+  return result;
+}
+
+// src/schema/model.ts
+function createModel(table, relations) {
+  return {
+    table,
+    relations: relations ?? {},
+    schemas: deriveSchemas(table)
+  };
+}
+
 // src/schema/relation.ts
 function createOneRelation(target, foreignKey) {
   return {
@@ -1663,9 +3055,10 @@ function createManyRelation(target, foreignKey) {
 }
 
 // src/schema/table.ts
-function createIndex(columns) {
+function createIndex(columns, options) {
   return {
-    columns: Array.isArray(columns) ? columns : [columns]
+    columns: Array.isArray(columns) ? columns : [columns],
+    ...options
   };
 }
 function createTable(name, columns, options) {
@@ -1689,10 +3082,13 @@ function createTableInternal(name, columns, indexes, shared) {
     get $update() {
       return;
     },
-    get $not_sensitive() {
+    get $response() {
+      return;
+    },
+    get $create_input() {
       return;
     },
-    get $not_hidden() {
+    get $update_input() {
       return;
     },
     shared() {
@@ -1718,7 +3114,13 @@ var d = {
   timestamp: () => createColumn("timestamp with time zone"),
   date: () => createColumn("date"),
   time: () => createColumn("time"),
-  jsonb: (opts) => createColumn("jsonb", opts?.validator ? { validator: opts.validator } : {}),
+  jsonb: (schemaOrOpts) => {
+    if (schemaOrOpts && "parse" in schemaOrOpts && !("validator" in schemaOrOpts)) {
+      return createColumn("jsonb", { validator: schemaOrOpts });
+    }
+    const opts = schemaOrOpts;
+    return createColumn("jsonb", opts?.validator ? { validator: opts.validator } : {});
+  },
   textArray: () => createColumn("text[]"),
   integerArray: () => createColumn("integer[]"),
   enum: (name, valuesOrSchema) => {
@@ -1738,50 +3140,24 @@ var d = {
   entry: (table, relations = {}) => ({
     table,
     relations
-  })
-};
-// src/errors/error-codes.ts
-var DbErrorCode = {
-  UNIQUE_VIOLATION: "23505",
-  FOREIGN_KEY_VIOLATION: "23503",
-  NOT_NULL_VIOLATION: "23502",
-  CHECK_VIOLATION: "23514",
-  EXCLUSION_VIOLATION: "23P01",
-  SERIALIZATION_FAILURE: "40001",
-  DEADLOCK_DETECTED: "40P01",
-  CONNECTION_EXCEPTION: "08000",
-  CONNECTION_DOES_NOT_EXIST: "08003",
-  CONNECTION_FAILURE: "08006",
-  NOT_FOUND: "NOT_FOUND",
-  CONNECTION_ERROR: "CONNECTION_ERROR",
-  POOL_EXHAUSTED: "POOL_EXHAUSTED"
+  }),
+  model: (table, relations = {}) => createModel(table, relations)
 };
-var PgCodeToName = Object.fromEntries(Object.entries(DbErrorCode).map(([name, pgCode]) => [pgCode, name]));
-function resolveErrorCode(pgCode) {
-  return PgCodeToName[pgCode];
-}
-// src/errors/http-adapter.ts
-function dbErrorToHttpError(error) {
-  const body = error.toJSON();
-  if (error instanceof UniqueConstraintError) {
-    return { status: 409, body };
-  }
-  if (error instanceof NotFoundError) {
-    return { status: 404, body };
-  }
-  if (error instanceof ForeignKeyError) {
-    return { status: 422, body };
-  }
-  if (error instanceof NotNullError) {
-    return { status: 422, body };
-  }
-  if (error instanceof CheckConstraintError) {
-    return { status: 422, body };
+// src/schema/define-annotations.ts
+function defineAnnotations(...annotations) {
+  const result = {};
+  for (const annotation of annotations) {
+    result[annotation] = annotation;
   }
-  if (error instanceof ConnectionError) {
-    return { status: 503, body };
+  return Object.freeze(result);
+}
+// src/schema/enum-registry.ts
+function createEnumRegistry(definitions) {
+  const registry = {};
+  for (const [name, values] of Object.entries(definitions)) {
+    registry[name] = { name, values };
   }
-  return { status: 500, body };
+  return registry;
 }
 // src/schema/registry.ts
 function createRegistry(tables, relationsCallback) {
@@ -1809,195 +3185,39 @@ function createRegistry(tables, relationsCallback) {
   }
   return result;
 }
-// src/schema/enum-registry.ts
-function createEnumRegistry(definitions) {
-  const registry = {};
-  for (const [name, values] of Object.entries(definitions)) {
-    registry[name] = { name, values };
-  }
-  return registry;
-}
-// src/codegen/type-gen.ts
-function fieldTypeToTs(field) {
-  switch (field.type) {
-    case "string":
-    case "uuid":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "date":
-      return "Date";
-    case "json":
-      return "unknown";
-    case "enum":
-      return field.enumName || "string";
-    default:
-      return "unknown";
-  }
-}
-function generateTypes(domain) {
-  const { name, fields, relations } = domain;
-  const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
-  const lines = [];
-  for (const field of Object.values(fields)) {
-    if (field.type === "enum" && field.enumName && field.enumValues) {
-      lines.push(`enum ${field.enumName} {`);
-      for (const value of field.enumValues) {
-        lines.push(`  ${value.toUpperCase()} = '${value}',`);
-      }
-      lines.push("}");
-      lines.push("");
-    }
-  }
-  lines.push(`interface ${pascalName} {`);
-  for (const [fieldName, field] of Object.entries(fields)) {
-    const tsType = fieldTypeToTs(field);
-    const optional = field.required === false ? "?" : "";
-    lines.push(`  ${fieldName}${optional}: ${tsType};`);
-  }
-  if (relations) {
-    for (const [relName, rel] of Object.entries(relations)) {
-      if (rel.type === "belongsTo") {
-        const targetPascal = rel.target.charAt(0).toUpperCase() + rel.target.slice(1);
-        lines.push(`  ${relName}: () => Promise<${targetPascal} | null>;`);
-      } else if (rel.type === "hasMany") {
-        const targetPascal = rel.target.charAt(0).toUpperCase() + rel.target.slice(1);
-        lines.push(`  ${relName}: () => Promise<${targetPascal}[]>;`);
-      }
-    }
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface Create${pascalName}Input {`);
-  for (const [fieldName, field] of Object.entries(fields)) {
-    if (field.primary)
-      continue;
-    const tsType = fieldTypeToTs(field);
-    if (field.required !== false) {
-      lines.push(`  ${fieldName}: ${tsType};`);
-    }
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface Update${pascalName}Input {`);
-  for (const [fieldName, field] of Object.entries(fields)) {
-    if (field.primary)
-      continue;
-    const tsType = fieldTypeToTs(field);
-    lines.push(`  ${fieldName}?: ${tsType};`);
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface ${pascalName}Where {`);
-  for (const [fieldName, field] of Object.entries(fields)) {
-    const tsType = fieldTypeToTs(field);
-    lines.push(`  ${fieldName}?: ${tsType};`);
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface ${pascalName}OrderBy {`);
-  for (const fieldName of Object.keys(fields)) {
-    lines.push(`  ${fieldName}?: 'asc' | 'desc';`);
-  }
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface List${pascalName}Params {`);
-  lines.push(`  where?: ${pascalName}Where;`);
-  lines.push(`  orderBy?: ${pascalName}OrderBy;`);
-  lines.push(`  limit?: number;`);
-  lines.push(`  offset?: number;`);
-  lines.push("}");
-  lines.push("");
-  lines.push(`interface ${pascalName}Client {`);
-  lines.push(`  list(): Promise<${pascalName}[]>;`);
-  lines.push(`  list(params?: List${pascalName}Params): Promise<${pascalName}[]>;`);
-  let idField = "id";
-  for (const [fieldName, field] of Object.entries(fields)) {
-    if (field.primary) {
-      idField = fieldName;
-      break;
-    }
-  }
-  lines.push(`  get(${idField}: string): Promise<${pascalName} | null>;`);
-  lines.push(`  create(data: Create${pascalName}Input): Promise<${pascalName}>;`);
-  lines.push(`  update(${idField}: string, data: Update${pascalName}Input): Promise<${pascalName}>;`);
-  lines.push(`  delete(${idField}: string): Promise<void>;`);
-  lines.push("}");
-  return lines.join(`
-`);
-}
-// src/codegen/client-gen.ts
-function generateClient(domains) {
-  const lines = [];
-  for (const domain of domains) {
-    const types = generateTypes(domain);
-    lines.push(types);
-    lines.push("");
-  }
-  lines.push("export const db = {");
-  for (const domain of domains) {
-    const { name, fields, relations } = domain;
-    const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
-    let idField = "id";
-    for (const [fieldName, field] of Object.entries(fields)) {
-      if (field.primary) {
-        idField = fieldName;
-        break;
-      }
-    }
-    lines.push(`  ${name}: {`);
-    lines.push(`    list: (params?: List${pascalName}Params) => Promise<${pascalName}[]>,`);
-    lines.push(`    get: (${idField}: string) => Promise<${pascalName} | null>,`);
-    lines.push(`    create: (data: Create${pascalName}Input) => Promise<${pascalName}>,`);
-    lines.push(`    update: (${idField}: string, data: Update${pascalName}Input) => Promise<${pascalName}>,`);
-    lines.push(`    delete: (${idField}: string) => Promise<void>,`);
-    if (relations) {
-      for (const [relName, rel] of Object.entries(relations)) {
-        if (rel.type === "belongsTo") {
-          const targetPascal = rel.target.charAt(0).toUpperCase() + rel.target.slice(1);
-          const relParamName = `${name}Id`;
-          lines.push(`    ${relName}: {`);
-          lines.push(`      get(${relParamName}: string): Promise<${targetPascal} | null>,`);
-          lines.push(`    },`);
-        }
-      }
-    }
-    lines.push(`  },`);
-  }
-  lines.push("} as const;");
-  return lines.join(`
-`);
-}
-// src/domain.ts
-function defineDomain(name, config) {
-  return {
-    name,
-    fields: config.fields,
-    relations: config.relations
-  };
-}
 export {
+  toWriteError,
+  toReadError,
   resolveErrorCode,
+  reset,
   push,
   parsePgError,
+  parseMigrationName,
   migrateStatus,
   migrateDev,
   migrateDeploy,
-  generateTypes,
-  generateClient,
+  generateId,
   formatDiagnostic,
   explainError,
   diagnoseError,
-  defineDomain,
+  detectSchemaDrift,
+  defineAnnotations,
+  defaultSqliteDialect,
+  defaultPostgresDialect,
   dbErrorToHttpError,
   d,
+  createSnapshot,
   createRegistry,
   createEnumRegistry,
   createDb,
+  createDatabaseBridgeAdapter,
+  createD1Driver,
+  createD1Adapter,
   computeTenantGraph,
+  baseline,
   UniqueConstraintError,
+  SqliteDialect,
+  PostgresDialect,
   PgCodeToName,
   NotNullError,
   NotFoundError,