sqlite-zod-orm 3.7.3 → 3.9.0

package/dist/index.js

@@ -72,601 +72,6 @@ var op = {
   not: (node) => ({ type: "operator", op: "NOT", left: { type: "literal", value: "" }, right: wrapNode(node) })
 };
 
-// src/query-builder.ts
-var OPERATOR_MAP = {
-  $gt: ">",
-  $gte: ">=",
-  $lt: "<",
-  $lte: "<=",
-  $ne: "!=",
-  $in: "IN"
-};
-function transformValueForStorage(value) {
-  if (value instanceof Date)
-    return value.toISOString();
-  if (typeof value === "boolean")
-    return value ? 1 : 0;
-  return value;
-}
-function compileIQO(tableName, iqo) {
-  const params = [];
-  const selectParts = [];
-  if (iqo.selects.length > 0) {
-    selectParts.push(...iqo.selects.map((s) => `${tableName}.${s}`));
-  } else {
-    selectParts.push(`${tableName}.*`);
-  }
-  for (const j of iqo.joins) {
-    if (j.columns.length > 0) {
-      selectParts.push(...j.columns.map((c) => `${j.table}.${c} AS ${j.table}_${c}`));
-    } else {
-      selectParts.push(`${j.table}.*`);
-    }
-  }
-  let sql = `SELECT ${selectParts.join(", ")} FROM ${tableName}`;
-  for (const j of iqo.joins) {
-    sql += ` JOIN ${j.table} ON ${tableName}.${j.fromCol} = ${j.table}.${j.toCol}`;
-  }
-  if (iqo.whereAST) {
-    const compiled = compileAST(iqo.whereAST);
-    sql += ` WHERE ${compiled.sql}`;
-    params.push(...compiled.params);
-  } else if (iqo.wheres.length > 0) {
-    const hasJoins = iqo.joins.length > 0;
-    const qualify = (field) => hasJoins && !field.includes(".") ? `${tableName}.${field}` : field;
-    const whereParts = [];
-    for (const w of iqo.wheres) {
-      if (w.operator === "IN") {
-        const arr = w.value;
-        if (arr.length === 0) {
-          whereParts.push("1 = 0");
-        } else {
-          const placeholders = arr.map(() => "?").join(", ");
-          whereParts.push(`${qualify(w.field)} IN (${placeholders})`);
-          params.push(...arr.map(transformValueForStorage));
-        }
-      } else {
-        whereParts.push(`${qualify(w.field)} ${w.operator} ?`);
-        params.push(transformValueForStorage(w.value));
-      }
-    }
-    sql += ` WHERE ${whereParts.join(" AND ")}`;
-  }
-  if (iqo.whereOrs.length > 0) {
-    for (const orGroup of iqo.whereOrs) {
-      const orParts = [];
-      for (const w of orGroup) {
-        if (w.operator === "IN") {
-          const arr = w.value;
-          if (arr.length === 0) {
-            orParts.push("1 = 0");
-          } else {
-            orParts.push(`${w.field} IN (${arr.map(() => "?").join(", ")})`);
-            params.push(...arr.map(transformValueForStorage));
-          }
-        } else {
-          orParts.push(`${w.field} ${w.operator} ?`);
-          params.push(transformValueForStorage(w.value));
-        }
-      }
-      if (orParts.length > 0) {
-        const orClause = `(${orParts.join(" OR ")})`;
-        sql += sql.includes(" WHERE ") ? ` AND ${orClause}` : ` WHERE ${orClause}`;
-      }
-    }
-  }
-  if (iqo.orderBy.length > 0) {
-    const parts = iqo.orderBy.map((o) => `${o.field} ${o.direction.toUpperCase()}`);
-    sql += ` ORDER BY ${parts.join(", ")}`;
-  }
-  if (iqo.limit !== null) {
-    sql += ` LIMIT ${iqo.limit}`;
-  }
-  if (iqo.offset !== null) {
-    sql += ` OFFSET ${iqo.offset}`;
-  }
-  return { sql, params };
-}
-
-class QueryBuilder {
-  iqo;
-  tableName;
-  executor;
-  singleExecutor;
-  joinResolver;
-  conditionResolver;
-  revisionGetter;
-  eagerLoader;
-  defaultPollInterval;
-  constructor(tableName, executor, singleExecutor, joinResolver, conditionResolver, revisionGetter, eagerLoader, pollInterval) {
-    this.tableName = tableName;
-    this.executor = executor;
-    this.singleExecutor = singleExecutor;
-    this.joinResolver = joinResolver ?? null;
-    this.conditionResolver = conditionResolver ?? null;
-    this.revisionGetter = revisionGetter ?? null;
-    this.eagerLoader = eagerLoader ?? null;
-    this.defaultPollInterval = pollInterval ?? 500;
-    this.iqo = {
-      selects: [],
-      wheres: [],
-      whereOrs: [],
-      whereAST: null,
-      joins: [],
-      limit: null,
-      offset: null,
-      orderBy: [],
-      includes: [],
-      raw: false
-    };
-  }
-  select(...cols) {
-    this.iqo.selects.push(...cols);
-    return this;
-  }
-  where(criteriaOrCallback) {
-    if (typeof criteriaOrCallback === "function") {
-      const ast = criteriaOrCallback(createColumnProxy(), createFunctionProxy(), op);
-      if (this.iqo.whereAST) {
-        this.iqo.whereAST = { type: "operator", op: "AND", left: this.iqo.whereAST, right: ast };
-      } else {
-        this.iqo.whereAST = ast;
-      }
-    } else {
-      const resolved = this.conditionResolver ? this.conditionResolver(criteriaOrCallback) : criteriaOrCallback;
-      for (const [key, value] of Object.entries(resolved)) {
-        if (key === "$or" && Array.isArray(value)) {
-          const orConditions = [];
-          for (const branch of value) {
-            const resolvedBranch = this.conditionResolver ? this.conditionResolver(branch) : branch;
-            for (const [bKey, bValue] of Object.entries(resolvedBranch)) {
-              if (typeof bValue === "object" && bValue !== null && !Array.isArray(bValue) && !(bValue instanceof Date)) {
-                for (const [opKey, operand] of Object.entries(bValue)) {
-                  const sqlOp = OPERATOR_MAP[opKey];
-                  if (sqlOp)
-                    orConditions.push({ field: bKey, operator: sqlOp, value: operand });
-                }
-              } else {
-                orConditions.push({ field: bKey, operator: "=", value: bValue });
-              }
-            }
-          }
-          if (orConditions.length > 0)
-            this.iqo.whereOrs.push(orConditions);
-          continue;
-        }
-        if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
-          for (const [opKey, operand] of Object.entries(value)) {
-            const sqlOp = OPERATOR_MAP[opKey];
-            if (!sqlOp)
-              throw new Error(`Unsupported query operator: '${opKey}' on field '${key}'.`);
-            this.iqo.wheres.push({
-              field: key,
-              operator: sqlOp,
-              value: operand
-            });
-          }
-        } else {
-          this.iqo.wheres.push({ field: key, operator: "=", value });
-        }
-      }
-    }
-    return this;
-  }
-  limit(n) {
-    this.iqo.limit = n;
-    return this;
-  }
-  offset(n) {
-    this.iqo.offset = n;
-    return this;
-  }
-  orderBy(field, direction = "asc") {
-    this.iqo.orderBy.push({ field, direction });
-    return this;
-  }
-  join(tableOrAccessor, fkOrCols, colsOrPk, pk) {
-    let table;
-    let fromCol;
-    let toCol;
-    let columns;
-    if (typeof tableOrAccessor === "object" && "_tableName" in tableOrAccessor) {
-      table = tableOrAccessor._tableName;
-      columns = Array.isArray(fkOrCols) ? fkOrCols : [];
-      if (!this.joinResolver)
-        throw new Error(`Cannot auto-resolve join: no relationship data available`);
-      const resolved = this.joinResolver(this.tableName, table);
-      if (!resolved)
-        throw new Error(`No relationship found between '${this.tableName}' and '${table}'`);
-      fromCol = resolved.fk;
-      toCol = resolved.pk;
-    } else {
-      table = tableOrAccessor;
-      fromCol = fkOrCols;
-      columns = Array.isArray(colsOrPk) ? colsOrPk : [];
-      toCol = (typeof colsOrPk === "string" ? colsOrPk : pk) ?? "id";
-    }
-    this.iqo.joins.push({ table, fromCol, toCol, columns });
-    this.iqo.raw = true;
-    return this;
-  }
-  raw() {
-    this.iqo.raw = true;
-    return this;
-  }
-  with(...relations) {
-    this.iqo.includes.push(...relations);
-    return this;
-  }
-  _applyEagerLoads(results) {
-    if (this.iqo.includes.length === 0 || !this.eagerLoader || results.length === 0) {
-      return results;
-    }
-    const parentIds = results.map((r) => r.id).filter((id) => typeof id === "number");
-    if (parentIds.length === 0)
-      return results;
-    for (const relation of this.iqo.includes) {
-      const loaded = this.eagerLoader(this.tableName, relation, parentIds);
-      if (!loaded)
-        continue;
-      for (const row of results) {
-        row[loaded.key] = loaded.groups.get(row.id) ?? [];
-      }
-    }
-    return results;
-  }
-  all() {
-    const { sql, params } = compileIQO(this.tableName, this.iqo);
-    const results = this.executor(sql, params, this.iqo.raw);
-    return this._applyEagerLoads(results);
-  }
-  get() {
-    this.iqo.limit = 1;
-    const { sql, params } = compileIQO(this.tableName, this.iqo);
-    const result = this.singleExecutor(sql, params, this.iqo.raw);
-    if (!result)
-      return null;
-    const [loaded] = this._applyEagerLoads([result]);
-    return loaded ?? null;
-  }
-  count() {
-    const params = [];
-    let sql = `SELECT COUNT(*) as count FROM ${this.tableName}`;
-    if (this.iqo.whereAST) {
-      const compiled = compileAST(this.iqo.whereAST);
-      sql += ` WHERE ${compiled.sql}`;
-      params.push(...compiled.params);
-    } else if (this.iqo.wheres.length > 0) {
-      const whereParts = [];
-      for (const w of this.iqo.wheres) {
-        if (w.operator === "IN") {
-          const arr = w.value;
-          if (arr.length === 0) {
-            whereParts.push("1 = 0");
-          } else {
-            const placeholders = arr.map(() => "?").join(", ");
-            whereParts.push(`${w.field} IN (${placeholders})`);
-            params.push(...arr.map(transformValueForStorage));
-          }
-        } else {
-          whereParts.push(`${w.field} ${w.operator} ?`);
-          params.push(transformValueForStorage(w.value));
-        }
-      }
-      sql += ` WHERE ${whereParts.join(" AND ")}`;
-    }
-    const results = this.executor(sql, params, true);
-    return results[0]?.count ?? 0;
-  }
-  subscribe(callback, options = {}) {
-    const { interval = this.defaultPollInterval, immediate = true } = options;
-    const fingerprintSQL = this.buildFingerprintSQL();
-    let lastCount = null;
-    let lastMax = null;
-    let lastInMemoryRev = null;
-    let stopped = false;
-    const poll = async () => {
-      if (stopped)
-        return;
-      try {
-        const rev = this.revisionGetter?.() ?? "0";
-        const inMemoryChanged = rev !== lastInMemoryRev;
-        lastInMemoryRev = rev;
-        const fpRows = this.executor(fingerprintSQL.sql, fingerprintSQL.params, true);
-        const fpRow = fpRows[0];
-        const cnt = fpRow?._cnt ?? 0;
-        const max = fpRow?._max ?? 0;
-        const fpChanged = cnt !== lastCount || max !== lastMax;
-        lastCount = cnt;
-        lastMax = max;
-        if (inMemoryChanged || fpChanged) {
-          const rows = this.all();
-          await callback(rows);
-        }
-      } catch {}
-      if (!stopped)
-        setTimeout(poll, interval);
-    };
-    if (immediate) {
-      poll();
-    } else {
-      setTimeout(poll, interval);
-    }
-    return () => {
-      stopped = true;
-    };
-  }
-  each(callback, options = {}) {
-    const { interval = this.defaultPollInterval } = options;
-    const userWhere = this.buildWhereClause();
-    const maxRows = this.executor(`SELECT MAX(id) as _max FROM ${this.tableName} ${userWhere.sql ? `WHERE ${userWhere.sql}` : ""}`, userWhere.params, true);
-    let lastMaxId = maxRows[0]?._max ?? 0;
-    let lastRevision = this.revisionGetter?.() ?? "0";
-    let stopped = false;
-    const poll = async () => {
-      if (stopped)
-        return;
-      const rev = this.revisionGetter?.() ?? "0";
-      if (rev !== lastRevision) {
-        lastRevision = rev;
-        const params = [...userWhere.params, lastMaxId];
-        const whereClause = userWhere.sql ? `WHERE ${userWhere.sql} AND id > ? ORDER BY id ASC` : `WHERE id > ? ORDER BY id ASC`;
-        const sql = `SELECT * FROM ${this.tableName} ${whereClause}`;
-        const newRows = this.executor(sql, params, false);
-        for (const row of newRows) {
-          if (stopped)
-            return;
-          await callback(row);
-          lastMaxId = row.id;
-        }
-      }
-      if (!stopped)
-        setTimeout(poll, interval);
-    };
-    setTimeout(poll, interval);
-    return () => {
-      stopped = true;
-    };
-  }
-  buildWhereClause() {
-    const params = [];
-    if (this.iqo.whereAST) {
-      const compiled = compileAST(this.iqo.whereAST);
-      return { sql: compiled.sql, params: compiled.params };
-    }
-    if (this.iqo.wheres.length > 0) {
-      const whereParts = [];
-      for (const w of this.iqo.wheres) {
-        if (w.operator === "IN") {
-          const arr = w.value;
-          if (arr.length === 0) {
-            whereParts.push("1 = 0");
-          } else {
-            const placeholders = arr.map(() => "?").join(", ");
-            whereParts.push(`${w.field} IN (${placeholders})`);
-            params.push(...arr.map(transformValueForStorage));
-          }
-        } else {
-          whereParts.push(`${w.field} ${w.operator} ?`);
-          params.push(transformValueForStorage(w.value));
-        }
-      }
-      return { sql: whereParts.join(" AND "), params };
-    }
-    return { sql: "", params: [] };
-  }
-  buildFingerprintSQL() {
-    const where = this.buildWhereClause();
-    const sql = `SELECT COUNT(*) as _cnt, MAX(id) as _max FROM ${this.tableName}${where.sql ? ` WHERE ${where.sql}` : ""}`;
-    return { sql, params: where.params };
-  }
-  then(onfulfilled, onrejected) {
-    try {
-      const result = this.all();
-      return Promise.resolve(result).then(onfulfilled, onrejected);
-    } catch (err) {
-      return Promise.reject(err).then(onfulfilled, onrejected);
-    }
-  }
-}
-
-// src/proxy-query.ts
-class ColumnNode {
-  table;
-  column;
-  alias;
-  _type = "COL";
-  constructor(table, column, alias) {
-    this.table = table;
-    this.column = column;
-    this.alias = alias;
-  }
-  toString() {
-    return `"${this.alias}"."${this.column}"`;
-  }
-  [Symbol.toPrimitive]() {
-    return this.toString();
-  }
-}
-function q(name) {
-  return `"${name}"`;
-}
-function qRef(alias, column) {
-  return `"${alias}"."${column}"`;
-}
-function createTableProxy(tableName, alias, columns) {
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
-        return;
-      }
-      return new ColumnNode(tableName, prop, alias);
-    },
-    ownKeys() {
-      return [...columns];
-    },
-    getOwnPropertyDescriptor(_target, prop) {
-      if (columns.has(prop)) {
-        return { configurable: true, enumerable: true, value: new ColumnNode(tableName, prop, alias) };
-      }
-      return;
-    }
-  });
-}
-function createContextProxy(schemas) {
-  const aliases = new Map;
-  let aliasCounter = 0;
-  const proxy = new Proxy({}, {
-    get(_target, tableName) {
-      if (typeof tableName !== "string")
-        return;
-      const schema = schemas[tableName];
-      const shape = schema ? schema.shape : {};
-      const columns = new Set(Object.keys(shape));
-      aliasCounter++;
-      const alias = `t${aliasCounter}`;
-      const tableProxy = createTableProxy(tableName, alias, columns);
-      const entries = aliases.get(tableName) || [];
-      entries.push({ tableName, alias, proxy: tableProxy });
-      aliases.set(tableName, entries);
-      return tableProxy;
-    }
-  });
-  return { proxy, aliasMap: aliases };
-}
-function isColumnNode(val) {
-  return val && typeof val === "object" && val._type === "COL";
-}
-function compileProxyQuery(queryResult, aliasMap) {
-  const params = [];
-  const tablesUsed = new Map;
-  for (const [tableName, entries] of aliasMap) {
-    for (const entry of entries) {
-      tablesUsed.set(entry.alias, { tableName, alias: entry.alias });
-    }
-  }
-  const selectParts = [];
-  for (const [outputName, colOrValue] of Object.entries(queryResult.select)) {
-    if (isColumnNode(colOrValue)) {
-      if (outputName === colOrValue.column) {
-        selectParts.push(qRef(colOrValue.alias, colOrValue.column));
-      } else {
-        selectParts.push(`${qRef(colOrValue.alias, colOrValue.column)} AS ${q(outputName)}`);
-      }
-    } else {
-      selectParts.push(`? AS ${q(outputName)}`);
-      params.push(colOrValue);
-    }
-  }
-  const allAliases = [...tablesUsed.values()];
-  if (allAliases.length === 0)
-    throw new Error("No tables referenced in query.");
-  const primaryAlias = allAliases[0];
-  let sql = `SELECT ${selectParts.join(", ")} FROM ${q(primaryAlias.tableName)} ${q(primaryAlias.alias)}`;
-  if (queryResult.join) {
-    const joins = Array.isArray(queryResult.join[0]) ? queryResult.join : [queryResult.join];
-    for (const [left, right] of joins) {
-      const leftTable = tablesUsed.get(left.alias);
-      const rightTable = tablesUsed.get(right.alias);
-      if (!leftTable || !rightTable)
-        throw new Error("Join references unknown table alias.");
-      const joinAlias = leftTable.alias === primaryAlias.alias ? rightTable : leftTable;
-      sql += ` JOIN ${q(joinAlias.tableName)} ${q(joinAlias.alias)} ON ${qRef(left.alias, left.column)} = ${qRef(right.alias, right.column)}`;
-    }
-  }
-  if (queryResult.where && Object.keys(queryResult.where).length > 0) {
-    const whereParts = [];
-    for (const [key, value] of Object.entries(queryResult.where)) {
-      let fieldRef;
-      const quotedMatch = key.match(/^"([^"]+)"\."([^"]+)"$/);
-      if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
-        fieldRef = key;
-      } else {
-        fieldRef = qRef(primaryAlias.alias, key);
-      }
-      if (isColumnNode(value)) {
-        whereParts.push(`${fieldRef} = ${qRef(value.alias, value.column)}`);
-      } else if (Array.isArray(value)) {
-        if (value.length === 0) {
-          whereParts.push("1 = 0");
-        } else {
-          const placeholders = value.map(() => "?").join(", ");
-          whereParts.push(`${fieldRef} IN (${placeholders})`);
-          params.push(...value);
-        }
-      } else if (typeof value === "object" && value !== null && !(value instanceof Date)) {
-        for (const [op2, operand] of Object.entries(value)) {
-          if (op2 === "$in") {
-            const arr = operand;
-            if (arr.length === 0) {
-              whereParts.push("1 = 0");
-            } else {
-              const placeholders = arr.map(() => "?").join(", ");
-              whereParts.push(`${fieldRef} IN (${placeholders})`);
-              params.push(...arr);
-            }
-            continue;
-          }
-          const opMap = {
-            $gt: ">",
-            $gte: ">=",
-            $lt: "<",
-            $lte: "<=",
-            $ne: "!="
-          };
-          const sqlOp = opMap[op2];
-          if (!sqlOp)
-            throw new Error(`Unsupported where operator: ${op2}`);
-          whereParts.push(`${fieldRef} ${sqlOp} ?`);
-          params.push(operand);
-        }
-      } else {
-        whereParts.push(`${fieldRef} = ?`);
-        params.push(value instanceof Date ? value.toISOString() : value);
-      }
-    }
-    if (whereParts.length > 0) {
-      sql += ` WHERE ${whereParts.join(" AND ")}`;
-    }
-  }
-  if (queryResult.orderBy) {
-    const parts = [];
-    for (const [key, dir] of Object.entries(queryResult.orderBy)) {
-      let fieldRef;
-      const quotedMatch = key.match(/^"([^"]+)"\."([^"]+)"$/);
-      if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
-        fieldRef = key;
-      } else {
-        fieldRef = qRef(primaryAlias.alias, key);
-      }
-      parts.push(`${fieldRef} ${dir.toUpperCase()}`);
-    }
-    if (parts.length > 0) {
-      sql += ` ORDER BY ${parts.join(", ")}`;
-    }
-  }
-  if (queryResult.groupBy && queryResult.groupBy.length > 0) {
-    const parts = queryResult.groupBy.filter(Boolean).map((col) => qRef(col.alias, col.column));
-    sql += ` GROUP BY ${parts.join(", ")}`;
-  }
-  if (queryResult.limit !== undefined) {
-    sql += ` LIMIT ${queryResult.limit}`;
-  }
-  if (queryResult.offset !== undefined) {
-    sql += ` OFFSET ${queryResult.offset}`;
-  }
-  return { sql, params };
-}
-function executeProxyQuery(schemas, callback, executor) {
-  const { proxy, aliasMap } = createContextProxy(schemas);
-  const queryResult = callback(proxy);
-  const { sql, params } = compileProxyQuery(queryResult, aliasMap);
-  return executor(sql, params);
-}
-
-// src/types.ts
-var asZodObject = (s) => s;
-
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -3557,1212 +2962,2014 @@ class ZodIntersection extends ZodType {
         })
       ]).then(([left, right]) => handleParsed(left, right));
     } else {
-      return handleParsed(this._def.left._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      }), this._def.right._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      }));
+      return handleParsed(this._def.left._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      }), this._def.right._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      }));
+    }
+  }
+}
+ZodIntersection.create = (left, right, params) => {
+  return new ZodIntersection({
+    left,
+    right,
+    typeName: ZodFirstPartyTypeKind.ZodIntersection,
+    ...processCreateParams(params)
+  });
+};
+
+class ZodTuple extends ZodType {
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.array) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.array,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    if (ctx.data.length < this._def.items.length) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.too_small,
+        minimum: this._def.items.length,
+        inclusive: true,
+        exact: false,
+        type: "array"
+      });
+      return INVALID;
+    }
+    const rest = this._def.rest;
+    if (!rest && ctx.data.length > this._def.items.length) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.too_big,
+        maximum: this._def.items.length,
+        inclusive: true,
+        exact: false,
+        type: "array"
+      });
+      status.dirty();
+    }
+    const items = [...ctx.data].map((item, itemIndex) => {
+      const schema = this._def.items[itemIndex] || this._def.rest;
+      if (!schema)
+        return null;
+      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
+    }).filter((x) => !!x);
+    if (ctx.common.async) {
+      return Promise.all(items).then((results) => {
+        return ParseStatus.mergeArray(status, results);
+      });
+    } else {
+      return ParseStatus.mergeArray(status, items);
+    }
+  }
+  get items() {
+    return this._def.items;
+  }
+  rest(rest) {
+    return new ZodTuple({
+      ...this._def,
+      rest
+    });
+  }
+}
+ZodTuple.create = (schemas, params) => {
+  if (!Array.isArray(schemas)) {
+    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  }
+  return new ZodTuple({
+    items: schemas,
+    typeName: ZodFirstPartyTypeKind.ZodTuple,
+    rest: null,
+    ...processCreateParams(params)
+  });
+};
+
+class ZodRecord extends ZodType {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.object) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.object,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const pairs = [];
+    const keyType = this._def.keyType;
+    const valueType = this._def.valueType;
+    for (const key in ctx.data) {
+      pairs.push({
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
+        alwaysSet: key in ctx.data
+      });
+    }
+    if (ctx.common.async) {
+      return ParseStatus.mergeObjectAsync(status, pairs);
+    } else {
+      return ParseStatus.mergeObjectSync(status, pairs);
+    }
+  }
+  get element() {
+    return this._def.valueType;
+  }
+  static create(first, second, third) {
+    if (second instanceof ZodType) {
+      return new ZodRecord({
+        keyType: first,
+        valueType: second,
+        typeName: ZodFirstPartyTypeKind.ZodRecord,
+        ...processCreateParams(third)
+      });
+    }
+    return new ZodRecord({
+      keyType: ZodString.create(),
+      valueType: first,
+      typeName: ZodFirstPartyTypeKind.ZodRecord,
+      ...processCreateParams(second)
+    });
+  }
+}
+
+class ZodMap extends ZodType {
+  get keySchema() {
+    return this._def.keyType;
+  }
+  get valueSchema() {
+    return this._def.valueType;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.map) {
+      addIssueToContext(ctx, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.map,
+        received: ctx.parsedType
+      });
+      return INVALID;
+    }
+    const keyType = this._def.keyType;
+    const valueType = this._def.valueType;
+    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+      return {
+        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
+      };
+    });
+    if (ctx.common.async) {
+      const finalMap = new Map;
+      return Promise.resolve().then(async () => {
+        for (const pair of pairs) {
+          const key = await pair.key;
+          const value = await pair.value;
+          if (key.status === "aborted" || value.status === "aborted") {
+            return INVALID;
+          }
+          if (key.status === "dirty" || value.status === "dirty") {
+            status.dirty();
+          }
+          finalMap.set(key.value, value.value);
+        }
+        return { status: status.value, value: finalMap };
+      });
+    } else {
+      const finalMap = new Map;
+      for (const pair of pairs) {
+        const key = pair.key;
+        const value = pair.value;
+        if (key.status === "aborted" || value.status === "aborted") {
+          return INVALID;
+        }
+        if (key.status === "dirty" || value.status === "dirty") {
+          status.dirty();
+        }
+        finalMap.set(key.value, value.value);
+      }
+      return { status: status.value, value: finalMap };
     }
   }
 }
-ZodIntersection.create = (left, right, params) => {
-  return new ZodIntersection({
-    left,
-    right,
-    typeName: ZodFirstPartyTypeKind.ZodIntersection,
+ZodMap.create = (keyType, valueType, params) => {
+  return new ZodMap({
+    valueType,
+    keyType,
+    typeName: ZodFirstPartyTypeKind.ZodMap,
     ...processCreateParams(params)
   });
 };
 
-class ZodTuple extends ZodType {
+class ZodSet extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.array) {
+    if (ctx.parsedType !== ZodParsedType.set) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.array,
+        expected: ZodParsedType.set,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    if (ctx.data.length < this._def.items.length) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.too_small,
-        minimum: this._def.items.length,
-        inclusive: true,
-        exact: false,
-        type: "array"
-      });
-      return INVALID;
+    const def = this._def;
+    if (def.minSize !== null) {
+      if (ctx.data.size < def.minSize.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_small,
+          minimum: def.minSize.value,
+          type: "set",
+          inclusive: true,
+          exact: false,
+          message: def.minSize.message
+        });
+        status.dirty();
+      }
     }
-    const rest = this._def.rest;
-    if (!rest && ctx.data.length > this._def.items.length) {
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.too_big,
-        maximum: this._def.items.length,
-        inclusive: true,
-        exact: false,
-        type: "array"
-      });
-      status.dirty();
+    if (def.maxSize !== null) {
+      if (ctx.data.size > def.maxSize.value) {
+        addIssueToContext(ctx, {
+          code: ZodIssueCode.too_big,
+          maximum: def.maxSize.value,
+          type: "set",
+          inclusive: true,
+          exact: false,
+          message: def.maxSize.message
+        });
+        status.dirty();
+      }
     }
-    const items = [...ctx.data].map((item, itemIndex) => {
-      const schema = this._def.items[itemIndex] || this._def.rest;
-      if (!schema)
-        return null;
-      return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
-    }).filter((x) => !!x);
+    const valueType = this._def.valueType;
+    function finalizeSet(elements2) {
+      const parsedSet = new Set;
+      for (const element of elements2) {
+        if (element.status === "aborted")
+          return INVALID;
+        if (element.status === "dirty")
+          status.dirty();
+        parsedSet.add(element.value);
+      }
+      return { status: status.value, value: parsedSet };
+    }
+    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
     if (ctx.common.async) {
-      return Promise.all(items).then((results) => {
-        return ParseStatus.mergeArray(status, results);
-      });
+      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
     } else {
-      return ParseStatus.mergeArray(status, items);
+      return finalizeSet(elements);
     }
   }
-  get items() {
-    return this._def.items;
+  min(minSize, message) {
+    return new ZodSet({
+      ...this._def,
+      minSize: { value: minSize, message: errorUtil.toString(message) }
+    });
   }
-  rest(rest) {
-    return new ZodTuple({
+  max(maxSize, message) {
+    return new ZodSet({
       ...this._def,
-      rest
+      maxSize: { value: maxSize, message: errorUtil.toString(message) }
     });
   }
-}
-ZodTuple.create = (schemas, params) => {
-  if (!Array.isArray(schemas)) {
-    throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+  size(size, message) {
+    return this.min(size, message).max(size, message);
   }
-  return new ZodTuple({
-    items: schemas,
-    typeName: ZodFirstPartyTypeKind.ZodTuple,
-    rest: null,
+  nonempty(message) {
+    return this.min(1, message);
+  }
+}
+ZodSet.create = (valueType, params) => {
+  return new ZodSet({
+    valueType,
+    minSize: null,
+    maxSize: null,
+    typeName: ZodFirstPartyTypeKind.ZodSet,
     ...processCreateParams(params)
   });
 };
 
-class ZodRecord extends ZodType {
-  get keySchema() {
-    return this._def.keyType;
-  }
-  get valueSchema() {
-    return this._def.valueType;
+class ZodFunction extends ZodType {
+  constructor() {
+    super(...arguments);
+    this.validate = this.implement;
   }
   _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.object) {
+    const { ctx } = this._processInputParams(input);
+    if (ctx.parsedType !== ZodParsedType.function) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.object,
+        expected: ZodParsedType.function,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    const pairs = [];
-    const keyType = this._def.keyType;
-    const valueType = this._def.valueType;
-    for (const key in ctx.data) {
-      pairs.push({
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
-        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
-        alwaysSet: key in ctx.data
+    function makeArgsIssue(args, error) {
+      return makeIssue({
+        data: args,
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_arguments,
+          argumentsError: error
+        }
       });
     }
-    if (ctx.common.async) {
-      return ParseStatus.mergeObjectAsync(status, pairs);
+    function makeReturnsIssue(returns, error) {
+      return makeIssue({
+        data: returns,
+        path: ctx.path,
+        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
+        issueData: {
+          code: ZodIssueCode.invalid_return_type,
+          returnTypeError: error
+        }
+      });
+    }
+    const params = { errorMap: ctx.common.contextualErrorMap };
+    const fn = ctx.data;
+    if (this._def.returns instanceof ZodPromise) {
+      const me = this;
+      return OK(async function(...args) {
+        const error = new ZodError([]);
+        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+          error.addIssue(makeArgsIssue(args, e));
+          throw error;
+        });
+        const result = await Reflect.apply(fn, this, parsedArgs);
+        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          error.addIssue(makeReturnsIssue(result, e));
+          throw error;
+        });
+        return parsedReturns;
+      });
     } else {
-      return ParseStatus.mergeObjectSync(status, pairs);
+      const me = this;
+      return OK(function(...args) {
+        const parsedArgs = me._def.args.safeParse(args, params);
+        if (!parsedArgs.success) {
+          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+        }
+        const result = Reflect.apply(fn, this, parsedArgs.data);
+        const parsedReturns = me._def.returns.safeParse(result, params);
+        if (!parsedReturns.success) {
+          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+        }
+        return parsedReturns.data;
+      });
     }
   }
-  get element() {
-    return this._def.valueType;
+  parameters() {
+    return this._def.args;
+  }
+  returnType() {
+    return this._def.returns;
+  }
+  args(...items) {
+    return new ZodFunction({
+      ...this._def,
+      args: ZodTuple.create(items).rest(ZodUnknown.create())
+    });
+  }
+  returns(returnType) {
+    return new ZodFunction({
+      ...this._def,
+      returns: returnType
+    });
+  }
+  implement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
   }
-  static create(first, second, third) {
-    if (second instanceof ZodType) {
-      return new ZodRecord({
-        keyType: first,
-        valueType: second,
-        typeName: ZodFirstPartyTypeKind.ZodRecord,
-        ...processCreateParams(third)
-      });
-    }
-    return new ZodRecord({
-      keyType: ZodString.create(),
-      valueType: first,
-      typeName: ZodFirstPartyTypeKind.ZodRecord,
-      ...processCreateParams(second)
+  strictImplement(func) {
+    const validatedFunc = this.parse(func);
+    return validatedFunc;
+  }
+  static create(args, returns, params) {
+    return new ZodFunction({
+      args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
+      returns: returns || ZodUnknown.create(),
+      typeName: ZodFirstPartyTypeKind.ZodFunction,
+      ...processCreateParams(params)
     });
   }
 }
 
-class ZodMap extends ZodType {
-  get keySchema() {
-    return this._def.keyType;
+class ZodLazy extends ZodType {
+  get schema() {
+    return this._def.getter();
   }
-  get valueSchema() {
-    return this._def.valueType;
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const lazySchema = this._def.getter();
+    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
+}
+ZodLazy.create = (getter, params) => {
+  return new ZodLazy({
+    getter,
+    typeName: ZodFirstPartyTypeKind.ZodLazy,
+    ...processCreateParams(params)
+  });
+};
+
+class ZodLiteral extends ZodType {
   _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.map) {
+    if (input.data !== this._def.value) {
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.map,
-        received: ctx.parsedType
+        received: ctx.data,
+        code: ZodIssueCode.invalid_literal,
+        expected: this._def.value
       });
       return INVALID;
     }
-    const keyType = this._def.keyType;
-    const valueType = this._def.valueType;
-    const pairs = [...ctx.data.entries()].map(([key, value], index) => {
-      return {
-        key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
-        value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
-      };
-    });
-    if (ctx.common.async) {
-      const finalMap = new Map;
-      return Promise.resolve().then(async () => {
-        for (const pair of pairs) {
-          const key = await pair.key;
-          const value = await pair.value;
-          if (key.status === "aborted" || value.status === "aborted") {
-            return INVALID;
-          }
-          if (key.status === "dirty" || value.status === "dirty") {
-            status.dirty();
-          }
-          finalMap.set(key.value, value.value);
-        }
-        return { status: status.value, value: finalMap };
-      });
-    } else {
-      const finalMap = new Map;
-      for (const pair of pairs) {
-        const key = pair.key;
-        const value = pair.value;
-        if (key.status === "aborted" || value.status === "aborted") {
-          return INVALID;
-        }
-        if (key.status === "dirty" || value.status === "dirty") {
-          status.dirty();
-        }
-        finalMap.set(key.value, value.value);
-      }
-      return { status: status.value, value: finalMap };
-    }
+    return { status: "valid", value: input.data };
+  }
+  get value() {
+    return this._def.value;
   }
 }
-ZodMap.create = (keyType, valueType, params) => {
-  return new ZodMap({
-    valueType,
-    keyType,
-    typeName: ZodFirstPartyTypeKind.ZodMap,
+ZodLiteral.create = (value, params) => {
+  return new ZodLiteral({
+    value,
+    typeName: ZodFirstPartyTypeKind.ZodLiteral,
     ...processCreateParams(params)
   });
 };
+function createZodEnum(values, params) {
+  return new ZodEnum({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodEnum,
+    ...processCreateParams(params)
+  });
+}
 
-class ZodSet extends ZodType {
+class ZodEnum extends ZodType {
   _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.set) {
+    if (typeof input.data !== "string") {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
       addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.set,
-        received: ctx.parsedType
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
       });
       return INVALID;
     }
-    const def = this._def;
-    if (def.minSize !== null) {
-      if (ctx.data.size < def.minSize.value) {
-        addIssueToContext(ctx, {
-          code: ZodIssueCode.too_small,
-          minimum: def.minSize.value,
-          type: "set",
-          inclusive: true,
-          exact: false,
-          message: def.minSize.message
-        });
-        status.dirty();
-      }
+    if (!this._cache) {
+      this._cache = new Set(this._def.values);
     }
-    if (def.maxSize !== null) {
-      if (ctx.data.size > def.maxSize.value) {
-        addIssueToContext(ctx, {
-          code: ZodIssueCode.too_big,
-          maximum: def.maxSize.value,
-          type: "set",
-          inclusive: true,
-          exact: false,
-          message: def.maxSize.message
-        });
-        status.dirty();
-      }
+    if (!this._cache.has(input.data)) {
+      const ctx = this._getOrReturnCtx(input);
+      const expectedValues = this._def.values;
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
     }
-    const valueType = this._def.valueType;
-    function finalizeSet(elements2) {
-      const parsedSet = new Set;
-      for (const element of elements2) {
-        if (element.status === "aborted")
-          return INVALID;
-        if (element.status === "dirty")
-          status.dirty();
-        parsedSet.add(element.value);
-      }
-      return { status: status.value, value: parsedSet };
+    return OK(input.data);
+  }
+  get options() {
+    return this._def.values;
+  }
+  get enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
     }
-    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
-    if (ctx.common.async) {
-      return Promise.all(elements).then((elements2) => finalizeSet(elements2));
-    } else {
-      return finalizeSet(elements);
+    return enumValues;
+  }
+  get Values() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
     }
+    return enumValues;
   }
-  min(minSize, message) {
-    return new ZodSet({
+  get Enum() {
+    const enumValues = {};
+    for (const val of this._def.values) {
+      enumValues[val] = val;
+    }
+    return enumValues;
+  }
+  extract(values, newDef = this._def) {
+    return ZodEnum.create(values, {
       ...this._def,
-      minSize: { value: minSize, message: errorUtil.toString(message) }
+      ...newDef
     });
   }
-  max(maxSize, message) {
-    return new ZodSet({
+  exclude(values, newDef = this._def) {
+    return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
       ...this._def,
-      maxSize: { value: maxSize, message: errorUtil.toString(message) }
+      ...newDef
     });
   }
-  size(size, message) {
-    return this.min(size, message).max(size, message);
+}
+ZodEnum.create = createZodEnum;
+
+class ZodNativeEnum extends ZodType {
+  _parse(input) {
+    const nativeEnumValues = util.getValidEnumValues(this._def.values);
+    const ctx = this._getOrReturnCtx(input);
+    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        expected: util.joinValues(expectedValues),
+        received: ctx.parsedType,
+        code: ZodIssueCode.invalid_type
+      });
+      return INVALID;
+    }
+    if (!this._cache) {
+      this._cache = new Set(util.getValidEnumValues(this._def.values));
+    }
+    if (!this._cache.has(input.data)) {
+      const expectedValues = util.objectValues(nativeEnumValues);
+      addIssueToContext(ctx, {
+        received: ctx.data,
+        code: ZodIssueCode.invalid_enum_value,
+        options: expectedValues
+      });
+      return INVALID;
+    }
+    return OK(input.data);
   }
-  nonempty(message) {
-    return this.min(1, message);
+  get enum() {
+    return this._def.values;
   }
 }
-ZodSet.create = (valueType, params) => {
-  return new ZodSet({
-    valueType,
-    minSize: null,
-    maxSize: null,
-    typeName: ZodFirstPartyTypeKind.ZodSet,
+ZodNativeEnum.create = (values, params) => {
+  return new ZodNativeEnum({
+    values,
+    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
     ...processCreateParams(params)
   });
 };
 
-class ZodFunction extends ZodType {
-  constructor() {
-    super(...arguments);
-    this.validate = this.implement;
+class ZodPromise extends ZodType {
+  unwrap() {
+    return this._def.type;
   }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.function) {
+    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.function,
+        expected: ZodParsedType.promise,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    function makeArgsIssue(args, error) {
-      return makeIssue({
-        data: args,
+    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
+    return OK(promisified.then((data) => {
+      return this._def.type.parseAsync(data, {
         path: ctx.path,
-        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
-        issueData: {
-          code: ZodIssueCode.invalid_arguments,
-          argumentsError: error
-        }
+        errorMap: ctx.common.contextualErrorMap
       });
-    }
-    function makeReturnsIssue(returns, error) {
-      return makeIssue({
-        data: returns,
-        path: ctx.path,
-        errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
-        issueData: {
-          code: ZodIssueCode.invalid_return_type,
-          returnTypeError: error
+    }));
+  }
+}
+ZodPromise.create = (schema, params) => {
+  return new ZodPromise({
+    type: schema,
+    typeName: ZodFirstPartyTypeKind.ZodPromise,
+    ...processCreateParams(params)
+  });
+};
+
+class ZodEffects extends ZodType {
+  innerType() {
+    return this._def.schema;
+  }
+  sourceType() {
+    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  }
+  _parse(input) {
+    const { status, ctx } = this._processInputParams(input);
+    const effect = this._def.effect || null;
+    const checkCtx = {
+      addIssue: (arg) => {
+        addIssueToContext(ctx, arg);
+        if (arg.fatal) {
+          status.abort();
+        } else {
+          status.dirty();
         }
-      });
-    }
-    const params = { errorMap: ctx.common.contextualErrorMap };
-    const fn = ctx.data;
-    if (this._def.returns instanceof ZodPromise) {
-      const me = this;
-      return OK(async function(...args) {
-        const error = new ZodError([]);
-        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
-          error.addIssue(makeArgsIssue(args, e));
-          throw error;
+      },
+      get path() {
+        return ctx.path;
+      }
+    };
+    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
+    if (effect.type === "preprocess") {
+      const processed = effect.transform(ctx.data, checkCtx);
+      if (ctx.common.async) {
+        return Promise.resolve(processed).then(async (processed2) => {
+          if (status.value === "aborted")
+            return INVALID;
+          const result = await this._def.schema._parseAsync({
+            data: processed2,
+            path: ctx.path,
+            parent: ctx
+          });
+          if (result.status === "aborted")
+            return INVALID;
+          if (result.status === "dirty")
+            return DIRTY(result.value);
+          if (status.value === "dirty")
+            return DIRTY(result.value);
+          return result;
         });
-        const result = await Reflect.apply(fn, this, parsedArgs);
-        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
-          error.addIssue(makeReturnsIssue(result, e));
-          throw error;
+      } else {
+        if (status.value === "aborted")
+          return INVALID;
+        const result = this._def.schema._parseSync({
+          data: processed,
+          path: ctx.path,
+          parent: ctx
         });
-        return parsedReturns;
-      });
-    } else {
-      const me = this;
-      return OK(function(...args) {
-        const parsedArgs = me._def.args.safeParse(args, params);
-        if (!parsedArgs.success) {
-          throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
+        if (result.status === "aborted")
+          return INVALID;
+        if (result.status === "dirty")
+          return DIRTY(result.value);
+        if (status.value === "dirty")
+          return DIRTY(result.value);
+        return result;
+      }
+    }
+    if (effect.type === "refinement") {
+      const executeRefinement = (acc) => {
+        const result = effect.refinement(acc, checkCtx);
+        if (ctx.common.async) {
+          return Promise.resolve(result);
         }
-        const result = Reflect.apply(fn, this, parsedArgs.data);
-        const parsedReturns = me._def.returns.safeParse(result, params);
-        if (!parsedReturns.success) {
-          throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
+        if (result instanceof Promise) {
+          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
         }
-        return parsedReturns.data;
-      });
+        return acc;
+      };
+      if (ctx.common.async === false) {
+        const inner = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inner.status === "aborted")
+          return INVALID;
+        if (inner.status === "dirty")
+          status.dirty();
+        executeRefinement(inner.value);
+        return { status: status.value, value: inner.value };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
+          if (inner.status === "aborted")
+            return INVALID;
+          if (inner.status === "dirty")
+            status.dirty();
+          return executeRefinement(inner.value).then(() => {
+            return { status: status.value, value: inner.value };
+          });
+        });
+      }
     }
-  }
-  parameters() {
-    return this._def.args;
-  }
-  returnType() {
-    return this._def.returns;
-  }
-  args(...items) {
-    return new ZodFunction({
-      ...this._def,
-      args: ZodTuple.create(items).rest(ZodUnknown.create())
-    });
-  }
-  returns(returnType) {
-    return new ZodFunction({
-      ...this._def,
-      returns: returnType
-    });
-  }
-  implement(func) {
-    const validatedFunc = this.parse(func);
-    return validatedFunc;
-  }
-  strictImplement(func) {
-    const validatedFunc = this.parse(func);
-    return validatedFunc;
-  }
-  static create(args, returns, params) {
-    return new ZodFunction({
-      args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
-      returns: returns || ZodUnknown.create(),
-      typeName: ZodFirstPartyTypeKind.ZodFunction,
-      ...processCreateParams(params)
-    });
+    if (effect.type === "transform") {
+      if (ctx.common.async === false) {
+        const base = this._def.schema._parseSync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (!isValid(base))
+          return INVALID;
+        const result = effect.transform(base.value, checkCtx);
+        if (result instanceof Promise) {
+          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
+        }
+        return { status: status.value, value: result };
+      } else {
+        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
+          if (!isValid(base))
+            return INVALID;
+          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
+            status: status.value,
+            value: result
+          }));
+        });
+      }
+    }
+    util.assertNever(effect);
   }
 }
-
-class ZodLazy extends ZodType {
-  get schema() {
-    return this._def.getter();
+ZodEffects.create = (schema, effect, params) => {
+  return new ZodEffects({
+    schema,
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    effect,
+    ...processCreateParams(params)
+  });
+};
+ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
+  return new ZodEffects({
+    schema,
+    effect: { type: "preprocess", transform: preprocess },
+    typeName: ZodFirstPartyTypeKind.ZodEffects,
+    ...processCreateParams(params)
+  });
+};
+class ZodOptional extends ZodType {
+  _parse(input) {
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.undefined) {
+      return OK(undefined);
+    }
+    return this._def.innerType._parse(input);
   }
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const lazySchema = this._def.getter();
-    return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
+  unwrap() {
+    return this._def.innerType;
   }
 }
-ZodLazy.create = (getter, params) => {
-  return new ZodLazy({
-    getter,
-    typeName: ZodFirstPartyTypeKind.ZodLazy,
+ZodOptional.create = (type, params) => {
+  return new ZodOptional({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodOptional,
     ...processCreateParams(params)
   });
 };
 
-class ZodLiteral extends ZodType {
+class ZodNullable extends ZodType {
   _parse(input) {
-    if (input.data !== this._def.value) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_literal,
-        expected: this._def.value
-      });
-      return INVALID;
+    const parsedType = this._getType(input);
+    if (parsedType === ZodParsedType.null) {
+      return OK(null);
     }
-    return { status: "valid", value: input.data };
+    return this._def.innerType._parse(input);
   }
-  get value() {
-    return this._def.value;
+  unwrap() {
+    return this._def.innerType;
   }
 }
-ZodLiteral.create = (value, params) => {
-  return new ZodLiteral({
-    value,
-    typeName: ZodFirstPartyTypeKind.ZodLiteral,
+ZodNullable.create = (type, params) => {
+  return new ZodNullable({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodNullable,
     ...processCreateParams(params)
   });
 };
-function createZodEnum(values, params) {
-  return new ZodEnum({
-    values,
-    typeName: ZodFirstPartyTypeKind.ZodEnum,
-    ...processCreateParams(params)
-  });
-}
 
-class ZodEnum extends ZodType {
+class ZodDefault extends ZodType {
   _parse(input) {
-    if (typeof input.data !== "string") {
-      const ctx = this._getOrReturnCtx(input);
-      const expectedValues = this._def.values;
-      addIssueToContext(ctx, {
-        expected: util.joinValues(expectedValues),
-        received: ctx.parsedType,
-        code: ZodIssueCode.invalid_type
-      });
-      return INVALID;
-    }
-    if (!this._cache) {
-      this._cache = new Set(this._def.values);
-    }
-    if (!this._cache.has(input.data)) {
-      const ctx = this._getOrReturnCtx(input);
-      const expectedValues = this._def.values;
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_enum_value,
-        options: expectedValues
-      });
-      return INVALID;
-    }
-    return OK(input.data);
-  }
-  get options() {
-    return this._def.values;
-  }
-  get enum() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
-    }
-    return enumValues;
-  }
-  get Values() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
-    }
-    return enumValues;
-  }
-  get Enum() {
-    const enumValues = {};
-    for (const val of this._def.values) {
-      enumValues[val] = val;
+    const { ctx } = this._processInputParams(input);
+    let data = ctx.data;
+    if (ctx.parsedType === ZodParsedType.undefined) {
+      data = this._def.defaultValue();
     }
-    return enumValues;
-  }
-  extract(values, newDef = this._def) {
-    return ZodEnum.create(values, {
-      ...this._def,
-      ...newDef
+    return this._def.innerType._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
     });
   }
-  exclude(values, newDef = this._def) {
-    return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
-      ...this._def,
-      ...newDef
-    });
+  removeDefault() {
+    return this._def.innerType;
   }
 }
-ZodEnum.create = createZodEnum;
+ZodDefault.create = (type, params) => {
+  return new ZodDefault({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodDefault,
+    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+    ...processCreateParams(params)
+  });
+};
 
-class ZodNativeEnum extends ZodType {
+class ZodCatch extends ZodType {
   _parse(input) {
-    const nativeEnumValues = util.getValidEnumValues(this._def.values);
-    const ctx = this._getOrReturnCtx(input);
-    if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
-      const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx, {
-        expected: util.joinValues(expectedValues),
-        received: ctx.parsedType,
-        code: ZodIssueCode.invalid_type
-      });
-      return INVALID;
-    }
-    if (!this._cache) {
-      this._cache = new Set(util.getValidEnumValues(this._def.values));
-    }
-    if (!this._cache.has(input.data)) {
-      const expectedValues = util.objectValues(nativeEnumValues);
-      addIssueToContext(ctx, {
-        received: ctx.data,
-        code: ZodIssueCode.invalid_enum_value,
-        options: expectedValues
+    const { ctx } = this._processInputParams(input);
+    const newCtx = {
+      ...ctx,
+      common: {
+        ...ctx.common,
+        issues: []
+      }
+    };
+    const result = this._def.innerType._parse({
+      data: newCtx.data,
+      path: newCtx.path,
+      parent: {
+        ...newCtx
+      }
+    });
+    if (isAsync(result)) {
+      return result.then((result2) => {
+        return {
+          status: "valid",
+          value: result2.status === "valid" ? result2.value : this._def.catchValue({
+            get error() {
+              return new ZodError(newCtx.common.issues);
+            },
+            input: newCtx.data
+          })
+        };
       });
-      return INVALID;
+    } else {
+      return {
+        status: "valid",
+        value: result.status === "valid" ? result.value : this._def.catchValue({
+          get error() {
+            return new ZodError(newCtx.common.issues);
+          },
+          input: newCtx.data
+        })
+      };
     }
-    return OK(input.data);
   }
-  get enum() {
-    return this._def.values;
+  removeCatch() {
+    return this._def.innerType;
   }
 }
-ZodNativeEnum.create = (values, params) => {
-  return new ZodNativeEnum({
-    values,
-    typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
+ZodCatch.create = (type, params) => {
+  return new ZodCatch({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodCatch,
+    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
     ...processCreateParams(params)
   });
 };
 
-class ZodPromise extends ZodType {
-  unwrap() {
-    return this._def.type;
-  }
+class ZodNaN extends ZodType {
   _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
+    const parsedType = this._getType(input);
+    if (parsedType !== ZodParsedType.nan) {
+      const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.promise,
+        expected: ZodParsedType.nan,
         received: ctx.parsedType
       });
       return INVALID;
     }
-    const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
-    return OK(promisified.then((data) => {
-      return this._def.type.parseAsync(data, {
-        path: ctx.path,
-        errorMap: ctx.common.contextualErrorMap
-      });
-    }));
+    return { status: "valid", value: input.data };
   }
 }
-ZodPromise.create = (schema, params) => {
-  return new ZodPromise({
-    type: schema,
-    typeName: ZodFirstPartyTypeKind.ZodPromise,
+ZodNaN.create = (params) => {
+  return new ZodNaN({
+    typeName: ZodFirstPartyTypeKind.ZodNaN,
     ...processCreateParams(params)
   });
 };
+var BRAND = Symbol("zod_brand");
 
-class ZodEffects extends ZodType {
-  innerType() {
-    return this._def.schema;
+class ZodBranded extends ZodType {
+  _parse(input) {
+    const { ctx } = this._processInputParams(input);
+    const data = ctx.data;
+    return this._def.type._parse({
+      data,
+      path: ctx.path,
+      parent: ctx
+    });
   }
-  sourceType() {
-    return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
+  unwrap() {
+    return this._def.type;
   }
+}
+
+class ZodPipeline extends ZodType {
   _parse(input) {
     const { status, ctx } = this._processInputParams(input);
-    const effect = this._def.effect || null;
-    const checkCtx = {
-      addIssue: (arg) => {
-        addIssueToContext(ctx, arg);
-        if (arg.fatal) {
-          status.abort();
-        } else {
+    if (ctx.common.async) {
+      const handleAsync = async () => {
+        const inResult = await this._def.in._parseAsync({
+          data: ctx.data,
+          path: ctx.path,
+          parent: ctx
+        });
+        if (inResult.status === "aborted")
+          return INVALID;
+        if (inResult.status === "dirty") {
           status.dirty();
-        }
-      },
-      get path() {
-        return ctx.path;
-      }
-    };
-    checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
-    if (effect.type === "preprocess") {
-      const processed = effect.transform(ctx.data, checkCtx);
-      if (ctx.common.async) {
-        return Promise.resolve(processed).then(async (processed2) => {
-          if (status.value === "aborted")
-            return INVALID;
-          const result = await this._def.schema._parseAsync({
-            data: processed2,
+          return DIRTY(inResult.value);
+        } else {
+          return this._def.out._parseAsync({
+            data: inResult.value,
             path: ctx.path,
             parent: ctx
           });
-          if (result.status === "aborted")
-            return INVALID;
-          if (result.status === "dirty")
-            return DIRTY(result.value);
-          if (status.value === "dirty")
-            return DIRTY(result.value);
-          return result;
-        });
+        }
+      };
+      return handleAsync();
+    } else {
+      const inResult = this._def.in._parseSync({
+        data: ctx.data,
+        path: ctx.path,
+        parent: ctx
+      });
+      if (inResult.status === "aborted")
+        return INVALID;
+      if (inResult.status === "dirty") {
+        status.dirty();
+        return {
+          status: "dirty",
+          value: inResult.value
+        };
       } else {
-        if (status.value === "aborted")
-          return INVALID;
-        const result = this._def.schema._parseSync({
-          data: processed,
+        return this._def.out._parseSync({
+          data: inResult.value,
           path: ctx.path,
           parent: ctx
         });
-        if (result.status === "aborted")
-          return INVALID;
-        if (result.status === "dirty")
-          return DIRTY(result.value);
-        if (status.value === "dirty")
-          return DIRTY(result.value);
-        return result;
       }
     }
-    if (effect.type === "refinement") {
-      const executeRefinement = (acc) => {
-        const result = effect.refinement(acc, checkCtx);
-        if (ctx.common.async) {
-          return Promise.resolve(result);
-        }
-        if (result instanceof Promise) {
-          throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
-        }
-        return acc;
-      };
-      if (ctx.common.async === false) {
-        const inner = this._def.schema._parseSync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inner.status === "aborted")
-          return INVALID;
-        if (inner.status === "dirty")
-          status.dirty();
-        executeRefinement(inner.value);
-        return { status: status.value, value: inner.value };
-      } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
-          if (inner.status === "aborted")
-            return INVALID;
-          if (inner.status === "dirty")
-            status.dirty();
-          return executeRefinement(inner.value).then(() => {
-            return { status: status.value, value: inner.value };
-          });
+  }
+  static create(a, b) {
+    return new ZodPipeline({
+      in: a,
+      out: b,
+      typeName: ZodFirstPartyTypeKind.ZodPipeline
+    });
+  }
+}
+
+class ZodReadonly extends ZodType {
+  _parse(input) {
+    const result = this._def.innerType._parse(input);
+    const freeze = (data) => {
+      if (isValid(data)) {
+        data.value = Object.freeze(data.value);
+      }
+      return data;
+    };
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  }
+  unwrap() {
+    return this._def.innerType;
+  }
+}
+ZodReadonly.create = (type, params) => {
+  return new ZodReadonly({
+    innerType: type,
+    typeName: ZodFirstPartyTypeKind.ZodReadonly,
+    ...processCreateParams(params)
+  });
+};
+function cleanParams(params, data) {
+  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p2 = typeof p === "string" ? { message: p } : p;
+  return p2;
+}
+function custom(check, _params = {}, fatal) {
+  if (check)
+    return ZodAny.create().superRefine((data, ctx) => {
+      const r = check(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+          }
         });
       }
+      if (!r) {
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      }
+      return;
+    });
+  return ZodAny.create();
+}
+var late = {
+  object: ZodObject.lazycreate
+};
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind2) {
+  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
+  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
+  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
+  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
+  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
+  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
+  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
+  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
+  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
+  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
+  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
+  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
+  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
+  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
+  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
+  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
+  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
+  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
+  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
+  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
+  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
+  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
+  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
+  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
+  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
+  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
+  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
+  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
+  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
+  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
+  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
+  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
+  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
+  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
+  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
+  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
+})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom((data) => data instanceof cls, params);
+var stringType = ZodString.create;
+var numberType = ZodNumber.create;
+var nanType = ZodNaN.create;
+var bigIntType = ZodBigInt.create;
+var booleanType = ZodBoolean.create;
+var dateType = ZodDate.create;
+var symbolType = ZodSymbol.create;
+var undefinedType = ZodUndefined.create;
+var nullType = ZodNull.create;
+var anyType = ZodAny.create;
+var unknownType = ZodUnknown.create;
+var neverType = ZodNever.create;
+var voidType = ZodVoid.create;
+var arrayType = ZodArray.create;
+var objectType = ZodObject.create;
+var strictObjectType = ZodObject.strictCreate;
+var unionType = ZodUnion.create;
+var discriminatedUnionType = ZodDiscriminatedUnion.create;
+var intersectionType = ZodIntersection.create;
+var tupleType = ZodTuple.create;
+var recordType = ZodRecord.create;
+var mapType = ZodMap.create;
+var setType = ZodSet.create;
+var functionType = ZodFunction.create;
+var lazyType = ZodLazy.create;
+var literalType = ZodLiteral.create;
+var enumType = ZodEnum.create;
+var nativeEnumType = ZodNativeEnum.create;
+var promiseType = ZodPromise.create;
+var effectsType = ZodEffects.create;
+var optionalType = ZodOptional.create;
+var nullableType = ZodNullable.create;
+var preprocessType = ZodEffects.createWithPreprocess;
+var pipelineType = ZodPipeline.create;
+var ostring = () => stringType().optional();
+var onumber = () => numberType().optional();
+var oboolean = () => booleanType().optional();
+var coerce = {
+  string: (arg) => ZodString.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean.create({
+    ...arg,
+    coerce: true
+  }),
+  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate.create({ ...arg, coerce: true })
+};
+var NEVER = INVALID;
+// src/types.ts
+var asZodObject = (s) => s;
+
+// src/schema.ts
+function parseRelationsConfig(relations, schemas) {
+  const relationships = [];
+  const added = new Set;
+  for (const [fromTable, rels] of Object.entries(relations)) {
+    if (!schemas[fromTable]) {
+      throw new Error(`relations: unknown table '${fromTable}'`);
     }
-    if (effect.type === "transform") {
-      if (ctx.common.async === false) {
-        const base = this._def.schema._parseSync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
+    for (const [fkColumn, toTable] of Object.entries(rels)) {
+      if (!schemas[toTable]) {
+        throw new Error(`relations: unknown target table '${toTable}' in ${fromTable}.${fkColumn}`);
+      }
+      const navField = fkColumn.replace(/_id$/, "");
+      const btKey = `${fromTable}.${fkColumn}:belongs-to`;
+      if (!added.has(btKey)) {
+        relationships.push({
+          type: "belongs-to",
+          from: fromTable,
+          to: toTable,
+          relationshipField: navField,
+          foreignKey: fkColumn
         });
-        if (!isValid(base))
-          return INVALID;
-        const result = effect.transform(base.value, checkCtx);
-        if (result instanceof Promise) {
-          throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
-        }
-        return { status: status.value, value: result };
-      } else {
-        return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
-          if (!isValid(base))
-            return INVALID;
-          return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
-            status: status.value,
-            value: result
-          }));
+        added.add(btKey);
+      }
+      const otmKey = `${toTable}.${fromTable}:one-to-many`;
+      if (!added.has(otmKey)) {
+        relationships.push({
+          type: "one-to-many",
+          from: toTable,
+          to: fromTable,
+          relationshipField: fromTable,
+          foreignKey: ""
         });
+        added.add(otmKey);
       }
     }
-    util.assertNever(effect);
   }
+  return relationships;
 }
-ZodEffects.create = (schema, effect, params) => {
-  return new ZodEffects({
-    schema,
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    effect,
-    ...processCreateParams(params)
-  });
-};
-ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
-  return new ZodEffects({
-    schema,
-    effect: { type: "preprocess", transform: preprocess },
-    typeName: ZodFirstPartyTypeKind.ZodEffects,
-    ...processCreateParams(params)
-  });
-};
-class ZodOptional extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType === ZodParsedType.undefined) {
-      return OK(undefined);
-    }
-    return this._def.innerType._parse(input);
+function getStorableFields(schema) {
+  return Object.entries(asZodObject(schema).shape).filter(([key]) => key !== "id").map(([name, type]) => ({ name, type }));
+}
+function zodTypeToSqlType(zodType) {
+  if (zodType instanceof exports_external.ZodOptional) {
+    zodType = zodType._def.innerType;
   }
-  unwrap() {
-    return this._def.innerType;
+  if (zodType instanceof exports_external.ZodDefault) {
+    zodType = zodType._def.innerType;
   }
+  if (zodType instanceof exports_external.ZodString || zodType instanceof exports_external.ZodDate)
+    return "TEXT";
+  if (zodType instanceof exports_external.ZodNumber || zodType instanceof exports_external.ZodBoolean)
+    return "INTEGER";
+  if (zodType._def.typeName === "ZodInstanceOf" && zodType._def.type === Buffer)
+    return "BLOB";
+  return "TEXT";
 }
-ZodOptional.create = (type, params) => {
-  return new ZodOptional({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodOptional,
-    ...processCreateParams(params)
-  });
-};
-
-class ZodNullable extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType === ZodParsedType.null) {
-      return OK(null);
+function transformForStorage(data) {
+  const transformed = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value instanceof Date) {
+      transformed[key] = value.toISOString();
+    } else if (typeof value === "boolean") {
+      transformed[key] = value ? 1 : 0;
+    } else {
+      transformed[key] = value;
     }
-    return this._def.innerType._parse(input);
   }
-  unwrap() {
-    return this._def.innerType;
+  return transformed;
+}
+function transformFromStorage(row, schema) {
+  const transformed = {};
+  for (const [key, value] of Object.entries(row)) {
+    let fieldSchema = asZodObject(schema).shape[key];
+    if (fieldSchema instanceof exports_external.ZodOptional) {
+      fieldSchema = fieldSchema._def.innerType;
+    }
+    if (fieldSchema instanceof exports_external.ZodDefault) {
+      fieldSchema = fieldSchema._def.innerType;
+    }
+    if (fieldSchema instanceof exports_external.ZodDate && typeof value === "string") {
+      transformed[key] = new Date(value);
+    } else if (fieldSchema instanceof exports_external.ZodBoolean && typeof value === "number") {
+      transformed[key] = value === 1;
+    } else {
+      transformed[key] = value;
+    }
   }
+  return transformed;
 }
-ZodNullable.create = (type, params) => {
-  return new ZodNullable({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodNullable,
-    ...processCreateParams(params)
-  });
-};
 
-class ZodDefault extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    let data = ctx.data;
-    if (ctx.parsedType === ZodParsedType.undefined) {
-      data = this._def.defaultValue();
+// src/query.ts
+var OPERATOR_MAP = {
+  $gt: ">",
+  $gte: ">=",
+  $lt: "<",
+  $lte: "<=",
+  $ne: "!=",
+  $in: "IN",
+  $like: "LIKE",
+  $notIn: "NOT IN",
+  $between: "BETWEEN"
+};
+function transformValueForStorage(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  return value;
+}
+function compileIQO(tableName, iqo) {
+  const params = [];
+  const selectParts = [];
+  if (iqo.selects.length > 0) {
+    selectParts.push(...iqo.selects.map((s) => `${tableName}.${s}`));
+  } else {
+    selectParts.push(`${tableName}.*`);
+  }
+  for (const j of iqo.joins) {
+    if (j.columns.length > 0) {
+      selectParts.push(...j.columns.map((c) => `${j.table}.${c} AS ${j.table}_${c}`));
+    } else {
+      selectParts.push(`${j.table}.*`);
     }
-    return this._def.innerType._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
   }
-  removeDefault() {
-    return this._def.innerType;
+  let sql = `SELECT ${selectParts.join(", ")} FROM ${tableName}`;
+  for (const j of iqo.joins) {
+    sql += ` JOIN ${j.table} ON ${tableName}.${j.fromCol} = ${j.table}.${j.toCol}`;
   }
-}
-ZodDefault.create = (type, params) => {
-  return new ZodDefault({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodDefault,
-    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
-    ...processCreateParams(params)
-  });
-};
-
-class ZodCatch extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const newCtx = {
-      ...ctx,
-      common: {
-        ...ctx.common,
-        issues: []
+  if (iqo.whereAST) {
+    const compiled = compileAST(iqo.whereAST);
+    sql += ` WHERE ${compiled.sql}`;
+    params.push(...compiled.params);
+  } else if (iqo.wheres.length > 0) {
+    const hasJoins = iqo.joins.length > 0;
+    const qualify = (field) => hasJoins && !field.includes(".") ? `${tableName}.${field}` : field;
+    const whereParts = [];
+    for (const w of iqo.wheres) {
+      if (w.operator === "IN") {
+        const arr = w.value;
+        if (arr.length === 0) {
+          whereParts.push("1 = 0");
+        } else {
+          const placeholders = arr.map(() => "?").join(", ");
+          whereParts.push(`${qualify(w.field)} IN (${placeholders})`);
+          params.push(...arr.map(transformValueForStorage));
+        }
+      } else if (w.operator === "NOT IN") {
+        const arr = w.value;
+        if (arr.length === 0)
+          continue;
+        const placeholders = arr.map(() => "?").join(", ");
+        whereParts.push(`${qualify(w.field)} NOT IN (${placeholders})`);
+        params.push(...arr.map(transformValueForStorage));
+      } else if (w.operator === "BETWEEN") {
+        const [min, max] = w.value;
+        whereParts.push(`${qualify(w.field)} BETWEEN ? AND ?`);
+        params.push(transformValueForStorage(min), transformValueForStorage(max));
+      } else {
+        whereParts.push(`${qualify(w.field)} ${w.operator} ?`);
+        params.push(transformValueForStorage(w.value));
       }
-    };
-    const result = this._def.innerType._parse({
-      data: newCtx.data,
-      path: newCtx.path,
-      parent: {
-        ...newCtx
+    }
+    if (whereParts.length > 0) {
+      sql += ` WHERE ${whereParts.join(" AND ")}`;
+    }
+  }
+  if (iqo.whereOrs.length > 0) {
+    for (const orGroup of iqo.whereOrs) {
+      const orParts = [];
+      for (const w of orGroup) {
+        if (w.operator === "IN") {
+          const arr = w.value;
+          if (arr.length === 0) {
+            orParts.push("1 = 0");
+          } else {
+            orParts.push(`${w.field} IN (${arr.map(() => "?").join(", ")})`);
+            params.push(...arr.map(transformValueForStorage));
+          }
+        } else {
+          orParts.push(`${w.field} ${w.operator} ?`);
+          params.push(transformValueForStorage(w.value));
+        }
+      }
+      if (orParts.length > 0) {
+        const orClause = `(${orParts.join(" OR ")})`;
+        sql += sql.includes(" WHERE ") ? ` AND ${orClause}` : ` WHERE ${orClause}`;
       }
-    });
-    if (isAsync(result)) {
-      return result.then((result2) => {
-        return {
-          status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.catchValue({
-            get error() {
-              return new ZodError(newCtx.common.issues);
-            },
-            input: newCtx.data
-          })
-        };
-      });
-    } else {
-      return {
-        status: "valid",
-        value: result.status === "valid" ? result.value : this._def.catchValue({
-          get error() {
-            return new ZodError(newCtx.common.issues);
-          },
-          input: newCtx.data
-        })
-      };
     }
   }
-  removeCatch() {
-    return this._def.innerType;
+  if (iqo.groupBy.length > 0) {
+    sql += ` GROUP BY ${iqo.groupBy.join(", ")}`;
   }
-}
-ZodCatch.create = (type, params) => {
-  return new ZodCatch({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodCatch,
-    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
-    ...processCreateParams(params)
-  });
-};
-
-class ZodNaN extends ZodType {
-  _parse(input) {
-    const parsedType = this._getType(input);
-    if (parsedType !== ZodParsedType.nan) {
-      const ctx = this._getOrReturnCtx(input);
-      addIssueToContext(ctx, {
-        code: ZodIssueCode.invalid_type,
-        expected: ZodParsedType.nan,
-        received: ctx.parsedType
-      });
-      return INVALID;
-    }
-    return { status: "valid", value: input.data };
+  if (iqo.orderBy.length > 0) {
+    const parts = iqo.orderBy.map((o) => `${o.field} ${o.direction.toUpperCase()}`);
+    sql += ` ORDER BY ${parts.join(", ")}`;
   }
+  if (iqo.limit !== null)
+    sql += ` LIMIT ${iqo.limit}`;
+  if (iqo.offset !== null)
+    sql += ` OFFSET ${iqo.offset}`;
+  return { sql, params };
 }
-ZodNaN.create = (params) => {
-  return new ZodNaN({
-    typeName: ZodFirstPartyTypeKind.ZodNaN,
-    ...processCreateParams(params)
-  });
-};
-var BRAND = Symbol("zod_brand");
 
-class ZodBranded extends ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const data = ctx.data;
-    return this._def.type._parse({
-      data,
-      path: ctx.path,
-      parent: ctx
-    });
+class QueryBuilder {
+  iqo;
+  tableName;
+  executor;
+  singleExecutor;
+  joinResolver;
+  conditionResolver;
+  eagerLoader;
+  constructor(tableName, executor, singleExecutor, joinResolver, conditionResolver, eagerLoader) {
+    this.tableName = tableName;
+    this.executor = executor;
+    this.singleExecutor = singleExecutor;
+    this.joinResolver = joinResolver ?? null;
+    this.conditionResolver = conditionResolver ?? null;
+    this.eagerLoader = eagerLoader ?? null;
+    this.iqo = {
+      selects: [],
+      wheres: [],
+      whereOrs: [],
+      whereAST: null,
+      joins: [],
+      groupBy: [],
+      limit: null,
+      offset: null,
+      orderBy: [],
+      includes: [],
+      raw: false
+    };
   }
-  unwrap() {
-    return this._def.type;
+  select(...cols) {
+    this.iqo.selects.push(...cols);
+    return this;
   }
-}
-
-class ZodPipeline extends ZodType {
-  _parse(input) {
-    const { status, ctx } = this._processInputParams(input);
-    if (ctx.common.async) {
-      const handleAsync = async () => {
-        const inResult = await this._def.in._parseAsync({
-          data: ctx.data,
-          path: ctx.path,
-          parent: ctx
-        });
-        if (inResult.status === "aborted")
-          return INVALID;
-        if (inResult.status === "dirty") {
-          status.dirty();
-          return DIRTY(inResult.value);
+  where(criteriaOrCallback) {
+    if (typeof criteriaOrCallback === "function") {
+      const ast = criteriaOrCallback(createColumnProxy(), createFunctionProxy(), op);
+      if (this.iqo.whereAST) {
+        this.iqo.whereAST = { type: "operator", op: "AND", left: this.iqo.whereAST, right: ast };
+      } else {
+        this.iqo.whereAST = ast;
+      }
+    } else {
+      const resolved = this.conditionResolver ? this.conditionResolver(criteriaOrCallback) : criteriaOrCallback;
+      for (const [key, value] of Object.entries(resolved)) {
+        if (key === "$or" && Array.isArray(value)) {
+          const orConditions = [];
+          for (const branch of value) {
+            const resolvedBranch = this.conditionResolver ? this.conditionResolver(branch) : branch;
+            for (const [bKey, bValue] of Object.entries(resolvedBranch)) {
+              if (typeof bValue === "object" && bValue !== null && !Array.isArray(bValue) && !(bValue instanceof Date)) {
+                for (const [opKey, operand] of Object.entries(bValue)) {
+                  const sqlOp = OPERATOR_MAP[opKey];
+                  if (sqlOp)
+                    orConditions.push({ field: bKey, operator: sqlOp, value: operand });
+                }
+              } else {
+                orConditions.push({ field: bKey, operator: "=", value: bValue });
+              }
+            }
+          }
+          if (orConditions.length > 0)
+            this.iqo.whereOrs.push(orConditions);
+          continue;
+        }
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+          for (const [opKey, operand] of Object.entries(value)) {
+            const sqlOp = OPERATOR_MAP[opKey];
+            if (!sqlOp)
+              throw new Error(`Unsupported query operator: '${opKey}' on field '${key}'.`);
+            if (opKey === "$between") {
+              if (!Array.isArray(operand) || operand.length !== 2)
+                throw new Error(`$between for '${key}' requires [min, max]`);
+            }
+            this.iqo.wheres.push({
+              field: key,
+              operator: sqlOp,
+              value: operand
+            });
+          }
         } else {
-          return this._def.out._parseAsync({
-            data: inResult.value,
-            path: ctx.path,
-            parent: ctx
-          });
+          this.iqo.wheres.push({ field: key, operator: "=", value });
         }
-      };
-      return handleAsync();
+      }
+    }
+    return this;
+  }
+  limit(n) {
+    this.iqo.limit = n;
+    return this;
+  }
+  offset(n) {
+    this.iqo.offset = n;
+    return this;
+  }
+  orderBy(field, direction = "asc") {
+    this.iqo.orderBy.push({ field, direction });
+    return this;
+  }
+  join(tableOrAccessor, fkOrCols, colsOrPk, pk) {
+    let table;
+    let fromCol;
+    let toCol;
+    let columns;
+    if (typeof tableOrAccessor === "object" && "_tableName" in tableOrAccessor) {
+      table = tableOrAccessor._tableName;
+      columns = Array.isArray(fkOrCols) ? fkOrCols : [];
+      if (!this.joinResolver)
+        throw new Error(`Cannot auto-resolve join: no relationship data available`);
+      const resolved = this.joinResolver(this.tableName, table);
+      if (!resolved)
+        throw new Error(`No relationship found between '${this.tableName}' and '${table}'`);
+      fromCol = resolved.fk;
+      toCol = resolved.pk;
     } else {
-      const inResult = this._def.in._parseSync({
-        data: ctx.data,
-        path: ctx.path,
-        parent: ctx
-      });
-      if (inResult.status === "aborted")
-        return INVALID;
-      if (inResult.status === "dirty") {
-        status.dirty();
-        return {
-          status: "dirty",
-          value: inResult.value
-        };
-      } else {
-        return this._def.out._parseSync({
-          data: inResult.value,
-          path: ctx.path,
-          parent: ctx
-        });
+      table = tableOrAccessor;
+      fromCol = fkOrCols;
+      columns = Array.isArray(colsOrPk) ? colsOrPk : [];
+      toCol = (typeof colsOrPk === "string" ? colsOrPk : pk) ?? "id";
+    }
+    this.iqo.joins.push({ table, fromCol, toCol, columns });
+    this.iqo.raw = true;
+    return this;
+  }
+  raw() {
+    this.iqo.raw = true;
+    return this;
+  }
+  with(...relations) {
+    this.iqo.includes.push(...relations);
+    return this;
+  }
+  _applyEagerLoads(results) {
+    if (this.iqo.includes.length === 0 || !this.eagerLoader || results.length === 0) {
+      return results;
+    }
+    const parentIds = results.map((r) => r.id).filter((id) => typeof id === "number");
+    if (parentIds.length === 0)
+      return results;
+    for (const relation of this.iqo.includes) {
+      const loaded = this.eagerLoader(this.tableName, relation, parentIds);
+      if (!loaded)
+        continue;
+      for (const row of results) {
+        row[loaded.key] = loaded.groups.get(row.id) ?? [];
       }
     }
+    return results;
+  }
+  all() {
+    const { sql, params } = compileIQO(this.tableName, this.iqo);
+    const results = this.executor(sql, params, this.iqo.raw);
+    return this._applyEagerLoads(results);
+  }
+  get() {
+    this.iqo.limit = 1;
+    const { sql, params } = compileIQO(this.tableName, this.iqo);
+    const result = this.singleExecutor(sql, params, this.iqo.raw);
+    if (!result)
+      return null;
+    const [loaded] = this._applyEagerLoads([result]);
+    return loaded ?? null;
   }
-  static create(a, b) {
-    return new ZodPipeline({
-      in: a,
-      out: b,
-      typeName: ZodFirstPartyTypeKind.ZodPipeline
-    });
+  count() {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const countSql = selectSql.replace(/^SELECT .+? FROM/, "SELECT COUNT(*) as count FROM");
+    const results = this.executor(countSql, params, true);
+    return results[0]?.count ?? 0;
+  }
+  first() {
+    return this.get();
+  }
+  exists() {
+    const { sql: selectSql, params } = compileIQO(this.tableName, this.iqo);
+    const existsSql = selectSql.replace(/^SELECT .+? FROM/, "SELECT 1 FROM").replace(/ LIMIT \d+/, "") + " LIMIT 1";
+    const results = this.executor(existsSql, params, true);
+    return results.length > 0;
+  }
+  groupBy(...fields) {
+    this.iqo.groupBy.push(...fields);
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    try {
+      const result = this.all();
+      return Promise.resolve(result).then(onfulfilled, onrejected);
+    } catch (err) {
+      return Promise.reject(err).then(onfulfilled, onrejected);
+    }
   }
 }
 
-class ZodReadonly extends ZodType {
-  _parse(input) {
-    const result = this._def.innerType._parse(input);
-    const freeze = (data) => {
-      if (isValid(data)) {
-        data.value = Object.freeze(data.value);
-      }
-      return data;
-    };
-    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+class ColumnNode {
+  table;
+  column;
+  alias;
+  _type = "COL";
+  constructor(table, column, alias) {
+    this.table = table;
+    this.column = column;
+    this.alias = alias;
   }
-  unwrap() {
-    return this._def.innerType;
+  toString() {
+    return `"${this.alias}"."${this.column}"`;
+  }
+  [Symbol.toPrimitive]() {
+    return this.toString();
   }
 }
-ZodReadonly.create = (type, params) => {
-  return new ZodReadonly({
-    innerType: type,
-    typeName: ZodFirstPartyTypeKind.ZodReadonly,
-    ...processCreateParams(params)
-  });
-};
-function cleanParams(params, data) {
-  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-  const p2 = typeof p === "string" ? { message: p } : p;
-  return p2;
+function q(name) {
+  return `"${name}"`;
 }
-function custom(check, _params = {}, fatal) {
-  if (check)
-    return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
-            const params = cleanParams(_params, data);
-            const _fatal = params.fatal ?? fatal ?? true;
-            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
-          }
-        });
+function qRef(alias, column) {
+  return `"${alias}"."${column}"`;
+}
+function createTableProxy(tableName, alias, columns) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+        return;
       }
-      if (!r) {
-        const params = cleanParams(_params, data);
-        const _fatal = params.fatal ?? fatal ?? true;
-        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      return new ColumnNode(tableName, prop, alias);
+    },
+    ownKeys() {
+      return [...columns];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (columns.has(prop)) {
+        return { configurable: true, enumerable: true, value: new ColumnNode(tableName, prop, alias) };
       }
       return;
-    });
-  return ZodAny.create();
+    }
+  });
 }
-var late = {
-  object: ZodObject.lazycreate
-};
-var ZodFirstPartyTypeKind;
-(function(ZodFirstPartyTypeKind2) {
-  ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
-  ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
-  ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
-  ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
-  ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
-  ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
-  ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
-  ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
-  ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
-  ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
-  ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
-  ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
-  ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
-  ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
-  ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
-  ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
-  ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-  ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
-  ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
-  ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
-  ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
-  ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
-  ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
-  ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
-  ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
-  ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
-  ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
-  ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
-  ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
-  ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
-  ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
-  ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
-  ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
-  ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
-  ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
-  ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-var instanceOfType = (cls, params = {
-  message: `Input not instance of ${cls.name}`
-}) => custom((data) => data instanceof cls, params);
-var stringType = ZodString.create;
-var numberType = ZodNumber.create;
-var nanType = ZodNaN.create;
-var bigIntType = ZodBigInt.create;
-var booleanType = ZodBoolean.create;
-var dateType = ZodDate.create;
-var symbolType = ZodSymbol.create;
-var undefinedType = ZodUndefined.create;
-var nullType = ZodNull.create;
-var anyType = ZodAny.create;
-var unknownType = ZodUnknown.create;
-var neverType = ZodNever.create;
-var voidType = ZodVoid.create;
-var arrayType = ZodArray.create;
-var objectType = ZodObject.create;
-var strictObjectType = ZodObject.strictCreate;
-var unionType = ZodUnion.create;
-var discriminatedUnionType = ZodDiscriminatedUnion.create;
-var intersectionType = ZodIntersection.create;
-var tupleType = ZodTuple.create;
-var recordType = ZodRecord.create;
-var mapType = ZodMap.create;
-var setType = ZodSet.create;
-var functionType = ZodFunction.create;
-var lazyType = ZodLazy.create;
-var literalType = ZodLiteral.create;
-var enumType = ZodEnum.create;
-var nativeEnumType = ZodNativeEnum.create;
-var promiseType = ZodPromise.create;
-var effectsType = ZodEffects.create;
-var optionalType = ZodOptional.create;
-var nullableType = ZodNullable.create;
-var preprocessType = ZodEffects.createWithPreprocess;
-var pipelineType = ZodPipeline.create;
-var ostring = () => stringType().optional();
-var onumber = () => numberType().optional();
-var oboolean = () => booleanType().optional();
-var coerce = {
-  string: (arg) => ZodString.create({ ...arg, coerce: true }),
-  number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
-  boolean: (arg) => ZodBoolean.create({
-    ...arg,
-    coerce: true
-  }),
-  bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
-  date: (arg) => ZodDate.create({ ...arg, coerce: true })
-};
-var NEVER = INVALID;
-// src/schema.ts
-function parseRelationsConfig(relations, schemas) {
-  const relationships = [];
-  const added = new Set;
-  for (const [fromTable, rels] of Object.entries(relations)) {
-    if (!schemas[fromTable]) {
-      throw new Error(`relations: unknown table '${fromTable}'`);
+function createContextProxy(schemas) {
+  const aliases = new Map;
+  let aliasCounter = 0;
+  const proxy = new Proxy({}, {
+    get(_target, tableName) {
+      if (typeof tableName !== "string")
+        return;
+      const schema = schemas[tableName];
+      const shape = schema ? schema.shape : {};
+      const columns = new Set(Object.keys(shape));
+      aliasCounter++;
+      const alias = `t${aliasCounter}`;
+      const tableProxy = createTableProxy(tableName, alias, columns);
+      const entries = aliases.get(tableName) || [];
+      entries.push({ tableName, alias, proxy: tableProxy });
+      aliases.set(tableName, entries);
+      return tableProxy;
+    }
+  });
+  return { proxy, aliasMap: aliases };
+}
+function isColumnNode(val) {
+  return val && typeof val === "object" && val._type === "COL";
+}
+function compileProxyQuery(queryResult, aliasMap) {
+  const params = [];
+  const tablesUsed = new Map;
+  for (const [tableName, entries] of aliasMap) {
+    for (const entry of entries) {
+      tablesUsed.set(entry.alias, { tableName, alias: entry.alias });
+    }
+  }
+  const selectParts = [];
+  for (const [outputName, colOrValue] of Object.entries(queryResult.select)) {
+    if (isColumnNode(colOrValue)) {
+      if (outputName === colOrValue.column) {
+        selectParts.push(qRef(colOrValue.alias, colOrValue.column));
+      } else {
+        selectParts.push(`${qRef(colOrValue.alias, colOrValue.column)} AS ${q(outputName)}`);
+      }
+    } else {
+      selectParts.push(`? AS ${q(outputName)}`);
+      params.push(colOrValue);
+    }
+  }
+  const allAliases = [...tablesUsed.values()];
+  if (allAliases.length === 0)
+    throw new Error("No tables referenced in query.");
+  const primaryAlias = allAliases[0];
+  let sql = `SELECT ${selectParts.join(", ")} FROM ${q(primaryAlias.tableName)} ${q(primaryAlias.alias)}`;
+  if (queryResult.join) {
+    const joins = Array.isArray(queryResult.join[0]) ? queryResult.join : [queryResult.join];
+    for (const [left, right] of joins) {
+      const leftTable = tablesUsed.get(left.alias);
+      const rightTable = tablesUsed.get(right.alias);
+      if (!leftTable || !rightTable)
+        throw new Error("Join references unknown table alias.");
+      const joinAlias = leftTable.alias === primaryAlias.alias ? rightTable : leftTable;
+      sql += ` JOIN ${q(joinAlias.tableName)} ${q(joinAlias.alias)} ON ${qRef(left.alias, left.column)} = ${qRef(right.alias, right.column)}`;
     }
-    for (const [fkColumn, toTable] of Object.entries(rels)) {
-      if (!schemas[toTable]) {
-        throw new Error(`relations: unknown target table '${toTable}' in ${fromTable}.${fkColumn}`);
+  }
+  if (queryResult.where && Object.keys(queryResult.where).length > 0) {
+    const whereParts = [];
+    for (const [key, value] of Object.entries(queryResult.where)) {
+      let fieldRef;
+      const quotedMatch = key.match(/^"([^"]+)"\.\"([^"]+)"$/);
+      if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
+        fieldRef = key;
+      } else {
+        fieldRef = qRef(primaryAlias.alias, key);
       }
-      const navField = fkColumn.replace(/_id$/, "");
-      const btKey = `${fromTable}.${fkColumn}:belongs-to`;
-      if (!added.has(btKey)) {
-        relationships.push({
-          type: "belongs-to",
-          from: fromTable,
-          to: toTable,
-          relationshipField: navField,
-          foreignKey: fkColumn
-        });
-        added.add(btKey);
+      if (isColumnNode(value)) {
+        whereParts.push(`${fieldRef} = ${qRef(value.alias, value.column)}`);
+      } else if (Array.isArray(value)) {
+        if (value.length === 0) {
+          whereParts.push("1 = 0");
+        } else {
+          const placeholders = value.map(() => "?").join(", ");
+          whereParts.push(`${fieldRef} IN (${placeholders})`);
+          params.push(...value);
+        }
+      } else if (typeof value === "object" && value !== null && !(value instanceof Date)) {
+        for (const [pOp, operand] of Object.entries(value)) {
+          if (pOp === "$in") {
+            const arr = operand;
+            if (arr.length === 0) {
+              whereParts.push("1 = 0");
+            } else {
+              const placeholders = arr.map(() => "?").join(", ");
+              whereParts.push(`${fieldRef} IN (${placeholders})`);
+              params.push(...arr);
+            }
+            continue;
+          }
+          const opMap = {
+            $gt: ">",
+            $gte: ">=",
+            $lt: "<",
+            $lte: "<=",
+            $ne: "!="
+          };
+          const sqlOp = opMap[pOp];
+          if (!sqlOp)
+            throw new Error(`Unsupported where operator: ${pOp}`);
+          whereParts.push(`${fieldRef} ${sqlOp} ?`);
+          params.push(operand);
+        }
+      } else {
+        whereParts.push(`${fieldRef} = ?`);
+        params.push(value instanceof Date ? value.toISOString() : value);
       }
-      const otmKey = `${toTable}.${fromTable}:one-to-many`;
-      if (!added.has(otmKey)) {
-        relationships.push({
-          type: "one-to-many",
-          from: toTable,
-          to: fromTable,
-          relationshipField: fromTable,
-          foreignKey: ""
-        });
-        added.add(otmKey);
+    }
+    if (whereParts.length > 0) {
+      sql += ` WHERE ${whereParts.join(" AND ")}`;
+    }
+  }
+  if (queryResult.orderBy) {
+    const parts = [];
+    for (const [key, dir] of Object.entries(queryResult.orderBy)) {
+      let fieldRef;
+      const quotedMatch = key.match(/^"([^"]+)"\.\"([^"]+)"$/);
+      if (quotedMatch && tablesUsed.has(quotedMatch[1])) {
+        fieldRef = key;
+      } else {
+        fieldRef = qRef(primaryAlias.alias, key);
       }
+      parts.push(`${fieldRef} ${dir.toUpperCase()}`);
+    }
+    if (parts.length > 0) {
+      sql += ` ORDER BY ${parts.join(", ")}`;
     }
   }
-  return relationships;
+  if (queryResult.groupBy && queryResult.groupBy.length > 0) {
+    const parts = queryResult.groupBy.filter(Boolean).map((col) => qRef(col.alias, col.column));
+    sql += ` GROUP BY ${parts.join(", ")}`;
+  }
+  if (queryResult.limit !== undefined)
+    sql += ` LIMIT ${queryResult.limit}`;
+  if (queryResult.offset !== undefined)
+    sql += ` OFFSET ${queryResult.offset}`;
+  return { sql, params };
 }
-function getStorableFields(schema) {
-  return Object.entries(asZodObject(schema).shape).filter(([key]) => key !== "id").map(([name, type]) => ({ name, type }));
+function executeProxyQuery(schemas, callback, executor) {
+  const { proxy, aliasMap } = createContextProxy(schemas);
+  const queryResult = callback(proxy);
+  const { sql, params } = compileProxyQuery(queryResult, aliasMap);
+  return executor(sql, params);
 }
-function zodTypeToSqlType(zodType) {
-  if (zodType instanceof exports_external.ZodOptional) {
-    zodType = zodType._def.innerType;
-  }
-  if (zodType instanceof exports_external.ZodDefault) {
-    zodType = zodType._def.innerType;
-  }
-  if (zodType instanceof exports_external.ZodString || zodType instanceof exports_external.ZodDate)
-    return "TEXT";
-  if (zodType instanceof exports_external.ZodNumber || zodType instanceof exports_external.ZodBoolean)
-    return "INTEGER";
-  if (zodType._def.typeName === "ZodInstanceOf" && zodType._def.type === Buffer)
-    return "BLOB";
-  return "TEXT";
+function createQueryBuilder(ctx, entityName, initialCols) {
+  const schema = ctx.schemas[entityName];
+  const executor = (sql, params, raw) => {
+    const rows = ctx.db.query(sql).all(...params);
+    if (raw)
+      return rows;
+    return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, schema)));
+  };
+  const singleExecutor = (sql, params, raw) => {
+    const results = executor(sql, params, raw);
+    return results.length > 0 ? results[0] : null;
+  };
+  const joinResolver = (fromTable, toTable) => {
+    const belongsTo = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === fromTable && r.to === toTable);
+    if (belongsTo)
+      return { fk: belongsTo.foreignKey, pk: "id" };
+    const reverse = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === toTable && r.to === fromTable);
+    if (reverse)
+      return { fk: "id", pk: reverse.foreignKey };
+    return null;
+  };
+  const conditionResolver = (conditions) => {
+    const resolved = {};
+    for (const [key, value] of Object.entries(conditions)) {
+      if (value && typeof value === "object" && typeof value.id === "number" && typeof value.delete === "function") {
+        const fkCol = key + "_id";
+        const rel = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.foreignKey === fkCol);
+        if (rel) {
+          resolved[fkCol] = value.id;
+        } else {
+          const relByNav = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.to === key + "s") || ctx.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.to === key);
+          if (relByNav) {
+            resolved[relByNav.foreignKey] = value.id;
+          } else {
+            resolved[key] = value;
+          }
+        }
+      } else {
+        resolved[key] = value;
+      }
+    }
+    return resolved;
+  };
+  const eagerLoader = (parentTable, relation, parentIds) => {
+    const hasMany = ctx.relationships.find((r) => r.type === "one-to-many" && r.from === parentTable && r.relationshipField === relation);
+    if (hasMany) {
+      const belongsTo2 = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === hasMany.to && r.to === parentTable);
+      if (belongsTo2) {
+        const fk = belongsTo2.foreignKey;
+        const placeholders = parentIds.map(() => "?").join(", ");
+        const childRows = ctx.db.query(`SELECT * FROM ${hasMany.to} WHERE ${fk} IN (${placeholders})`).all(...parentIds);
+        const groups = new Map;
+        const childSchema = ctx.schemas[hasMany.to];
+        for (const rawRow of childRows) {
+          const entity = ctx.attachMethods(hasMany.to, transformFromStorage(rawRow, childSchema));
+          const parentId = rawRow[fk];
+          if (!groups.has(parentId))
+            groups.set(parentId, []);
+          groups.get(parentId).push(entity);
+        }
+        return { key: relation, groups };
+      }
+    }
+    const belongsTo = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === parentTable && r.relationshipField === relation);
+    if (belongsTo) {
+      return null;
+    }
+    return null;
+  };
+  const builder = new QueryBuilder(entityName, executor, singleExecutor, joinResolver, conditionResolver, eagerLoader);
+  if (initialCols.length > 0)
+    builder.select(...initialCols);
+  return builder;
 }
-function transformForStorage(data) {
-  const transformed = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (value instanceof Date) {
-      transformed[key] = value.toISOString();
-    } else if (typeof value === "boolean") {
-      transformed[key] = value ? 1 : 0;
+
+// src/helpers.ts
+function buildWhereClause(conditions, tablePrefix) {
+  const parts = [];
+  const values = [];
+  for (const key in conditions) {
+    if (key.startsWith("$")) {
+      if (key === "$or" && Array.isArray(conditions[key])) {
+        const orBranches = conditions[key];
+        const orParts = [];
+        for (const branch of orBranches) {
+          const sub = buildWhereClause(branch, tablePrefix);
+          if (sub.clause) {
+            orParts.push(`(${sub.clause.replace(/^WHERE /, "")})`);
+            values.push(...sub.values);
+          }
+        }
+        if (orParts.length > 0)
+          parts.push(`(${orParts.join(" OR ")})`);
+      }
+      continue;
+    }
+    const value = conditions[key];
+    const fieldName = tablePrefix ? `"${tablePrefix}"."${key}"` : `"${key}"`;
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+      const operator = Object.keys(value)[0];
+      if (!operator?.startsWith("$")) {
+        throw new Error(`Querying on nested object '${key}' not supported. Use operators like $gt.`);
+      }
+      const operand = value[operator];
+      if (operator === "$in") {
+        if (!Array.isArray(operand))
+          throw new Error(`$in for '${key}' requires an array`);
+        if (operand.length === 0) {
+          parts.push("1 = 0");
+          continue;
+        }
+        parts.push(`${fieldName} IN (${operand.map(() => "?").join(", ")})`);
+        values.push(...operand.map((v) => transformForStorage({ v }).v));
+        continue;
+      }
+      if (operator === "$notIn") {
+        if (!Array.isArray(operand))
+          throw new Error(`$notIn for '${key}' requires an array`);
+        if (operand.length === 0)
+          continue;
+        parts.push(`${fieldName} NOT IN (${operand.map(() => "?").join(", ")})`);
+        values.push(...operand.map((v) => transformForStorage({ v }).v));
+        continue;
+      }
+      if (operator === "$like") {
+        parts.push(`${fieldName} LIKE ?`);
+        values.push(operand);
+        continue;
+      }
+      if (operator === "$between") {
+        if (!Array.isArray(operand) || operand.length !== 2)
+          throw new Error(`$between for '${key}' requires [min, max]`);
+        parts.push(`${fieldName} BETWEEN ? AND ?`);
+        values.push(transformForStorage({ v: operand[0] }).v, transformForStorage({ v: operand[1] }).v);
+        continue;
+      }
+      const sqlOp = { $gt: ">", $gte: ">=", $lt: "<", $lte: "<=", $ne: "!=" }[operator];
+      if (!sqlOp)
+        throw new Error(`Unsupported operator '${operator}' on '${key}'`);
+      parts.push(`${fieldName} ${sqlOp} ?`);
+      values.push(transformForStorage({ operand }).operand);
     } else {
-      transformed[key] = value;
+      parts.push(`${fieldName} = ?`);
+      values.push(transformForStorage({ value }).value);
     }
   }
-  return transformed;
+  return { clause: parts.length > 0 ? `WHERE ${parts.join(" AND ")}` : "", values };
 }
-function transformFromStorage(row, schema) {
-  const transformed = {};
-  for (const [key, value] of Object.entries(row)) {
-    let fieldSchema = asZodObject(schema).shape[key];
-    if (fieldSchema instanceof exports_external.ZodOptional) {
-      fieldSchema = fieldSchema._def.innerType;
-    }
-    if (fieldSchema instanceof exports_external.ZodDefault) {
-      fieldSchema = fieldSchema._def.innerType;
-    }
-    if (fieldSchema instanceof exports_external.ZodDate && typeof value === "string") {
-      transformed[key] = new Date(value);
-    } else if (fieldSchema instanceof exports_external.ZodBoolean && typeof value === "number") {
-      transformed[key] = value === 1;
-    } else {
-      transformed[key] = value;
+
+// src/crud.ts
+function getById(ctx, entityName, id) {
+  const row = ctx.db.query(`SELECT * FROM "${entityName}" WHERE id = ?`).get(id);
+  if (!row)
+    return null;
+  return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]));
+}
+function getOne(ctx, entityName, conditions) {
+  const { clause, values } = ctx.buildWhereClause(conditions);
+  const row = ctx.db.query(`SELECT * FROM "${entityName}" ${clause} LIMIT 1`).get(...values);
+  if (!row)
+    return null;
+  return ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName]));
+}
+function findMany(ctx, entityName, conditions = {}) {
+  const { clause, values } = ctx.buildWhereClause(conditions);
+  const rows = ctx.db.query(`SELECT * FROM "${entityName}" ${clause}`).all(...values);
+  return rows.map((row) => ctx.attachMethods(entityName, transformFromStorage(row, ctx.schemas[entityName])));
+}
+function insert(ctx, entityName, data) {
+  const schema = ctx.schemas[entityName];
+  const validatedData = asZodObject(schema).passthrough().parse(data);
+  const transformed = transformForStorage(validatedData);
+  const columns = Object.keys(transformed);
+  const quotedCols = columns.map((c) => `"${c}"`);
+  const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+  const result = ctx.db.query(sql).run(...Object.values(transformed));
+  const newEntity = getById(ctx, entityName, result.lastInsertRowid);
+  if (!newEntity)
+    throw new Error("Failed to retrieve entity after insertion");
+  return newEntity;
+}
+function update(ctx, entityName, id, data) {
+  const schema = ctx.schemas[entityName];
+  const validatedData = asZodObject(schema).partial().parse(data);
+  const transformed = transformForStorage(validatedData);
+  if (Object.keys(transformed).length === 0)
+    return getById(ctx, entityName, id);
+  const setClause = Object.keys(transformed).map((key) => `"${key}" = ?`).join(", ");
+  ctx.db.query(`UPDATE "${entityName}" SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
+  return getById(ctx, entityName, id);
+}
+function updateWhere(ctx, entityName, data, conditions) {
+  const schema = ctx.schemas[entityName];
+  const validatedData = asZodObject(schema).partial().parse(data);
+  const transformed = transformForStorage(validatedData);
+  if (Object.keys(transformed).length === 0)
+    return 0;
+  const { clause, values: whereValues } = ctx.buildWhereClause(conditions);
+  if (!clause)
+    throw new Error("update().where() requires at least one condition");
+  const setCols = Object.keys(transformed);
+  const setClause = setCols.map((key) => `"${key}" = ?`).join(", ");
+  const result = ctx.db.query(`UPDATE "${entityName}" SET ${setClause} ${clause}`).run(...setCols.map((key) => transformed[key]), ...whereValues);
+  return result.changes ?? 0;
+}
+function createUpdateBuilder(ctx, entityName, data) {
+  let _conditions = {};
+  const builder = {
+    where: (conditions) => {
+      _conditions = { ..._conditions, ...conditions };
+      return builder;
+    },
+    exec: () => updateWhere(ctx, entityName, data, _conditions)
+  };
+  return builder;
+}
+function upsert(ctx, entityName, data, conditions = {}) {
+  const hasId = data?.id && typeof data.id === "number";
+  const existing = hasId ? getById(ctx, entityName, data.id) : Object.keys(conditions ?? {}).length > 0 ? getOne(ctx, entityName, conditions) : null;
+  if (existing) {
+    const updateData = { ...data };
+    delete updateData.id;
+    return update(ctx, entityName, existing.id, updateData);
+  }
+  const insertData = { ...conditions ?? {}, ...data ?? {} };
+  delete insertData.id;
+  return insert(ctx, entityName, insertData);
+}
+function deleteEntity(ctx, entityName, id) {
+  ctx.db.query(`DELETE FROM "${entityName}" WHERE id = ?`).run(id);
+}
+function insertMany(ctx, entityName, rows) {
+  if (rows.length === 0)
+    return [];
+  const schema = ctx.schemas[entityName];
+  const zodSchema = asZodObject(schema).passthrough();
+  const txn = ctx.db.transaction(() => {
+    const ids2 = [];
+    for (const data of rows) {
+      const validatedData = zodSchema.parse(data);
+      const transformed = transformForStorage(validatedData);
+      const columns = Object.keys(transformed);
+      const quotedCols = columns.map((c) => `"${c}"`);
+      const sql = columns.length === 0 ? `INSERT INTO "${entityName}" DEFAULT VALUES` : `INSERT INTO "${entityName}" (${quotedCols.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
+      const result = ctx.db.query(sql).run(...Object.values(transformed));
+      ids2.push(result.lastInsertRowid);
+    }
+    return ids2;
+  });
+  const ids = txn();
+  return ids.map((id) => getById(ctx, entityName, id)).filter(Boolean);
+}
+
+// src/entity.ts
+function attachMethods(ctx, entityName, entity) {
+  const augmented = entity;
+  augmented.update = (data) => update(ctx, entityName, entity.id, data);
+  augmented.delete = () => deleteEntity(ctx, entityName, entity.id);
+  for (const rel of ctx.relationships) {
+    if (rel.from === entityName && rel.type === "belongs-to") {
+      augmented[rel.relationshipField] = () => {
+        const fkValue = entity[rel.foreignKey];
+        return fkValue ? getById(ctx, rel.to, fkValue) : null;
+      };
+    } else if (rel.from === entityName && rel.type === "one-to-many") {
+      const belongsToRel = ctx.relationships.find((r) => r.type === "belongs-to" && r.from === rel.to && r.to === rel.from);
+      if (belongsToRel) {
+        const fk = belongsToRel.foreignKey;
+        augmented[rel.relationshipField] = () => {
+          return findMany(ctx, rel.to, { [fk]: entity.id });
+        };
+      }
     }
   }
-  return transformed;
+  const storableFieldNames = new Set(getStorableFields(ctx.schemas[entityName]).map((f) => f.name));
+  return new Proxy(augmented, {
+    set: (target, prop, value) => {
+      if (storableFieldNames.has(prop) && target[prop] !== value) {
+        update(ctx, entityName, target.id, { [prop]: value });
+      }
+      target[prop] = value;
+      return true;
+    },
+    get: (target, prop, receiver) => Reflect.get(target, prop, receiver)
+  });
 }
 
 // src/database.ts
 class _Database {
   db;
+  _reactive;
   schemas;
   relationships;
   options;
-  pollInterval;
-  _revisions = {};
+  _ctx;
+  _listeners = [];
+  _changeWatermark = 0;
+  _pollTimer = null;
+  _pollInterval;
   constructor(dbFile, schemas, options = {}) {
     this.db = new SqliteDatabase(dbFile);
     this.db.run("PRAGMA journal_mode = WAL");
     this.db.run("PRAGMA foreign_keys = ON");
     this.schemas = schemas;
     this.options = options;
-    this.pollInterval = options.pollInterval ?? 500;
+    this._reactive = options.reactive !== false;
+    this._pollInterval = options.pollInterval ?? 100;
     this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
+    this._ctx = {
+      db: this.db,
+      schemas: this.schemas,
+      relationships: this.relationships,
+      attachMethods: (name, entity) => attachMethods(this._ctx, name, entity),
+      buildWhereClause: (conds, prefix) => buildWhereClause(conds, prefix)
+    };
     this.initializeTables();
+    if (this._reactive)
+      this.initializeChangeTracking();
     this.runMigrations();
     if (options.indexes)
       this.createIndexes(options.indexes);
     for (const entityName of Object.keys(schemas)) {
       const key = entityName;
       const accessor = {
-        insert: (data) => this.insert(entityName, data),
+        insert: (data) => insert(this._ctx, entityName, data),
+        insertMany: (rows) => insertMany(this._ctx, entityName, rows),
         update: (idOrData, data) => {
           if (typeof idOrData === "number")
-            return this.update(entityName, idOrData, data);
-          return this._createUpdateBuilder(entityName, idOrData);
+            return update(this._ctx, entityName, idOrData, data);
+          return createUpdateBuilder(this._ctx, entityName, idOrData);
+        },
+        upsert: (conditions, data) => upsert(this._ctx, entityName, data, conditions),
+        delete: (id) => deleteEntity(this._ctx, entityName, id),
+        select: (...cols) => createQueryBuilder(this._ctx, entityName, cols),
+        on: (event, callback) => {
+          return this._registerListener(entityName, event, callback);
         },
-        upsert: (conditions, data) => this.upsert(entityName, data, conditions),
-        delete: (id) => this.delete(entityName, id),
-        select: (...cols) => this._createQueryBuilder(entityName, cols),
         _tableName: entityName
       };
       this[key] = accessor;
@@ -4771,26 +4978,53 @@ class _Database {
   initializeTables() {
     for (const [entityName, schema] of Object.entries(this.schemas)) {
       const storableFields = getStorableFields(schema);
-      const columnDefs = storableFields.map((f) => `${f.name} ${zodTypeToSqlType(f.type)}`);
+      const columnDefs = storableFields.map((f) => `"${f.name}" ${zodTypeToSqlType(f.type)}`);
       const constraints = [];
       const belongsToRels = this.relationships.filter((rel) => rel.type === "belongs-to" && rel.from === entityName);
       for (const rel of belongsToRels) {
-        constraints.push(`FOREIGN KEY (${rel.foreignKey}) REFERENCES ${rel.to}(id) ON DELETE SET NULL`);
+        constraints.push(`FOREIGN KEY ("${rel.foreignKey}") REFERENCES "${rel.to}"(id) ON DELETE SET NULL`);
       }
       const allCols = columnDefs.join(", ");
       const allConstraints = constraints.length > 0 ? ", " + constraints.join(", ") : "";
-      this.db.run(`CREATE TABLE IF NOT EXISTS ${entityName} (id INTEGER PRIMARY KEY AUTOINCREMENT, ${allCols}${allConstraints})`);
-    }
+      this.db.run(`CREATE TABLE IF NOT EXISTS "${entityName}" (id INTEGER PRIMARY KEY AUTOINCREMENT, ${allCols}${allConstraints})`);
+    }
+  }
+  initializeChangeTracking() {
+    this.db.run(`CREATE TABLE IF NOT EXISTS "_changes" (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            tbl TEXT NOT NULL,
+            op TEXT NOT NULL,
+            row_id INTEGER NOT NULL
+        )`);
+    for (const entityName of Object.keys(this.schemas)) {
+      this.db.run(`CREATE TRIGGER IF NOT EXISTS "_trg_${entityName}_insert"
+                AFTER INSERT ON "${entityName}"
+                BEGIN
+                    INSERT INTO "_changes" (tbl, op, row_id) VALUES ('${entityName}', 'insert', NEW.id);
+                END`);
+      this.db.run(`CREATE TRIGGER IF NOT EXISTS "_trg_${entityName}_update"
+                AFTER UPDATE ON "${entityName}"
+                BEGIN
+                    INSERT INTO "_changes" (tbl, op, row_id) VALUES ('${entityName}', 'update', NEW.id);
+                END`);
+      this.db.run(`CREATE TRIGGER IF NOT EXISTS "_trg_${entityName}_delete"
+                AFTER DELETE ON "${entityName}"
+                BEGIN
+                    INSERT INTO "_changes" (tbl, op, row_id) VALUES ('${entityName}', 'delete', OLD.id);
+                END`);
+    }
+    const row = this.db.query('SELECT MAX(id) as maxId FROM "_changes"').get();
+    this._changeWatermark = row?.maxId ?? 0;
   }
   runMigrations() {
     for (const [entityName, schema] of Object.entries(this.schemas)) {
-      const existingColumns = this.db.query(`PRAGMA table_info(${entityName})`).all();
+      const existingColumns = this.db.query(`PRAGMA table_info("${entityName}")`).all();
       const existingNames = new Set(existingColumns.map((c) => c.name));
       const storableFields = getStorableFields(schema);
       for (const field of storableFields) {
         if (!existingNames.has(field.name)) {
           const sqlType = zodTypeToSqlType(field.type);
-          this.db.run(`ALTER TABLE ${entityName} ADD COLUMN ${field.name} ${sqlType}`);
+          this.db.run(`ALTER TABLE "${entityName}" ADD COLUMN "${field.name}" ${sqlType}`);
         }
       }
     }
@@ -4800,277 +5034,73 @@ class _Database {
       for (const def of indexDefs) {
         const cols = Array.isArray(def) ? def : [def];
         const idxName = `idx_${tableName}_${cols.join("_")}`;
-        this.db.run(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${tableName} (${cols.join(", ")})`);
+        this.db.run(`CREATE INDEX IF NOT EXISTS "${idxName}" ON "${tableName}" (${cols.map((c) => `"${c}"`).join(", ")})`);
       }
     }
   }
-  _bumpRevision(entityName) {
-    this._revisions[entityName] = (this._revisions[entityName] ?? 0) + 1;
-  }
-  _getRevision(entityName) {
-    const rev = this._revisions[entityName] ?? 0;
-    const dataVersion = this.db.query("PRAGMA data_version").get()?.data_version ?? 0;
-    return `${rev}:${dataVersion}`;
-  }
-  insert(entityName, data) {
-    const schema = this.schemas[entityName];
-    const validatedData = asZodObject(schema).passthrough().parse(data);
-    const transformed = transformForStorage(validatedData);
-    const columns = Object.keys(transformed);
-    const sql = columns.length === 0 ? `INSERT INTO ${entityName} DEFAULT VALUES` : `INSERT INTO ${entityName} (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`;
-    const result = this.db.query(sql).run(...Object.values(transformed));
-    const newEntity = this._getById(entityName, result.lastInsertRowid);
-    if (!newEntity)
-      throw new Error("Failed to retrieve entity after insertion");
-    this._bumpRevision(entityName);
-    return newEntity;
-  }
-  _getById(entityName, id) {
-    const row = this.db.query(`SELECT * FROM ${entityName} WHERE id = ?`).get(id);
-    if (!row)
-      return null;
-    return this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName]));
-  }
-  _getOne(entityName, conditions) {
-    const { clause, values } = this.buildWhereClause(conditions);
-    const row = this.db.query(`SELECT * FROM ${entityName} ${clause} LIMIT 1`).get(...values);
-    if (!row)
-      return null;
-    return this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName]));
-  }
-  _findMany(entityName, conditions = {}) {
-    const { clause, values } = this.buildWhereClause(conditions);
-    const rows = this.db.query(`SELECT * FROM ${entityName} ${clause}`).all(...values);
-    return rows.map((row) => this._attachMethods(entityName, transformFromStorage(row, this.schemas[entityName])));
-  }
-  update(entityName, id, data) {
-    const schema = this.schemas[entityName];
-    const validatedData = asZodObject(schema).partial().parse(data);
-    const transformed = transformForStorage(validatedData);
-    if (Object.keys(transformed).length === 0)
-      return this._getById(entityName, id);
-    const setClause = Object.keys(transformed).map((key) => `${key} = ?`).join(", ");
-    this.db.query(`UPDATE ${entityName} SET ${setClause} WHERE id = ?`).run(...Object.values(transformed), id);
-    this._bumpRevision(entityName);
-    const updatedEntity = this._getById(entityName, id);
-    return updatedEntity;
-  }
-  _updateWhere(entityName, data, conditions) {
-    const schema = this.schemas[entityName];
-    const validatedData = asZodObject(schema).partial().parse(data);
-    const transformed = transformForStorage(validatedData);
-    if (Object.keys(transformed).length === 0)
-      return 0;
-    const { clause, values: whereValues } = this.buildWhereClause(conditions);
-    if (!clause)
-      throw new Error("update().where() requires at least one condition");
-    const setCols = Object.keys(transformed);
-    const setClause = setCols.map((key) => `${key} = ?`).join(", ");
-    const result = this.db.query(`UPDATE ${entityName} SET ${setClause} ${clause}`).run(...setCols.map((key) => transformed[key]), ...whereValues);
-    const affected = result.changes ?? 0;
-    if (affected > 0)
-      this._bumpRevision(entityName);
-    return affected;
-  }
-  _createUpdateBuilder(entityName, data) {
-    let _conditions = {};
-    const builder = {
-      where: (conditions) => {
-        _conditions = { ..._conditions, ...conditions };
-        return builder;
-      },
-      exec: () => this._updateWhere(entityName, data, _conditions)
+  _registerListener(table, event, callback) {
+    if (!this._reactive) {
+      throw new Error("Change listeners are disabled. Set { reactive: true } (or omit it) in Database options to enable .on().");
+    }
+    const listener = { table, event, callback };
+    this._listeners.push(listener);
+    this._startPolling();
+    return () => {
+      const idx = this._listeners.indexOf(listener);
+      if (idx >= 0)
+        this._listeners.splice(idx, 1);
+      if (this._listeners.length === 0)
+        this._stopPolling();
     };
-    return builder;
-  }
-  upsert(entityName, data, conditions = {}) {
-    const hasId = data?.id && typeof data.id === "number";
-    const existing = hasId ? this._getById(entityName, data.id) : Object.keys(conditions ?? {}).length > 0 ? this._getOne(entityName, conditions) : null;
-    if (existing) {
-      const updateData = { ...data };
-      delete updateData.id;
-      return this.update(entityName, existing.id, updateData);
-    }
-    const insertData = { ...conditions ?? {}, ...data ?? {} };
-    delete insertData.id;
-    return this.insert(entityName, insertData);
-  }
-  delete(entityName, id) {
-    const entity = this._getById(entityName, id);
-    if (entity) {
-      this.db.query(`DELETE FROM ${entityName} WHERE id = ?`).run(id);
-      this._bumpRevision(entityName);
-    }
-  }
-  _attachMethods(entityName, entity) {
-    const augmented = entity;
-    augmented.update = (data) => this.update(entityName, entity.id, data);
-    augmented.delete = () => this.delete(entityName, entity.id);
-    for (const rel of this.relationships) {
-      if (rel.from === entityName && rel.type === "belongs-to") {
-        augmented[rel.relationshipField] = () => {
-          const fkValue = entity[rel.foreignKey];
-          return fkValue ? this._getById(rel.to, fkValue) : null;
-        };
-      } else if (rel.from === entityName && rel.type === "one-to-many") {
-        const belongsToRel = this.relationships.find((r) => r.type === "belongs-to" && r.from === rel.to && r.to === rel.from);
-        if (belongsToRel) {
-          const fk = belongsToRel.foreignKey;
-          augmented[rel.relationshipField] = () => {
-            return this._findMany(rel.to, { [fk]: entity.id });
-          };
-        }
-      }
+  }
+  _startPolling() {
+    if (this._pollTimer)
+      return;
+    this._pollTimer = setInterval(() => this._processChanges(), this._pollInterval);
+  }
+  _stopPolling() {
+    if (this._pollTimer) {
+      clearInterval(this._pollTimer);
+      this._pollTimer = null;
     }
-    const storableFieldNames = new Set(getStorableFields(this.schemas[entityName]).map((f) => f.name));
-    return new Proxy(augmented, {
-      set: (target, prop, value) => {
-        if (storableFieldNames.has(prop) && target[prop] !== value) {
-          this.update(entityName, target.id, { [prop]: value });
-        }
-        target[prop] = value;
-        return true;
-      },
-      get: (target, prop, receiver) => Reflect.get(target, prop, receiver)
-    });
   }
-  buildWhereClause(conditions, tablePrefix) {
-    const parts = [];
-    const values = [];
-    for (const key in conditions) {
-      if (key.startsWith("$")) {
-        if (key === "$or" && Array.isArray(conditions[key])) {
-          const orBranches = conditions[key];
-          const orParts = [];
-          for (const branch of orBranches) {
-            const sub = this.buildWhereClause(branch, tablePrefix);
-            if (sub.clause) {
-              orParts.push(`(${sub.clause.replace(/^WHERE /, "")})`);
-              values.push(...sub.values);
-            }
+  _processChanges() {
+    const head = this.db.query('SELECT MAX(id) as m FROM "_changes"').get();
+    const maxId = head?.m ?? 0;
+    if (maxId <= this._changeWatermark)
+      return;
+    const changes = this.db.query('SELECT id, tbl, op, row_id FROM "_changes" WHERE id > ? ORDER BY id').all(this._changeWatermark);
+    for (const change of changes) {
+      const listeners = this._listeners.filter((l) => l.table === change.tbl && l.event === change.op);
+      if (listeners.length > 0) {
+        if (change.op === "delete") {
+          const payload = { id: change.row_id };
+          for (const l of listeners) {
+            try {
+              l.callback(payload);
+            } catch {}
           }
-          if (orParts.length > 0)
-            parts.push(`(${orParts.join(" OR ")})`);
-        }
-        continue;
-      }
-      const value = conditions[key];
-      const fieldName = tablePrefix ? `${tablePrefix}.${key}` : key;
-      if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
-        const operator = Object.keys(value)[0];
-        if (!operator?.startsWith("$")) {
-          throw new Error(`Querying on nested object '${key}' not supported. Use operators like $gt.`);
-        }
-        const operand = value[operator];
-        if (operator === "$in") {
-          if (!Array.isArray(operand))
-            throw new Error(`$in for '${key}' requires an array`);
-          if (operand.length === 0) {
-            parts.push("1 = 0");
-            continue;
+        } else {
+          const row = getById(this._ctx, change.tbl, change.row_id);
+          if (row) {
+            for (const l of listeners) {
+              try {
+                l.callback(row);
+              } catch {}
+            }
           }
-          parts.push(`${fieldName} IN (${operand.map(() => "?").join(", ")})`);
-          values.push(...operand.map((v) => transformForStorage({ v }).v));
-          continue;
         }
-        const sqlOp = { $gt: ">", $gte: ">=", $lt: "<", $lte: "<=", $ne: "!=" }[operator];
-        if (!sqlOp)
-          throw new Error(`Unsupported operator '${operator}' on '${key}'`);
-        parts.push(`${fieldName} ${sqlOp} ?`);
-        values.push(transformForStorage({ operand }).operand);
-      } else {
-        parts.push(`${fieldName} = ?`);
-        values.push(transformForStorage({ value }).value);
       }
+      this._changeWatermark = change.id;
     }
-    return { clause: parts.length > 0 ? `WHERE ${parts.join(" AND ")}` : "", values };
+    this.db.run('DELETE FROM "_changes" WHERE id <= ?', this._changeWatermark);
   }
   transaction(callback) {
-    try {
-      this.db.run("BEGIN TRANSACTION");
-      const result = callback();
-      this.db.run("COMMIT");
-      return result;
-    } catch (error) {
-      this.db.run("ROLLBACK");
-      throw new Error(`Transaction failed: ${error.message}`);
-    }
-  }
-  _createQueryBuilder(entityName, initialCols) {
-    const schema = this.schemas[entityName];
-    const executor = (sql, params, raw) => {
-      const rows = this.db.query(sql).all(...params);
-      if (raw)
-        return rows;
-      return rows.map((row) => this._attachMethods(entityName, transformFromStorage(row, schema)));
-    };
-    const singleExecutor = (sql, params, raw) => {
-      const results = executor(sql, params, raw);
-      return results.length > 0 ? results[0] : null;
-    };
-    const joinResolver = (fromTable, toTable) => {
-      const belongsTo = this.relationships.find((r) => r.type === "belongs-to" && r.from === fromTable && r.to === toTable);
-      if (belongsTo)
-        return { fk: belongsTo.foreignKey, pk: "id" };
-      const reverse = this.relationships.find((r) => r.type === "belongs-to" && r.from === toTable && r.to === fromTable);
-      if (reverse)
-        return { fk: "id", pk: reverse.foreignKey };
-      return null;
-    };
-    const revisionGetter = () => this._getRevision(entityName);
-    const conditionResolver = (conditions) => {
-      const resolved = {};
-      for (const [key, value] of Object.entries(conditions)) {
-        if (value && typeof value === "object" && typeof value.id === "number" && typeof value.delete === "function") {
-          const fkCol = key + "_id";
-          const rel = this.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.foreignKey === fkCol);
-          if (rel) {
-            resolved[fkCol] = value.id;
-          } else {
-            const relByNav = this.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.to === key + "s") || this.relationships.find((r) => r.type === "belongs-to" && r.from === entityName && r.to === key);
-            if (relByNav) {
-              resolved[relByNav.foreignKey] = value.id;
-            } else {
-              resolved[key] = value;
-            }
-          }
-        } else {
-          resolved[key] = value;
-        }
-      }
-      return resolved;
-    };
-    const eagerLoader = (parentTable, relation, parentIds) => {
-      const hasMany = this.relationships.find((r) => r.type === "one-to-many" && r.from === parentTable && r.relationshipField === relation);
-      if (hasMany) {
-        const belongsTo2 = this.relationships.find((r) => r.type === "belongs-to" && r.from === hasMany.to && r.to === parentTable);
-        if (belongsTo2) {
-          const fk = belongsTo2.foreignKey;
-          const placeholders = parentIds.map(() => "?").join(", ");
-          const childRows = this.db.query(`SELECT * FROM ${hasMany.to} WHERE ${fk} IN (${placeholders})`).all(...parentIds);
-          const groups = new Map;
-          const childSchema = this.schemas[hasMany.to];
-          for (const rawRow of childRows) {
-            const entity = this._attachMethods(hasMany.to, transformFromStorage(rawRow, childSchema));
-            const parentId = rawRow[fk];
-            if (!groups.has(parentId))
-              groups.set(parentId, []);
-            groups.get(parentId).push(entity);
-          }
-          return { key: relation, groups };
-        }
-      }
-      const belongsTo = this.relationships.find((r) => r.type === "belongs-to" && r.from === parentTable && r.relationshipField === relation);
-      if (belongsTo) {
-        const fkValues = [...new Set(parentIds)];
-        return null;
-      }
-      return null;
-    };
-    const builder = new QueryBuilder(entityName, executor, singleExecutor, joinResolver, conditionResolver, revisionGetter, eagerLoader, this.pollInterval);
-    if (initialCols.length > 0)
-      builder.select(...initialCols);
-    return builder;
+    return this.db.transaction(callback)();
+  }
+  close() {
+    this._stopPolling();
+    this.db.close();
   }
   query(callback) {
     return executeProxyQuery(this.schemas, callback, (sql, params) => this.db.query(sql).all(...params));
@@ -5083,6 +5113,7 @@ export {
   op,
   createFunctionProxy,
   createColumnProxy,
+  compileIQO,
   compileAST,
   QueryBuilder,
   Database,