prisma-guard 1.1.0 → 1.2.0

package/dist/runtime/index.js

@@ -26,6 +26,12 @@ var CallerError = class extends Error {
     this.name = "CallerError";
   }
 };
+function formatZodError(err) {
+  return err.issues.map((i) => {
+    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+    return `${p}${i.message}`;
+  }).join("; ");
+}
 
 // src/runtime/schema-builder.ts
 import { z as z3 } from "zod";
@@ -36,9 +42,15 @@ import { z as z2 } from "zod";
 // src/shared/scalar-base.ts
 import { z } from "zod";
 function isJsonSafe(value) {
-  const stack = [value];
+  const stack = [{ tag: "visit", value }];
+  const ancestors = /* @__PURE__ */ new Set();
   while (stack.length > 0) {
-    const current = stack.pop();
+    const entry = stack.pop();
+    if (entry.tag === "exit") {
+      ancestors.delete(entry.ref);
+      continue;
+    }
+    const current = entry.value;
     if (current === void 0)
       return false;
     if (current === null)
@@ -52,9 +64,13 @@ function isJsonSafe(value) {
           return false;
         continue;
       case "object": {
+        if (ancestors.has(current))
+          return false;
+        ancestors.add(current);
+        stack.push({ tag: "exit", ref: current });
         if (Array.isArray(current)) {
           for (let i = 0; i < current.length; i++) {
-            stack.push(current[i]);
+            stack.push({ tag: "visit", value: current[i] });
           }
           continue;
         }
@@ -63,7 +79,7 @@ function isJsonSafe(value) {
           return false;
         const values = Object.values(current);
         for (let i = 0; i < values.length; i++) {
-          stack.push(values[i]);
+          stack.push({ tag: "visit", value: values[i] });
         }
         continue;
       }
@@ -82,6 +98,10 @@ var SCALAR_BASE = {
     z.string().refine(
       (s) => /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/.test(s),
       "Invalid decimal string"
+    ),
+    z.custom(
+      (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
+      "Expected Decimal-compatible object"
     )
   ]),
   BigInt: () => z.union([
@@ -98,7 +118,7 @@ var SCALAR_BASE = {
     z.string().datetime({ offset: true }),
     z.string().datetime()
   ]).pipe(z.coerce.date()),
-  Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, or Infinity)"),
+  Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"),
   Bytes: () => z.union([
     z.string(),
     z.custom((v) => v instanceof Uint8Array)
@@ -238,6 +258,12 @@ function lruSet(cache, key, value, maxSize) {
       cache.delete(oldest);
   }
 }
+function isZodSchema(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.parse === "function" && typeof v.optional === "function";
+}
 function createSchemaBuilder(typeMap, zodChains, enumMap) {
   const chainCache = /* @__PURE__ */ new Map();
   function buildFieldSchema(model, field) {
@@ -281,7 +307,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
       throw new ShapeError('InputOpts cannot define both "pick" and "omit"');
     }
     const mode = opts.mode ?? "create";
-    const allowNull = opts.allowNull ?? false;
+    const allowNull = opts.allowNull ?? true;
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
@@ -311,7 +337,21 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
       const fieldMeta = modelFields[name];
       let fieldSchema;
       if (opts.refine?.[name]) {
-        fieldSchema = opts.refine[name](buildBaseFieldSchema(model, name));
+        let refined;
+        try {
+          refined = opts.refine[name](buildBaseFieldSchema(model, name));
+        } catch (err) {
+          throw new ShapeError(
+            `Refine function for "${model}.${name}" threw: ${err.message}`,
+            { cause: err }
+          );
+        }
+        if (!isZodSchema(refined)) {
+          throw new ShapeError(
+            `Refine function for "${model}.${name}" must return a Zod schema`
+          );
+        }
+        fieldSchema = refined;
       } else {
         fieldSchema = buildFieldSchema(model, name);
       }
@@ -410,10 +450,12 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
       schemaMap[relName] = relSchema;
     }
     if (opts._count) {
-      const relationNames = Object.keys(modelFields).filter((n) => modelFields[n].isRelation);
+      const listRelationNames = Object.keys(modelFields).filter(
+        (n) => modelFields[n].isRelation && modelFields[n].isList
+      );
       if (opts._count === true) {
         const countFields = {};
-        for (const relName of relationNames) {
+        for (const relName of listRelationNames) {
           countFields[relName] = z3.number().int().min(0);
         }
         schemaMap["_count"] = z3.object(countFields);
@@ -424,6 +466,8 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
             throw new ShapeError(`Unknown field "${relName}" on model "${model}" in _count`);
           if (!modelFields[relName].isRelation)
             throw new ShapeError(`Field "${relName}" is not a relation on model "${model}" in _count`);
+          if (!modelFields[relName].isList)
+            throw new ShapeError(`Field "${relName}" is a to-one relation on model "${model}" in _count. Only to-many relations support _count.`);
           countFields[relName] = z3.number().int().min(0);
         }
         schemaMap["_count"] = z3.object(countFields);
@@ -439,7 +483,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
 }
 
 // src/runtime/query-builder.ts
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 
 // src/shared/constants.ts
 var SHAPE_CONFIG_KEYS = /* @__PURE__ */ new Set([
@@ -463,6 +507,13 @@ var GUARD_SHAPE_KEYS = /* @__PURE__ */ new Set([
   "data",
   ...SHAPE_CONFIG_KEYS
 ]);
+var COMBINATOR_KEYS = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+var TO_MANY_RELATION_OPS = /* @__PURE__ */ new Set(["some", "every", "none"]);
+var TO_ONE_RELATION_OPS = /* @__PURE__ */ new Set(["is", "isNot"]);
+var ALL_RELATION_OPS = /* @__PURE__ */ new Set([...TO_MANY_RELATION_OPS, ...TO_ONE_RELATION_OPS]);
+function toDelegateKey(modelName) {
+  return modelName[0].toLowerCase() + modelName.slice(1);
+}
 
 // src/shared/match-caller.ts
 function matchCallerPattern(patterns, caller) {
@@ -498,130 +549,107 @@ function matchCallerPattern(patterns, caller) {
   return matches[0];
 }
 
+// src/shared/is-plain-object.ts
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
 // src/runtime/policy.ts
 function requireContext(ctx, label) {
   if (ctx === void 0 || ctx === null) {
     throw new PolicyError(`Context required for ${label}`);
   }
 }
+function validateContext(ctx) {
+  if (ctx === null || ctx === void 0) {
+    throw new PolicyError(
+      `guard.extension() context function must return a plain object, got ${String(ctx)}`
+    );
+  }
+  if (!isPlainObject(ctx)) {
+    throw new PolicyError(
+      `guard.extension() context function must return a plain object, got ${Array.isArray(ctx) ? "array" : typeof ctx}`
+    );
+  }
+  return ctx;
+}
 
-// src/runtime/query-builder.ts
-var METHOD_ALLOWED_ARGS = {
-  findMany: /* @__PURE__ */ new Set([
-    "where",
-    "include",
-    "select",
-    "orderBy",
-    "cursor",
-    "take",
-    "skip",
-    "distinct"
-  ]),
-  findFirst: /* @__PURE__ */ new Set([
-    "where",
-    "include",
-    "select",
-    "orderBy",
-    "cursor",
-    "take",
-    "skip",
-    "distinct"
-  ]),
-  findFirstOrThrow: /* @__PURE__ */ new Set([
-    "where",
-    "include",
-    "select",
-    "orderBy",
-    "cursor",
-    "take",
-    "skip",
-    "distinct"
-  ]),
-  findUnique: /* @__PURE__ */ new Set(["where", "include", "select"]),
-  findUniqueOrThrow: /* @__PURE__ */ new Set(["where", "include", "select"]),
-  count: /* @__PURE__ */ new Set(["where", "select", "cursor", "orderBy", "skip", "take"]),
-  aggregate: /* @__PURE__ */ new Set([
-    "where",
-    "orderBy",
-    "cursor",
-    "take",
-    "skip",
-    "_count",
-    "_avg",
-    "_sum",
-    "_min",
-    "_max"
-  ]),
-  groupBy: /* @__PURE__ */ new Set([
-    "where",
-    "by",
-    "having",
-    "_count",
-    "_avg",
-    "_sum",
-    "_min",
-    "_max",
-    "orderBy",
-    "take",
-    "skip"
-  ])
-};
-var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set([
-  "findUnique",
-  "findUniqueOrThrow"
-]);
-var STRING_MODE_OPS = /* @__PURE__ */ new Set([
-  "contains",
-  "startsWith",
-  "endsWith",
-  "equals"
-]);
-var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
-var UNSUPPORTED_BY_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
-var KNOWN_NESTED_INCLUDE_KEYS = /* @__PURE__ */ new Set([
-  "where",
-  "include",
-  "select",
-  "orderBy",
-  "cursor",
-  "take",
-  "skip"
-]);
-var KNOWN_NESTED_SELECT_KEYS = /* @__PURE__ */ new Set([
-  "select",
-  "where",
-  "orderBy",
-  "cursor",
-  "take",
-  "skip"
-]);
-var KNOWN_COUNT_SELECT_ENTRY_KEYS = /* @__PURE__ */ new Set(["where"]);
-function isPlainObject(v) {
-  if (typeof v !== "object" || v === null || Array.isArray(v))
-    return false;
-  const proto = Object.getPrototypeOf(v);
-  return proto === Object.prototype || proto === null;
+// src/runtime/query-builder-where.ts
+import { z as z4 } from "zod";
+
+// src/runtime/query-builder-forced.ts
+var EMPTY_WHERE_FORCED = { conditions: {}, relations: {} };
+function hasWhereForced(f) {
+  return Object.keys(f.conditions).length > 0 || Object.keys(f.relations).length > 0;
 }
-function mergeForced(where, forced) {
-  if (!where)
-    return forced;
-  return { AND: [where, forced] };
+function mergeWhereForced(where, forced) {
+  if (!hasWhereForced(forced))
+    return where ?? {};
+  let result = where ? structuredClone(where) : {};
+  for (const [relName, opMap] of Object.entries(forced.relations)) {
+    if (!result[relName] || typeof result[relName] !== "object") {
+      result[relName] = {};
+    }
+    const relObj = result[relName];
+    for (const [op, nestedForced] of Object.entries(opMap)) {
+      relObj[op] = mergeWhereForced(
+        relObj[op],
+        nestedForced
+      );
+    }
+  }
+  if (Object.keys(forced.conditions).length > 0) {
+    const scalarClone = structuredClone(forced.conditions);
+    if (Object.keys(result).length === 0) {
+      result = scalarClone;
+    } else {
+      result = { AND: [result, scalarClone] };
+    }
+  }
+  return result;
 }
-function mergeUniqueForced(where, forced) {
-  if (!where)
-    return { ...forced };
-  return { ...where, AND: [forced] };
+function mergeUniqueWhereForced(where, forced) {
+  if (!hasWhereForced(forced))
+    return where ?? {};
+  let result = where ? { ...where } : {};
+  for (const [relName, opMap] of Object.entries(forced.relations)) {
+    if (!result[relName] || typeof result[relName] !== "object") {
+      result[relName] = {};
+    }
+    const relObj = result[relName];
+    for (const [op, nestedForced] of Object.entries(opMap)) {
+      relObj[op] = mergeWhereForced(
+        relObj[op],
+        nestedForced
+      );
+    }
+  }
+  if (Object.keys(forced.conditions).length > 0) {
+    const conditions = [structuredClone(forced.conditions)];
+    const existing = result.AND;
+    if (existing) {
+      if (Array.isArray(existing)) {
+        conditions.unshift(...existing);
+      } else {
+        conditions.unshift(existing);
+      }
+    }
+    result.AND = conditions;
+  }
+  return result;
 }
 function applyBuiltShape(built, body, isUniqueMethod) {
   const validated = built.zodSchema.parse(body);
-  if (Object.keys(built.forcedWhere).length > 0) {
-    const cloned = structuredClone(built.forcedWhere);
-    validated.where = isUniqueMethod ? mergeUniqueForced(
+  if (hasWhereForced(built.forcedWhere)) {
+    validated.where = isUniqueMethod ? mergeUniqueWhereForced(
       validated.where,
-      cloned
-    ) : mergeForced(
+      built.forcedWhere
+    ) : mergeWhereForced(
       validated.where,
-      cloned
+      built.forcedWhere
     );
   }
   if (Object.keys(built.forcedIncludeTree).length > 0) {
@@ -631,16 +659,14 @@ function applyBuiltShape(built, body, isUniqueMethod) {
     applyForcedTree(validated, "select", built.forcedSelectTree);
   }
   if (Object.keys(built.forcedIncludeCountWhere).length > 0) {
-    const includeContainer = validated.include;
-    if (includeContainer) {
-      applyForcedCountWhere(includeContainer, built.forcedIncludeCountWhere);
-    }
+    const ic = validated.include;
+    if (ic)
+      applyForcedCountWhere(ic, built.forcedIncludeCountWhere);
   }
   if (Object.keys(built.forcedSelectCountWhere).length > 0) {
-    const selectContainer = validated.select;
-    if (selectContainer) {
-      applyForcedCountWhere(selectContainer, built.forcedSelectCountWhere);
-    }
+    const sc = validated.select;
+    if (sc)
+      applyForcedCountWhere(sc, built.forcedSelectCountWhere);
   }
   return validated;
 }
@@ -654,8 +680,9 @@ function applyForcedTree(validated, key, tree) {
       continue;
     if (relVal === true) {
       const expanded = {};
-      if (forced.where)
-        expanded.where = structuredClone(forced.where);
+      if (forced.where && hasWhereForced(forced.where)) {
+        expanded.where = mergeWhereForced(void 0, forced.where);
+      }
       if (forced.include) {
         expanded.include = buildForcedOnlyContainer(forced.include);
         applyForcedTree(expanded, "include", forced.include);
@@ -666,10 +693,8 @@ function applyForcedTree(validated, key, tree) {
       }
       if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
         const countSelect = {};
-        for (const [countRel, countForced] of Object.entries(
-          forced._countWhere
-        )) {
-          countSelect[countRel] = { where: structuredClone(countForced) };
+        for (const [countRel, countForced] of Object.entries(forced._countWhere)) {
+          countSelect[countRel] = { where: mergeWhereForced(void 0, countForced) };
         }
         expanded._count = { select: countSelect };
       }
@@ -683,10 +708,10 @@ function applyForcedTree(validated, key, tree) {
     }
     if (isPlainObject(relVal)) {
       const relObj = relVal;
-      if (forced.where) {
-        relObj.where = mergeForced(
+      if (forced.where && hasWhereForced(forced.where)) {
+        relObj.where = mergeWhereForced(
           relObj.where,
-          structuredClone(forced.where)
+          forced.where
         );
       }
       if (forced.include) {
@@ -714,18 +739,17 @@ function buildForcedOnlyContainer(tree) {
   const result = {};
   for (const [relName, forced] of Object.entries(tree)) {
     const nested = {};
-    if (forced.where)
-      nested.where = structuredClone(forced.where);
+    if (forced.where && hasWhereForced(forced.where)) {
+      nested.where = mergeWhereForced(void 0, forced.where);
+    }
     if (forced.include)
       nested.include = buildForcedOnlyContainer(forced.include);
     if (forced.select)
       nested.select = buildForcedOnlyContainer(forced.select);
     if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
       const countSelect = {};
-      for (const [countRel, countForced] of Object.entries(
-        forced._countWhere
-      )) {
-        countSelect[countRel] = { where: structuredClone(countForced) };
+      for (const [countRel, countForced] of Object.entries(forced._countWhere)) {
+        countSelect[countRel] = { where: mergeWhereForced(void 0, countForced) };
       }
       nested._count = { select: countSelect };
     }
@@ -747,12 +771,12 @@ function applyForcedCountWhere(container, forcedCountWhere) {
     if (relVal === void 0)
       continue;
     if (relVal === true) {
-      selectObj[relName] = { where: structuredClone(forced) };
+      selectObj[relName] = { where: mergeWhereForced(void 0, forced) };
     } else if (isPlainObject(relVal)) {
       const relObj = relVal;
-      relObj.where = mergeForced(
+      relObj.where = mergeWhereForced(
         relObj.where,
-        structuredClone(forced)
+        forced
       );
     }
   }
@@ -789,17 +813,25 @@ function validateResolvedUniqueWhere(model, where, method, uniqueMap) {
     );
   }
 }
-function validateUniqueEquality(model, where, method, uniqueMap) {
+function validateUniqueEquality(model, where, method, uniqueMap, typeMap) {
   const constraints = uniqueMap[model];
   if (!constraints || constraints.length === 0)
     return;
-  const whereFields = new Set(Object.keys(where));
+  const combinators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const whereFields = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(where)) {
+    if (combinators.has(key))
+      continue;
+    if (typeMap && typeMap[model]?.[key]?.isRelation)
+      continue;
+    whereFields.add(key);
+  }
   const valid = constraints.some((constraint) => {
     if (!constraint.every((field) => whereFields.has(field)))
       return false;
     return constraint.every((field) => {
       const ops = where[field];
-      if (!ops)
+      if (!ops || !isPlainObject(ops))
         return false;
       return Object.keys(ops).every((op) => op === "equals");
     });
@@ -811,191 +843,440 @@ function validateUniqueEquality(model, where, method, uniqueMap) {
     );
   }
 }
-function validateNestedKeys(keys, allowed, context) {
-  for (const key of keys) {
-    if (!allowed.has(key)) {
+
+// src/runtime/query-builder-where.ts
+var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+var STRING_MODE_OPS = /* @__PURE__ */ new Set(["contains", "startsWith", "endsWith", "equals"]);
+function safeStringify(v) {
+  if (typeof v === "bigint")
+    return `${v}n`;
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function forcedValuesEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "bigint")
+    return a === b;
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b))
+      return false;
+    if (a.length !== b.length)
+      return false;
+    return a.every((v, i) => forcedValuesEqual(v, b[i]));
+  }
+  if (!isPlainObject(a) || !isPlainObject(b))
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  return aKeys.every((k) => k in b && forcedValuesEqual(a[k], b[k]));
+}
+function mergeScalarConditions(target, source) {
+  for (const [field, ops] of Object.entries(source)) {
+    const existing = target[field];
+    if (existing === void 0) {
+      target[field] = ops;
+      continue;
+    }
+    if (field === "NOT") {
+      const existingArr = Array.isArray(existing) ? existing : [existing];
+      const sourceArr = Array.isArray(ops) ? ops : [ops];
+      target[field] = [...existingArr, ...sourceArr];
+      continue;
+    }
+    if (isPlainObject(existing) && isPlainObject(ops)) {
+      for (const [op, val] of Object.entries(ops)) {
+        if (op in existing) {
+          const existingVal = existing[op];
+          if (!forcedValuesEqual(existingVal, val)) {
+            throw new ShapeError(
+              `Conflicting forced where values for "${field}.${op}": shape defines both ${safeStringify(existingVal)} and ${safeStringify(val)}`
+            );
+          }
+        }
+      }
+      Object.assign(existing, ops);
+      continue;
+    }
+    if (!forcedValuesEqual(existing, ops)) {
       throw new ShapeError(
-        `Unknown key "${key}" in ${context}. Allowed: ${[...allowed].join(", ")}`
+        `Conflicting forced where values for "${field}"`
       );
     }
   }
 }
-function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
-  function isShapeConfig(obj) {
-    if (!isPlainObject(obj))
-      return false;
-    const keys = Object.keys(obj);
-    return keys.length === 0 || keys.every((k) => SHAPE_CONFIG_KEYS.has(k));
+function mergeRelationForcedMaps(target, source) {
+  for (const [relName, ops] of Object.entries(source)) {
+    if (!target[relName]) {
+      target[relName] = ops;
+      continue;
+    }
+    for (const [op, forced] of Object.entries(ops)) {
+      if (!target[relName][op]) {
+        target[relName][op] = forced;
+      } else {
+        mergeScalarConditions(target[relName][op].conditions, forced.conditions);
+        mergeRelationForcedMaps(target[relName][op].relations, forced.relations);
+      }
+    }
   }
+}
+function createWhereBuilder(typeMap, enumMap) {
   function buildWhereSchema(model, whereConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
     const fieldSchemas = {};
-    const forced = {};
-    for (const [fieldName, operators] of Object.entries(whereConfig)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}"`
+    const scalarConditions = {};
+    const relationForced = {};
+    for (const [key, value] of Object.entries(whereConfig)) {
+      if (COMBINATOR_KEYS.has(key)) {
+        processCombinator(
+          key,
+          value,
+          model,
+          fieldSchemas,
+          scalarConditions,
+          relationForced
         );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in where`
+        continue;
+      }
+      const fieldMeta = modelFields[key];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${key}" on model "${model}"`);
+      if (fieldMeta.isRelation) {
+        processRelationFilter(
+          key,
+          value,
+          fieldMeta,
+          fieldSchemas,
+          relationForced
         );
+        continue;
+      }
       if (UNSUPPORTED_WHERE_TYPES.has(fieldMeta.type) && !fieldMeta.isList) {
         throw new ShapeError(
-          `${fieldMeta.type} field "${fieldName}" cannot be used in where filters`
+          `${fieldMeta.type} field "${key}" cannot be used in where filters`
         );
       }
-      const opSchemas = {};
-      const fieldForced = {};
-      let hasClientOps = false;
-      let hasStringModeOp = false;
-      const clientOpKeys = [];
-      for (const [op, value] of Object.entries(operators)) {
-        if (value === true) {
-          opSchemas[op] = createOperatorSchema(
-            fieldMeta,
-            op,
-            enumMap
-          ).optional();
-          hasClientOps = true;
-          clientOpKeys.push(op);
-          if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
-            hasStringModeOp = true;
-          }
-        } else {
-          const opSchema = createOperatorSchema(fieldMeta, op, enumMap);
-          let parsed;
-          try {
-            parsed = opSchema.parse(value);
-          } catch (err) {
-            throw new ShapeError(
-              `Invalid forced value for "${model}.${fieldName}.${op}": ${err.message}`
-            );
+      processScalarField(key, value, model, fieldMeta, fieldSchemas, scalarConditions);
+    }
+    const schema = Object.keys(fieldSchemas).length > 0 ? z4.object(fieldSchemas).strict().optional() : null;
+    return {
+      schema,
+      forced: {
+        conditions: scalarConditions,
+        relations: relationForced
+      }
+    };
+  }
+  function processCombinator(key, value, model, fieldSchemas, parentConditions, parentRelations) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`"${key}" in where shape must be an object defining allowed fields`);
+    }
+    const result = buildWhereSchema(model, value);
+    if (result.schema) {
+      if (key === "NOT") {
+        fieldSchemas[key] = z4.union([result.schema, z4.array(result.schema)]).optional();
+      } else {
+        fieldSchemas[key] = z4.array(result.schema).optional();
+      }
+    }
+    if (hasWhereForced(result.forced)) {
+      if (key === "AND" || key === "OR") {
+        mergeScalarConditions(parentConditions, result.forced.conditions);
+        mergeRelationForcedMaps(parentRelations, result.forced.relations);
+      } else {
+        const notWhere = mergeWhereForced(void 0, result.forced);
+        if (Object.keys(notWhere).length > 0) {
+          const existing = parentConditions[key];
+          if (existing) {
+            parentConditions[key] = Array.isArray(existing) ? [...existing, notWhere] : [existing, notWhere];
+          } else {
+            parentConditions[key] = notWhere;
           }
-          fieldForced[op] = parsed;
         }
       }
-      if (!hasClientOps && Object.keys(fieldForced).length === 0) {
+    }
+  }
+  function processRelationFilter(key, value, fieldMeta, fieldSchemas, parentRelations) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`Relation filter for "${key}" must be an object with operators (some, every, none, is, isNot)`);
+    }
+    const allowedOps = fieldMeta.isList ? TO_MANY_RELATION_OPS : TO_ONE_RELATION_OPS;
+    const opSchemas = {};
+    const opForced = {};
+    let hasClientOps = false;
+    for (const [op, opValue] of Object.entries(value)) {
+      if (!allowedOps.has(op)) {
+        const allowed = [...allowedOps].join(", ");
+        throw new ShapeError(
+          `Operator "${op}" not supported for ${fieldMeta.isList ? "to-many" : "to-one"} relation "${key}". Allowed: ${allowed}`
+        );
+      }
+      if (!isPlainObject(opValue)) {
         throw new ShapeError(
-          `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
+          `Relation filter operator "${op}" on "${key}" must be an object defining nested where fields`
         );
       }
-      if (hasStringModeOp) {
-        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
-      }
-      if (hasClientOps) {
-        const opObj = z4.object(opSchemas).strict();
-        fieldSchemas[fieldName] = opObj.refine(
-          (v) => clientOpKeys.some(
-            (k) => v[k] !== void 0
-          ),
-          {
-            message: `At least one operator required for where field "${fieldName}"`
-          }
-        ).optional();
+      const nested = buildWhereSchema(fieldMeta.type, opValue);
+      if (nested.schema) {
+        if (!hasWhereForced(nested.forced)) {
+          opSchemas[op] = nested.schema.refine(
+            (v) => v === void 0 || Object.keys(v).length > 0,
+            { message: `Relation filter "${key}.${op}" requires at least one condition` }
+          );
+        } else {
+          opSchemas[op] = nested.schema;
+        }
+        hasClientOps = true;
       }
-      if (Object.keys(fieldForced).length > 0) {
-        forced[fieldName] = fieldForced;
+      if (hasWhereForced(nested.forced)) {
+        opForced[op] = nested.forced;
       }
     }
-    const schema = Object.keys(fieldSchemas).length > 0 ? z4.object(fieldSchemas).strict().optional() : null;
-    return { schema, forced };
+    if (hasClientOps) {
+      const clientOpKeys = Object.keys(opSchemas);
+      const opObjSchema = z4.object(opSchemas).strict();
+      if (Object.keys(opForced).length === 0) {
+        fieldSchemas[key] = opObjSchema.refine(
+          (v) => clientOpKeys.some((k) => v[k] !== void 0),
+          { message: `At least one relation operator required for "${key}"` }
+        ).optional();
+      } else {
+        fieldSchemas[key] = opObjSchema.optional();
+      }
+    }
+    if (Object.keys(opForced).length > 0) {
+      parentRelations[key] = opForced;
+    }
   }
-  function buildCountFieldSchema(model, config, context) {
-    if (config === true) {
-      return z4.literal(true).optional();
+  function processScalarField(fieldName, operators, model, fieldMeta, fieldSchemas, scalarConditions) {
+    if (!isPlainObject(operators)) {
+      throw new ShapeError(
+        `Where config for scalar field "${fieldName}" on model "${model}" must be an object of operators`
+      );
     }
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(config)) {
-      if (fieldName !== "_all") {
-        const fieldMeta = modelFields[fieldName];
-        if (!fieldMeta)
-          throw new ShapeError(
-            `Unknown field "${fieldName}" on model "${model}" in ${context}`
-          );
-        if (fieldMeta.isRelation)
+    const opSchemas = {};
+    const fieldForced = {};
+    let hasClientOps = false;
+    let hasStringModeOp = false;
+    const clientOpKeys = [];
+    for (const [op, opValue] of Object.entries(operators)) {
+      if (opValue === true) {
+        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap).optional();
+        hasClientOps = true;
+        clientOpKeys.push(op);
+        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+          hasStringModeOp = true;
+        }
+      } else {
+        const opSchema = createOperatorSchema(fieldMeta, op, enumMap);
+        let parsed;
+        try {
+          parsed = opSchema.parse(opValue);
+        } catch (err) {
           throw new ShapeError(
-            `Relation field "${fieldName}" cannot be used in ${context}`
+            `Invalid forced value for "${model}.${fieldName}.${op}": ${err.message}`
           );
+        }
+        fieldForced[op] = parsed;
       }
-      fieldSchemas[fieldName] = z4.literal(true).optional();
     }
-    return z4.object(fieldSchemas).strict().optional();
+    if (!hasClientOps && Object.keys(fieldForced).length === 0) {
+      throw new ShapeError(
+        `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
+      );
+    }
+    if (hasStringModeOp) {
+      opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
+    }
+    if (hasClientOps) {
+      const opObj = z4.object(opSchemas).strict();
+      fieldSchemas[fieldName] = opObj.refine(
+        (v) => clientOpKeys.some((k) => v[k] !== void 0),
+        { message: `At least one operator required for where field "${fieldName}"` }
+      ).optional();
+    }
+    if (Object.keys(fieldForced).length > 0) {
+      scalarConditions[fieldName] = fieldForced;
+    }
   }
-  function buildIncludeCountSchema(model, config) {
+  return { buildWhereSchema };
+}
+
+// src/runtime/query-builder-args.ts
+import { z as z5 } from "zod";
+var UNSUPPORTED_BY_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+function createArgsBuilder(typeMap, enumMap, uniqueMap) {
+  function buildOrderBySchema(model, orderByConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    if (config === true) {
-      return { schema: z4.literal(true).optional(), forcedCountWhere: {} };
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(orderByConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in orderBy`);
+      if (fieldMeta.type === "Json")
+        throw new ShapeError(`Json field "${fieldName}" cannot be used in orderBy`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in orderBy`);
+      fieldSchemas[fieldName] = z5.enum(["asc", "desc"]).optional();
     }
-    if (!isPlainObject(config) || !("select" in config)) {
-      throw new ShapeError(
-        `Invalid _count config on model "${model}". Expected true or { select: { ... } }`
-      );
+    const fieldKeys = Object.keys(fieldSchemas);
+    const singleSchema = z5.object(fieldSchemas).strict().refine(
+      (v) => fieldKeys.some((k) => v[k] !== void 0),
+      { message: "orderBy must specify at least one field" }
+    );
+    return z5.union([singleSchema, z5.array(singleSchema).min(1)]).optional();
+  }
+  function buildTakeSchema(config) {
+    if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
+      throw new ShapeError(`take max must be a finite integer, got ${config.max}`);
     }
-    for (const key of Object.keys(config)) {
-      if (key !== "select") {
-        throw new ShapeError(
-          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
-        );
-      }
+    if (config.max < 1) {
+      throw new ShapeError(`take max must be at least 1, got ${config.max}`);
     }
-    const selectObj = config.select;
-    const countSelectFields = {};
-    const forcedCountWhere = {};
-    for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in _count.select`
-        );
-      if (!fieldMeta.isRelation)
-        throw new ShapeError(
-          `Field "${fieldName}" is not a relation on model "${model}" in _count.select`
-        );
-      if (fieldConfig === true) {
-        countSelectFields[fieldName] = z4.literal(true).optional();
-      } else if (isPlainObject(fieldConfig)) {
-        validateNestedKeys(
-          Object.keys(fieldConfig),
-          KNOWN_COUNT_SELECT_ENTRY_KEYS,
-          `_count.select.${fieldName} on model "${model}"`
-        );
-        if (fieldConfig.where) {
-          const relatedType = fieldMeta.type;
-          const { schema: whereSchema, forced } = buildWhereSchema(
-            relatedType,
-            fieldConfig.where
-          );
-          const nestedSchemas = {};
-          if (whereSchema)
-            nestedSchemas["where"] = whereSchema;
-          const nestedObj = z4.object(nestedSchemas).strict();
-          countSelectFields[fieldName] = z4.union([z4.literal(true), nestedObj]).optional();
-          if (Object.keys(forced).length > 0) {
-            forcedCountWhere[fieldName] = forced;
-          }
-        } else {
-          countSelectFields[fieldName] = z4.literal(true).optional();
-        }
-      } else {
+    if (config.default !== void 0) {
+      if (!Number.isFinite(config.default) || !Number.isInteger(config.default)) {
+        throw new ShapeError(`take default must be a finite integer, got ${config.default}`);
+      }
+      if (config.default < 1) {
+        throw new ShapeError(`take default must be at least 1, got ${config.default}`);
+      }
+      if (config.default > config.max) {
+        throw new ShapeError("take default cannot exceed max");
+      }
+      return z5.number().int().min(1).max(config.max).default(config.default);
+    }
+    return z5.number().int().min(1).max(config.max).optional();
+  }
+  function buildCursorSchema(model, cursorConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const cursorFields = new Set(Object.keys(cursorConfig));
+    const constraints = uniqueMap[model];
+    if (constraints && constraints.length > 0) {
+      const covered = constraints.some(
+        (constraint) => constraint.every((field) => cursorFields.has(field))
+      );
+      if (!covered) {
+        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
         throw new ShapeError(
-          `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
+          `cursor on model "${model}" must cover a unique constraint: ${constraintDesc}`
         );
       }
     }
-    const selectSchema = z4.object(countSelectFields).strict();
-    return {
-      schema: z4.object({ select: selectSchema }).strict().optional(),
-      forcedCountWhere
-    };
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(cursorConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in cursor`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in cursor`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in cursor`);
+      fieldSchemas[fieldName] = createBaseType(fieldMeta, enumMap);
+    }
+    return z5.object(fieldSchemas).strict().optional();
+  }
+  function buildDistinctSchema(model, distinctConfig) {
+    if (distinctConfig.length === 0) {
+      throw new ShapeError("distinct must contain at least one field");
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    for (const fieldName of distinctConfig) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in distinct`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in distinct`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in distinct`);
+    }
+    const enumSchema = z5.enum(distinctConfig);
+    return z5.union([enumSchema, z5.array(enumSchema).min(1)]).optional();
+  }
+  function buildBySchema(model, byConfig) {
+    if (byConfig.length === 0) {
+      throw new ShapeError('groupBy "by" must contain at least one field');
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    for (const fieldName of byConfig) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in by`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in by`);
+      if (UNSUPPORTED_BY_TYPES.has(fieldMeta.type)) {
+        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in by`);
+      }
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
+    }
+    const enumSchema = z5.enum(byConfig);
+    return z5.union([enumSchema, z5.array(enumSchema).min(1)]);
+  }
+  function buildHavingSchema(model, havingConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(havingConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in having`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in having`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in having`);
+      const ops = getSupportedOperators(fieldMeta);
+      if (ops.length === 0) {
+        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in having filters`);
+      }
+      const opSchemas = {};
+      const opKeys = [];
+      for (const op of ops) {
+        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap).optional();
+        opKeys.push(op);
+      }
+      if (fieldMeta.type === "String" && !fieldMeta.isList) {
+        opSchemas["mode"] = z5.enum(["default", "insensitive"]).optional();
+      }
+      fieldSchemas[fieldName] = z5.object(opSchemas).strict().refine(
+        (v) => opKeys.some((k) => v[k] !== void 0),
+        { message: `At least one operator required for having field "${fieldName}"` }
+      ).optional();
+    }
+    const havingFieldKeys = Object.keys(fieldSchemas);
+    return z5.object(fieldSchemas).strict().refine(
+      (v) => havingFieldKeys.some((k) => v[k] !== void 0),
+      { message: "having must specify at least one field" }
+    ).optional();
   }
   function buildAggregateFieldSchema(model, opName, fieldConfig) {
     const modelFields = typeMap[model];
@@ -1006,18 +1287,14 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
     const fieldSchemas = {};
     for (const fieldName of Object.keys(fieldConfig)) {
       if (fieldName === "_all" && opName === "_count") {
-        fieldSchemas[fieldName] = z4.literal(true).optional();
+        fieldSchemas[fieldName] = z5.literal(true).optional();
         continue;
       }
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in ${opName}`
-        );
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${opName}`);
       if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in ${opName}`
-        );
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${opName}`);
       if (isNumericOnly && !NUMERIC_TYPES.has(fieldMeta.type)) {
         throw new ShapeError(
           `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only numeric types (Int, Float, Decimal, BigInt) are supported.`
@@ -1028,96 +1305,180 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
           `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only comparable types (Int, Float, Decimal, BigInt, String, DateTime) are supported.`
         );
       }
-      fieldSchemas[fieldName] = z4.literal(true).optional();
+      fieldSchemas[fieldName] = z5.literal(true).optional();
     }
-    return z4.object(fieldSchemas).strict().optional();
+    const aggFieldKeys = Object.keys(fieldSchemas);
+    return z5.object(fieldSchemas).strict().refine(
+      (v) => aggFieldKeys.some((k) => v[k] !== void 0),
+      { message: `${opName} must specify at least one field` }
+    ).optional();
   }
-  function buildBySchema(model, byConfig) {
-    if (byConfig.length === 0) {
-      throw new ShapeError('groupBy "by" must contain at least one field');
+  function buildCountFieldSchema(model, config, context) {
+    if (config === true) {
+      return z5.literal(true).optional();
     }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    for (const fieldName of byConfig) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in by`
-        );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in by`
-        );
-      if (UNSUPPORTED_BY_TYPES.has(fieldMeta.type)) {
-        throw new ShapeError(
-          `${fieldMeta.type} field "${fieldName}" cannot be used in by`
-        );
-      }
-      if (fieldMeta.isList) {
-        throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(config)) {
+      if (fieldName !== "_all") {
+        const fieldMeta = modelFields[fieldName];
+        if (!fieldMeta)
+          throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${context}`);
+        if (fieldMeta.isRelation)
+          throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${context}`);
       }
+      fieldSchemas[fieldName] = z5.literal(true).optional();
     }
-    const enumSchema = z4.enum(byConfig);
-    return z4.union([enumSchema, z4.array(enumSchema).min(1)]);
+    const countFieldKeys = Object.keys(fieldSchemas);
+    return z5.object(fieldSchemas).strict().refine(
+      (v) => countFieldKeys.some((k) => v[k] !== void 0),
+      { message: `${context} must specify at least one field` }
+    ).optional();
   }
-  function buildCursorSchema(model, cursorConfig) {
+  function buildCountSelectSchema(model, selectConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    const cursorFields = new Set(Object.keys(cursorConfig));
-    const constraints = uniqueMap[model];
-    if (constraints && constraints.length > 0) {
-      const covered = constraints.some(
-        (constraint) => constraint.every((field) => cursorFields.has(field))
-      );
-      if (!covered) {
-        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
-        throw new ShapeError(
-          `cursor on model "${model}" must cover a unique constraint: ${constraintDesc}`
-        );
-      }
-    }
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(cursorConfig)) {
+    for (const fieldName of Object.keys(selectConfig)) {
+      if (fieldName === "_all") {
+        fieldSchemas["_all"] = z5.literal(true).optional();
+        continue;
+      }
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in cursor`
-        );
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in count select`);
       if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in cursor`
-        );
-      if (fieldMeta.isList)
-        throw new ShapeError(
-          `List field "${fieldName}" cannot be used in cursor`
-        );
-      fieldSchemas[fieldName] = createBaseType(fieldMeta, enumMap);
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in count select`);
+      fieldSchemas[fieldName] = z5.literal(true).optional();
     }
-    return z4.object(fieldSchemas).strict().optional();
+    const countSelectKeys = Object.keys(fieldSchemas);
+    return z5.object(fieldSchemas).strict().refine(
+      (v) => countSelectKeys.some((k) => v[k] !== void 0),
+      { message: "count select must specify at least one field" }
+    ).optional();
   }
-  function buildDistinctSchema(model, distinctConfig) {
+  return {
+    buildOrderBySchema,
+    buildTakeSchema,
+    buildCursorSchema,
+    buildDistinctSchema,
+    buildBySchema,
+    buildHavingSchema,
+    buildAggregateFieldSchema,
+    buildCountFieldSchema,
+    buildCountSelectSchema
+  };
+}
+
+// src/runtime/query-builder-projection.ts
+import { z as z6 } from "zod";
+var KNOWN_NESTED_INCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "where",
+  "include",
+  "select",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip"
+]);
+var KNOWN_NESTED_SELECT_KEYS = /* @__PURE__ */ new Set([
+  "select",
+  "where",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip"
+]);
+var KNOWN_COUNT_SELECT_ENTRY_KEYS = /* @__PURE__ */ new Set(["where"]);
+function validateNestedKeys(keys, allowed, context) {
+  for (const key of keys) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unknown key "${key}" in ${context}. Allowed: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+function createProjectionBuilder(typeMap, enumMap, deps) {
+  function buildIncludeCountSchema(model, config) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    for (const fieldName of distinctConfig) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
+    if (config === true) {
+      return { schema: z6.literal(true).optional(), forcedCountWhere: {} };
+    }
+    if (!isPlainObject(config) || !("select" in config)) {
+      throw new ShapeError(
+        `Invalid _count config on model "${model}". Expected true or { select: { ... } }`
+      );
+    }
+    for (const key of Object.keys(config)) {
+      if (key !== "select") {
         throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in distinct`
+          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
         );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in distinct`
+      }
+    }
+    if (!isPlainObject(config.select)) {
+      throw new ShapeError(
+        `Invalid _count.select on model "${model}". Expected a plain object with relation field keys.`
+      );
+    }
+    const selectObj = config.select;
+    if (Object.keys(selectObj).length === 0) {
+      throw new ShapeError(
+        `Empty _count.select on model "${model}". Define at least one relation field.`
+      );
+    }
+    const countSelectFields = {};
+    const forcedCountWhere = {};
+    for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in _count.select`);
+      if (!fieldMeta.isRelation)
+        throw new ShapeError(`Field "${fieldName}" is not a relation on model "${model}" in _count.select`);
+      if (!fieldMeta.isList)
+        throw new ShapeError(`Field "${fieldName}" is a to-one relation on model "${model}" in _count.select. Only to-many relations support _count.`);
+      if (fieldConfig === true) {
+        countSelectFields[fieldName] = z6.literal(true).optional();
+      } else if (isPlainObject(fieldConfig)) {
+        validateNestedKeys(
+          Object.keys(fieldConfig),
+          KNOWN_COUNT_SELECT_ENTRY_KEYS,
+          `_count.select.${fieldName} on model "${model}"`
         );
-      if (fieldMeta.isList)
+        if (fieldConfig.where) {
+          const relatedType = fieldMeta.type;
+          const { schema: whereSchema, forced } = deps.buildWhereSchema(
+            relatedType,
+            fieldConfig.where
+          );
+          const nestedSchemas = {};
+          if (whereSchema)
+            nestedSchemas["where"] = whereSchema;
+          const nestedObj = z6.object(nestedSchemas).strict();
+          countSelectFields[fieldName] = z6.union([z6.literal(true), nestedObj]).optional();
+          if (hasWhereForced(forced)) {
+            forcedCountWhere[fieldName] = forced;
+          }
+        } else {
+          countSelectFields[fieldName] = z6.literal(true).optional();
+        }
+      } else {
         throw new ShapeError(
-          `List field "${fieldName}" cannot be used in distinct`
+          `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
         );
+      }
     }
-    const enumSchema = z4.enum(distinctConfig);
-    return z4.union([enumSchema, z4.array(enumSchema).min(1)]).optional();
+    const selectSchema = z6.object(countSelectFields).strict();
+    return {
+      schema: z6.object({ select: selectSchema }).strict().optional(),
+      forcedCountWhere
+    };
   }
   function buildIncludeSchema(model, includeConfig) {
     const modelFields = typeMap[model];
@@ -1128,10 +1489,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
     let topLevelForcedCountWhere = {};
     for (const [relName, config] of Object.entries(includeConfig)) {
       if (relName === "_count") {
-        const countResult = buildIncludeCountSchema(
-          model,
-          config
-        );
+        const countResult = buildIncludeCountSchema(model, config);
         fieldSchemas["_count"] = countResult.schema;
         topLevelForcedCountWhere = countResult.forcedCountWhere;
         continue;
@@ -1140,11 +1498,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
       if (!fieldMeta)
         throw new ShapeError(`Unknown field "${relName}" on model "${model}"`);
       if (!fieldMeta.isRelation)
-        throw new ShapeError(
-          `Field "${relName}" is not a relation on model "${model}"`
-        );
+        throw new ShapeError(`Field "${relName}" is not a relation on model "${model}"`);
       if (config === true) {
-        fieldSchemas[relName] = z4.literal(true).optional();
+        fieldSchemas[relName] = z6.literal(true).optional();
       } else {
         validateNestedKeys(
           Object.keys(config),
@@ -1152,9 +1508,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
           `nested include for "${relName}" on model "${model}"`
         );
         if (config.select && config.include) {
-          throw new ShapeError(
-            `Nested include for "${relName}" cannot define both "select" and "include".`
-          );
+          throw new ShapeError(`Nested include for "${relName}" cannot define both "select" and "include".`);
         }
         if (!fieldMeta.isList) {
           if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
@@ -1166,13 +1520,13 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
         const nestedSchemas = {};
         const relForced = {};
         if (config.where) {
-          const { schema: whereSchema, forced } = buildWhereSchema(
+          const { schema: whereSchema, forced } = deps.buildWhereSchema(
             fieldMeta.type,
             config.where
           );
           if (whereSchema)
             nestedSchemas["where"] = whereSchema;
-          if (Object.keys(forced).length > 0)
+          if (hasWhereForced(forced))
             relForced.where = forced;
         }
         if (config.include) {
@@ -1192,31 +1546,25 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
             relForced._countWhere = nested.forcedCountWhere;
         }
         if (config.orderBy) {
-          nestedSchemas["orderBy"] = buildOrderBySchema(
-            fieldMeta.type,
-            config.orderBy
-          );
+          nestedSchemas["orderBy"] = deps.buildOrderBySchema(fieldMeta.type, config.orderBy);
         }
         if (config.cursor) {
-          nestedSchemas["cursor"] = buildCursorSchema(
-            fieldMeta.type,
-            config.cursor
-          );
+          nestedSchemas["cursor"] = deps.buildCursorSchema(fieldMeta.type, config.cursor);
         }
         if (config.take) {
-          nestedSchemas["take"] = buildTakeSchema(config.take);
+          nestedSchemas["take"] = deps.buildTakeSchema(config.take);
         }
         if (config.skip) {
-          nestedSchemas["skip"] = z4.number().int().min(0).optional();
+          nestedSchemas["skip"] = z6.number().int().min(0).optional();
         }
-        const nestedObj = z4.object(nestedSchemas).strict();
-        fieldSchemas[relName] = z4.union([z4.literal(true), nestedObj]).optional();
+        const nestedObj = z6.object(nestedSchemas).strict();
+        fieldSchemas[relName] = z6.union([z6.literal(true), nestedObj]).optional();
         if (Object.keys(relForced).length > 0)
           forcedTree[relName] = relForced;
       }
     }
     return {
-      schema: z4.object(fieldSchemas).strict().optional(),
+      schema: z6.object(fieldSchemas).strict().optional(),
       forcedTree,
       forcedCountWhere: topLevelForcedCountWhere
     };
@@ -1230,26 +1578,19 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
     let topLevelForcedCountWhere = {};
     for (const [fieldName, config] of Object.entries(selectConfig)) {
       if (fieldName === "_count") {
-        const countResult = buildIncludeCountSchema(
-          model,
-          config
-        );
+        const countResult = buildIncludeCountSchema(model, config);
         fieldSchemas["_count"] = countResult.schema;
         topLevelForcedCountWhere = countResult.forcedCountWhere;
         continue;
       }
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}"`
-        );
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
       if (config === true) {
-        fieldSchemas[fieldName] = z4.literal(true).optional();
+        fieldSchemas[fieldName] = z6.literal(true).optional();
       } else {
         if (!fieldMeta.isRelation) {
-          throw new ShapeError(
-            `Nested select args only valid for relations, not scalar "${fieldName}"`
-          );
+          throw new ShapeError(`Nested select args only valid for relations, not scalar "${fieldName}" on model "${model}"`);
         }
         validateNestedKeys(
           Object.keys(config),
@@ -1274,200 +1615,98 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
             relForced._countWhere = nested.forcedCountWhere;
         }
         if (config.where) {
-          const { schema: whereSchema, forced } = buildWhereSchema(
+          const { schema: whereSchema, forced } = deps.buildWhereSchema(
             fieldMeta.type,
             config.where
           );
           if (whereSchema)
             nestedSchemas["where"] = whereSchema;
-          if (Object.keys(forced).length > 0)
+          if (hasWhereForced(forced))
             relForced.where = forced;
         }
         if (config.orderBy) {
-          nestedSchemas["orderBy"] = buildOrderBySchema(
-            fieldMeta.type,
-            config.orderBy
-          );
+          nestedSchemas["orderBy"] = deps.buildOrderBySchema(fieldMeta.type, config.orderBy);
         }
         if (config.cursor) {
-          nestedSchemas["cursor"] = buildCursorSchema(
-            fieldMeta.type,
-            config.cursor
-          );
+          nestedSchemas["cursor"] = deps.buildCursorSchema(fieldMeta.type, config.cursor);
         }
         if (config.take) {
-          nestedSchemas["take"] = buildTakeSchema(config.take);
+          nestedSchemas["take"] = deps.buildTakeSchema(config.take);
         }
         if (config.skip) {
-          nestedSchemas["skip"] = z4.number().int().min(0).optional();
+          nestedSchemas["skip"] = z6.number().int().min(0).optional();
         }
-        const nestedObj = z4.object(nestedSchemas).strict();
-        fieldSchemas[fieldName] = z4.union([z4.literal(true), nestedObj]).optional();
+        const nestedObj = z6.object(nestedSchemas).strict();
+        fieldSchemas[fieldName] = z6.union([z6.literal(true), nestedObj]).optional();
         if (Object.keys(relForced).length > 0)
           forcedTree[fieldName] = relForced;
       }
     }
     return {
-      schema: z4.object(fieldSchemas).strict().optional(),
+      schema: z6.object(fieldSchemas).strict().optional(),
       forcedTree,
       forcedCountWhere: topLevelForcedCountWhere
     };
   }
-  function buildOrderBySchema(model, orderByConfig) {
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(orderByConfig)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}"`
-        );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in orderBy`
-        );
-      if (fieldMeta.type === "Json")
-        throw new ShapeError(
-          `Json field "${fieldName}" cannot be used in orderBy`
-        );
-      if (fieldMeta.isList)
-        throw new ShapeError(
-          `List field "${fieldName}" cannot be used in orderBy`
-        );
-      fieldSchemas[fieldName] = z4.enum(["asc", "desc"]).optional();
-    }
-    const singleSchema = z4.object(fieldSchemas).strict();
-    return z4.union([singleSchema, z4.array(singleSchema)]).optional();
-  }
-  function buildTakeSchema(config) {
-    if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
-      throw new ShapeError(
-        `take max must be a finite integer, got ${config.max}`
-      );
-    }
-    if (config.max < 1) {
-      throw new ShapeError(`take max must be at least 1, got ${config.max}`);
-    }
-    if (config.default !== void 0) {
-      if (!Number.isFinite(config.default) || !Number.isInteger(config.default)) {
-        throw new ShapeError(
-          `take default must be a finite integer, got ${config.default}`
-        );
-      }
-      if (config.default < 1) {
-        throw new ShapeError(
-          `take default must be at least 1, got ${config.default}`
-        );
-      }
-      if (config.default > config.max) {
-        throw new ShapeError("take default cannot exceed max");
-      }
-      return z4.number().int().min(1).max(config.max).default(config.default);
-    }
-    return z4.number().int().min(1).max(config.max).optional();
-  }
-  function buildHavingSchema(model, havingConfig) {
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(havingConfig)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in having`
-        );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in having`
-        );
-      if (fieldMeta.isList)
-        throw new ShapeError(
-          `List field "${fieldName}" cannot be used in having`
-        );
-      const ops = getSupportedOperators(fieldMeta);
-      if (ops.length === 0) {
-        throw new ShapeError(
-          `${fieldMeta.type} field "${fieldName}" cannot be used in having filters`
-        );
-      }
-      const opSchemas = {};
-      const opKeys = [];
-      for (const op of ops) {
-        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap).optional();
-        opKeys.push(op);
-      }
-      if (fieldMeta.type === "String" && !fieldMeta.isList) {
-        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
-      }
-      fieldSchemas[fieldName] = z4.object(opSchemas).strict().refine(
-        (v) => opKeys.some((k) => v[k] !== void 0),
-        {
-          message: `At least one operator required for having field "${fieldName}"`
-        }
-      ).optional();
-    }
-    return z4.object(fieldSchemas).strict().optional();
-  }
-  function buildCountSelectSchema(model, selectConfig) {
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(selectConfig)) {
-      if (fieldName === "_all") {
-        fieldSchemas["_all"] = z4.literal(true).optional();
-        continue;
-      }
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in count select`
-        );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in count select`
-        );
-      fieldSchemas[fieldName] = z4.literal(true).optional();
-    }
-    return z4.object(fieldSchemas).strict().optional();
+  return { buildIncludeSchema, buildSelectSchema, buildIncludeCountSchema };
+}
+
+// src/runtime/query-builder.ts
+var METHOD_ALLOWED_ARGS = {
+  findMany: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findFirst: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findFirstOrThrow: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findUnique: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  findUniqueOrThrow: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  count: /* @__PURE__ */ new Set(["where", "select", "cursor", "orderBy", "skip", "take"]),
+  aggregate: /* @__PURE__ */ new Set(["where", "orderBy", "cursor", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"]),
+  groupBy: /* @__PURE__ */ new Set(["where", "by", "having", "_count", "_avg", "_sum", "_min", "_max", "orderBy", "take", "skip"])
+};
+var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
+  const whereBuilder = createWhereBuilder(typeMap, enumMap);
+  const argsBuilder = createArgsBuilder(typeMap, enumMap, uniqueMap);
+  const projectionBuilder = createProjectionBuilder(typeMap, enumMap, {
+    buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildOrderBySchema: argsBuilder.buildOrderBySchema,
+    buildCursorSchema: argsBuilder.buildCursorSchema,
+    buildTakeSchema: argsBuilder.buildTakeSchema
+  });
+  function isShapeConfig(obj) {
+    if (!isPlainObject(obj))
+      return false;
+    const keys = Object.keys(obj);
+    return keys.length === 0 || keys.every((k) => SHAPE_CONFIG_KEYS.has(k));
   }
   function validateShapeArgs(method, shape) {
     const allowed = METHOD_ALLOWED_ARGS[method];
     for (const key of Object.keys(shape)) {
-      if (!SHAPE_CONFIG_KEYS.has(key)) {
+      if (!SHAPE_CONFIG_KEYS.has(key))
         throw new ShapeError(`Unknown shape config key "${key}"`);
-      }
-      if (!allowed.has(key)) {
+      if (!allowed.has(key))
         throw new ShapeError(`Arg "${key}" not allowed for method "${method}"`);
-      }
+    }
+    if (UNIQUE_WHERE_METHODS.has(method) && !shape.where) {
+      throw new ShapeError(`${method} shape must define "where"`);
     }
     if (shape.include && shape.select) {
-      throw new ShapeError(
-        'Shape config cannot define both "include" and "select".'
-      );
+      throw new ShapeError('Shape config cannot define both "include" and "select".');
     }
-    if (method === "groupBy" && !shape.by) {
+    if (method === "groupBy" && !shape.by)
       throw new ShapeError('groupBy shape must define "by"');
-    }
     if (method === "groupBy" && (shape.include || shape.select)) {
       throw new ShapeError('groupBy does not support "include" or "select"');
     }
     if (method === "aggregate" && (shape.include || shape.select)) {
       throw new ShapeError('aggregate does not support "include" or "select"');
     }
-    if (method === "count" && shape.include) {
+    if (method === "count" && shape.include)
       throw new ShapeError('count does not support "include"');
-    }
     if (method === "groupBy" && shape.orderBy) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.orderBy)) {
         if (!bySet.has(fieldName)) {
-          throw new ShapeError(
-            `orderBy field "${fieldName}" must be included in "by" for groupBy`
-          );
+          throw new ShapeError(`orderBy field "${fieldName}" must be included in "by" for groupBy`);
         }
       }
     }
@@ -1475,9 +1714,7 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
       const bySet = new Set(shape.by);
       for (const fieldName of Object.keys(shape.having)) {
         if (!bySet.has(fieldName)) {
-          throw new ShapeError(
-            `having field "${fieldName}" must be included in "by" for groupBy`
-          );
+          throw new ShapeError(`having field "${fieldName}" must be included in "by" for groupBy`);
         }
       }
     }
@@ -1487,97 +1724,76 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
       return;
     if (!shape.where)
       return;
-    validateUniqueEquality(model, shape.where, method, uniqueMap);
+    validateUniqueEquality(model, shape.where, method, uniqueMap, typeMap);
+  }
+  function resolveAndValidateShape(shapeOrFn, ctx) {
+    if (typeof shapeOrFn === "function") {
+      requireContext(ctx, "shape function");
+      const result = shapeOrFn(ctx);
+      if (!isPlainObject(result)) {
+        throw new ShapeError("Dynamic shape function must return a plain object");
+      }
+      return result;
+    }
+    return shapeOrFn;
   }
   function buildShapeZodSchema(model, method, shape) {
     validateShapeArgs(method, shape);
     validateUniqueWhere(model, method, shape);
     const schemaFields = {};
-    let forcedWhere = {};
+    let forcedWhere = EMPTY_WHERE_FORCED;
     let forcedIncludeTree = {};
     let forcedSelectTree = {};
     let forcedIncludeCountWhere = {};
     let forcedSelectCountWhere = {};
     if (shape.where) {
-      const { schema, forced } = buildWhereSchema(model, shape.where);
+      const { schema, forced } = whereBuilder.buildWhereSchema(model, shape.where);
       if (schema)
         schemaFields["where"] = schema;
       forcedWhere = forced;
     }
     if (shape.include) {
-      const result = buildIncludeSchema(model, shape.include);
+      const result = projectionBuilder.buildIncludeSchema(model, shape.include);
       schemaFields["include"] = result.schema;
       forcedIncludeTree = result.forcedTree;
       forcedIncludeCountWhere = result.forcedCountWhere;
     }
     if (shape.select) {
       if (method === "count") {
-        schemaFields["select"] = buildCountSelectSchema(model, shape.select);
+        schemaFields["select"] = argsBuilder.buildCountSelectSchema(model, shape.select);
       } else {
-        const result = buildSelectSchema(model, shape.select);
+        const result = projectionBuilder.buildSelectSchema(model, shape.select);
         schemaFields["select"] = result.schema;
         forcedSelectTree = result.forcedTree;
         forcedSelectCountWhere = result.forcedCountWhere;
       }
     }
-    if (shape.orderBy) {
-      schemaFields["orderBy"] = buildOrderBySchema(model, shape.orderBy);
-    }
-    if (shape.cursor) {
-      schemaFields["cursor"] = buildCursorSchema(model, shape.cursor);
-    }
-    if (shape.take) {
-      schemaFields["take"] = buildTakeSchema(shape.take);
-    }
-    if (shape.skip) {
-      schemaFields["skip"] = z4.number().int().min(0).optional();
-    }
-    if (shape.distinct) {
-      schemaFields["distinct"] = buildDistinctSchema(model, shape.distinct);
-    }
-    if (shape._count) {
-      schemaFields["_count"] = buildCountFieldSchema(
-        model,
-        shape._count,
-        "_count"
-      );
-    }
-    if (shape._avg) {
-      schemaFields["_avg"] = buildAggregateFieldSchema(
-        model,
-        "_avg",
-        shape._avg
-      );
-    }
-    if (shape._sum) {
-      schemaFields["_sum"] = buildAggregateFieldSchema(
-        model,
-        "_sum",
-        shape._sum
-      );
-    }
-    if (shape._min) {
-      schemaFields["_min"] = buildAggregateFieldSchema(
-        model,
-        "_min",
-        shape._min
-      );
-    }
-    if (shape._max) {
-      schemaFields["_max"] = buildAggregateFieldSchema(
-        model,
-        "_max",
-        shape._max
-      );
-    }
-    if (shape.by) {
-      schemaFields["by"] = buildBySchema(model, shape.by);
-    }
-    if (shape.having) {
-      schemaFields["having"] = buildHavingSchema(model, shape.having);
-    }
+    if (shape.orderBy)
+      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(model, shape.orderBy);
+    if (shape.cursor)
+      schemaFields["cursor"] = argsBuilder.buildCursorSchema(model, shape.cursor);
+    if (shape.take)
+      schemaFields["take"] = argsBuilder.buildTakeSchema(shape.take);
+    if (shape.skip)
+      schemaFields["skip"] = z7.number().int().min(0).optional();
+    if (shape.distinct)
+      schemaFields["distinct"] = argsBuilder.buildDistinctSchema(model, shape.distinct);
+    if (shape._count)
+      schemaFields["_count"] = argsBuilder.buildCountFieldSchema(model, shape._count, "_count");
+    if (shape._avg)
+      schemaFields["_avg"] = argsBuilder.buildAggregateFieldSchema(model, "_avg", shape._avg);
+    if (shape._sum)
+      schemaFields["_sum"] = argsBuilder.buildAggregateFieldSchema(model, "_sum", shape._sum);
+    if (shape._min)
+      schemaFields["_min"] = argsBuilder.buildAggregateFieldSchema(model, "_min", shape._min);
+    if (shape._max)
+      schemaFields["_max"] = argsBuilder.buildAggregateFieldSchema(model, "_max", shape._max);
+    if (shape.by)
+      schemaFields["by"] = argsBuilder.buildBySchema(model, shape.by);
+    if (shape.having)
+      schemaFields["having"] = argsBuilder.buildHavingSchema(model, shape.having);
     return {
-      zodSchema: z4.object(schemaFields).strict(),
+      zodSchema: z7.object(schemaFields).strict(),
       forcedWhere,
       forcedIncludeTree,
       forcedSelectTree,
@@ -1592,30 +1808,20 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
     return { key: matched, shape: shapes[matched] };
   }
   function buildQuerySchema(model, method, config) {
-    const isSingleShape2 = typeof config === "function" || isShapeConfig(config);
+    const isSingle = typeof config === "function" || isShapeConfig(config);
     const builtCache = /* @__PURE__ */ new Map();
-    if (isSingleShape2 && typeof config !== "function") {
-      const built = buildShapeZodSchema(model, method, config);
-      builtCache.set("_default", built);
+    if (isSingle && typeof config !== "function") {
+      builtCache.set("_default", buildShapeZodSchema(model, method, config));
     }
-    if (!isSingleShape2) {
+    if (!isSingle) {
       for (const key of Object.keys(config)) {
         if (SHAPE_CONFIG_KEYS.has(key)) {
-          throw new ShapeError(
-            `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
-          );
+          throw new ShapeError(`Caller key "${key}" collides with reserved shape config key. Rename the caller path.`);
         }
       }
-      for (const [key, shapeOrFn] of Object.entries(
-        config
-      )) {
+      for (const [key, shapeOrFn] of Object.entries(config)) {
         if (typeof shapeOrFn !== "function") {
-          const built = buildShapeZodSchema(
-            model,
-            method,
-            shapeOrFn
-          );
-          builtCache.set(key, built);
+          builtCache.set(key, buildShapeZodSchema(model, method, shapeOrFn));
         }
       }
     }
@@ -1626,45 +1832,41 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
       ),
       parse(body, opts) {
         let built;
-        if (isSingleShape2) {
+        if (isSingle) {
           if (typeof config === "function") {
-            requireContext(opts?.ctx, "shape function");
-            const resolvedShape = config(opts.ctx);
-            built = buildShapeZodSchema(model, method, resolvedShape);
+            const resolved = resolveAndValidateShape(config, opts?.ctx);
+            built = buildShapeZodSchema(model, method, resolved);
           } else {
             built = builtCache.get("_default");
           }
         } else {
-          if (!isPlainObject(body)) {
+          if (!isPlainObject(body))
             throw new ShapeError("Request body must be an object");
+          if ("caller" in body) {
+            throw new CallerError(
+              "Pass caller via opts.caller, not in the request body."
+            );
           }
-          const caller = body.caller;
+          const caller = opts?.caller;
           if (typeof caller !== "string") {
-            throw new CallerError('Missing "caller" field in request body');
+            const allowed = Object.keys(config);
+            throw new CallerError(
+              `Missing caller. This query uses named shape routing with keys: ${allowed.map((k) => `"${k}"`).join(", ")}. Provide caller via opts.caller.`
+            );
           }
-          const matched = matchCaller(
-            config,
-            caller
-          );
+          const matched = matchCaller(config, caller);
           if (!matched) {
-            const allowed = Object.keys(
-              config
-            );
+            const allowed = Object.keys(config);
             throw new CallerError(
               `Unknown caller: "${caller}". Allowed: ${allowed.map((k) => `"${k}"`).join(", ")}`
             );
           }
-          const shapeKey = matched.key;
-          const shapeOrFn = matched.shape;
-          if (typeof shapeOrFn === "function") {
-            requireContext(opts?.ctx, "shape function");
-            const resolvedShape = shapeOrFn(opts.ctx);
-            built = buildShapeZodSchema(model, method, resolvedShape);
+          if (typeof matched.shape === "function") {
+            const resolved = resolveAndValidateShape(matched.shape, opts?.ctx);
+            built = buildShapeZodSchema(model, method, resolved);
           } else {
-            built = builtCache.get(shapeKey);
+            built = builtCache.get(matched.key);
           }
-          const { caller: _, ...rest } = body;
-          body = rest;
         }
         return applyBuiltShape(built, body, isUnique);
       }
@@ -1673,9 +1875,9 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
   return {
     buildQuerySchema,
     buildShapeZodSchema,
-    buildWhereSchema,
-    buildIncludeSchema,
-    buildSelectSchema
+    buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildIncludeSchema: projectionBuilder.buildIncludeSchema,
+    buildSelectSchema: projectionBuilder.buildSelectSchema
   };
 }
 
@@ -2005,9 +2207,14 @@ async function handleFindUnique(args, query, conditions, scopes, operation, log)
 }
 
 // src/runtime/model-guard.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod";
+
+// src/runtime/model-guard-data.ts
+import { z as z8 } from "zod";
 var ALLOWED_BODY_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
 var ALLOWED_BODY_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
+var ALLOWED_BODY_KEYS_CREATE_MANY = /* @__PURE__ */ new Set(["data", "skipDuplicates"]);
+var ALLOWED_BODY_KEYS_CREATE_MANY_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include", "skipDuplicates"]);
 var ALLOWED_BODY_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
 var ALLOWED_BODY_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
 var ALLOWED_BODY_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
@@ -2018,28 +2225,11 @@ var VALID_SHAPE_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
 var VALID_SHAPE_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
 var VALID_SHAPE_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
 var VALID_SHAPE_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
-var UNIQUE_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete"]);
-var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
-var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
-  "updateMany",
-  "updateManyAndReturn",
-  "deleteMany"
-]);
-var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
-  "create",
-  "update",
-  "delete",
-  "createManyAndReturn",
-  "updateManyAndReturn"
-]);
-function isGuardShape(obj) {
-  if (!isPlainObject(obj))
+function isZodSchema2(value) {
+  if (value == null || typeof value !== "object")
     return false;
-  const keys = Object.keys(obj);
-  return keys.length === 0 || keys.every((k) => GUARD_SHAPE_KEYS.has(k));
-}
-function isSingleShape(input) {
-  return typeof input === "function" || isGuardShape(input);
+  const v = value;
+  return typeof v.parse === "function" && typeof v.optional === "function";
 }
 function validateMutationBodyKeys(body, allowed, method) {
   for (const key of Object.keys(body)) {
@@ -2059,197 +2249,258 @@ function validateMutationShapeKeys(shape, allowed, method) {
     }
   }
 }
-function formatZodError(err) {
-  return err.issues.map((i) => {
-    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
-    return `${p}${i.message}`;
-  }).join("; ");
-}
-function createModelGuardExtension(config) {
-  const { typeMap, enumMap, zodChains, uniqueMap, scopeMap, contextFn } = config;
-  const wrapZodErrors = config.wrapZodErrors ?? false;
-  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap);
-  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap);
-  const modelScopeFks = /* @__PURE__ */ new Map();
-  for (const [model, entries] of Object.entries(scopeMap)) {
-    const fks = /* @__PURE__ */ new Set();
-    for (const entry of entries) {
-      fks.add(entry.fk);
-    }
-    modelScopeFks.set(model, fks);
-  }
-  function validateCreateCompleteness(modelName, dataConfig) {
-    const modelFields = typeMap[modelName];
-    if (!modelFields)
-      return;
-    const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
-    for (const [fieldName, meta] of Object.entries(modelFields)) {
-      if (meta.isRelation)
-        continue;
-      if (meta.isUpdatedAt)
-        continue;
-      if (meta.hasDefault)
-        continue;
-      if (!meta.isRequired)
-        continue;
-      if (fieldName in dataConfig)
-        continue;
-      if (fks.has(fieldName))
-        continue;
-      throw new ShapeError(
-        `Required field "${fieldName}" on model "${modelName}" is missing from create data shape, has no default, and is not a scope FK`
-      );
-    }
+function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zodDefaults) {
+  const modelFields = typeMap[modelName];
+  if (!modelFields)
+    return;
+  const zodDefaultFields = zodDefaults[modelName];
+  const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
+  for (const [fieldName, meta] of Object.entries(modelFields)) {
+    if (meta.isRelation)
+      continue;
+    if (meta.isUpdatedAt)
+      continue;
+    if (meta.hasDefault)
+      continue;
+    if (!meta.isRequired)
+      continue;
+    if (fieldName in dataConfig)
+      continue;
+    if (scopeFks.has(fieldName))
+      continue;
+    if (zodDefaultSet && zodDefaultSet.has(fieldName))
+      continue;
+    throw new ShapeError(
+      `Required field "${fieldName}" on model "${modelName}" is missing from create data shape, has no default, and is not a scope FK`
+    );
   }
-  function buildDataSchema(model, dataConfig, mode) {
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    const schemaMap = {};
-    const forced = {};
-    for (const [fieldName, value] of Object.entries(dataConfig)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
-      if (fieldMeta.isRelation)
-        throw new ShapeError(`Relation field "${fieldName}" cannot be used in data shape`);
-      if (fieldMeta.isUpdatedAt)
-        throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in data shape`);
-      if (typeof value === "function") {
-        let baseSchema = schemaBuilder.buildBaseFieldSchema(model, fieldName);
-        let fieldSchema;
-        try {
-          fieldSchema = value(baseSchema);
-        } catch (err) {
-          throw new ShapeError(
-            `Invalid inline refine for "${model}.${fieldName}": ${err.message}`,
-            { cause: err }
-          );
+}
+function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder) {
+  const modelFields = typeMap[model];
+  if (!modelFields)
+    throw new ShapeError(`Unknown model: ${model}`);
+  const schemaMap = {};
+  const forced = {};
+  for (const [fieldName, value] of Object.entries(dataConfig)) {
+    const fieldMeta = modelFields[fieldName];
+    if (!fieldMeta)
+      throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+    if (fieldMeta.isRelation)
+      throw new ShapeError(`Relation field "${fieldName}" cannot be used in data shape`);
+    if (fieldMeta.isUpdatedAt)
+      throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in data shape`);
+    if (typeof value === "function") {
+      let baseSchema = schemaBuilder.buildBaseFieldSchema(model, fieldName);
+      let refined;
+      try {
+        refined = value(baseSchema);
+      } catch (err) {
+        throw new ShapeError(
+          `Invalid inline refine for "${model}.${fieldName}": ${err.message}`,
+          { cause: err }
+        );
+      }
+      if (!isZodSchema2(refined)) {
+        throw new ShapeError(`Inline refine for "${model}.${fieldName}" must return a Zod schema`);
+      }
+      let fieldSchema = refined;
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          fieldSchema = fieldSchema.optional();
         }
-        if (mode === "create") {
-          if (!fieldMeta.isRequired || fieldMeta.hasDefault) {
-            fieldSchema = fieldSchema.optional();
-          }
+      } else {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
         } else {
-          if (!fieldMeta.isRequired) {
-            fieldSchema = fieldSchema.nullable().optional();
-          } else {
-            fieldSchema = fieldSchema.optional();
-          }
+          fieldSchema = fieldSchema.optional();
         }
-        schemaMap[fieldName] = fieldSchema;
-      } else if (value === true) {
-        let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
-        if (mode === "create") {
-          if (!fieldMeta.isRequired || fieldMeta.hasDefault) {
-            fieldSchema = fieldSchema.optional();
-          }
-        } else {
-          if (!fieldMeta.isRequired) {
-            fieldSchema = fieldSchema.nullable().optional();
-          } else {
-            fieldSchema = fieldSchema.optional();
-          }
+      }
+      schemaMap[fieldName] = fieldSchema;
+    } else if (value === true) {
+      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          fieldSchema = fieldSchema.optional();
         }
-        schemaMap[fieldName] = fieldSchema;
       } else {
-        let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
         if (!fieldMeta.isRequired) {
-          fieldSchema = fieldSchema.nullable();
-        }
-        let parsed;
-        try {
-          parsed = fieldSchema.parse(value);
-        } catch (err) {
-          throw new ShapeError(
-            `Invalid forced data value for "${model}.${fieldName}": ${err.message}`
-          );
+          fieldSchema = fieldSchema.nullable().optional();
+        } else {
+          fieldSchema = fieldSchema.optional();
         }
-        forced[fieldName] = parsed;
       }
-    }
-    return {
-      schema: z5.object(schemaMap).strict(),
-      forced
-    };
-  }
-  function resolveShape(input, body) {
-    if (isSingleShape(input)) {
-      const wasDynamic2 = typeof input === "function";
-      const shape2 = wasDynamic2 ? input(contextFn()) : input;
-      const parsed2 = body === void 0 || body === null ? {} : requireBody(body);
-      if ("caller" in parsed2) {
-        throw new CallerError(
-          'Named shape routing is not configured on this guard. Remove "caller" from the request body or use a named shape map.'
-        );
-      }
-      return { shape: shape2, body: parsed2, matchedKey: "_default", wasDynamic: wasDynamic2 };
-    }
-    const namedMap = input;
-    for (const key of Object.keys(namedMap)) {
-      if (GUARD_SHAPE_KEYS.has(key)) {
-        throw new ShapeError(
-          `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
-        );
+      schemaMap[fieldName] = fieldSchema;
+    } else {
+      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      if (!fieldMeta.isRequired) {
+        fieldSchema = fieldSchema.nullable();
       }
-      const val = namedMap[key];
-      if (typeof val !== "function" && !isGuardShape(val)) {
+      let parsed;
+      try {
+        parsed = fieldSchema.parse(value);
+      } catch (err) {
         throw new ShapeError(
-          `Named shape value for "${key}" must be a guard shape object or function`
+          `Invalid forced data value for "${model}.${fieldName}": ${err.message}`
         );
       }
+      forced[fieldName] = parsed;
     }
-    const parsed = requireBody(body);
-    const caller = parsed.caller;
-    if (typeof caller !== "string") {
-      throw new CallerError('Missing "caller" field in request body');
+  }
+  return {
+    schema: z8.object(schemaMap).strict(),
+    forced
+  };
+}
+function validateAndMergeData(bodyData, cached, method) {
+  if (bodyData === void 0 || bodyData === null) {
+    throw new ShapeError(`${method} requires "data" in request body`);
+  }
+  const validated = cached.schema.parse(bodyData);
+  return { ...validated, ...cached.forced };
+}
+function hasDataRefines(dataConfig) {
+  for (const value of Object.values(dataConfig)) {
+    if (typeof value === "function")
+      return true;
+  }
+  return false;
+}
+
+// src/runtime/model-guard-resolve.ts
+function isGuardShape(obj) {
+  if (!isPlainObject(obj))
+    return false;
+  const keys = Object.keys(obj);
+  return keys.length === 0 || keys.every((k) => GUARD_SHAPE_KEYS.has(k));
+}
+function isSingleShape(input) {
+  return typeof input === "function" || isGuardShape(input);
+}
+function requireBody(body) {
+  if (!isPlainObject(body))
+    throw new ShapeError("Request body must be an object");
+  return body;
+}
+function resolveDynamicShape(fn, contextFn) {
+  const ctx = validateContext(contextFn());
+  let result;
+  try {
+    result = fn(ctx);
+  } catch (err) {
+    throw new ShapeError(
+      `Dynamic shape function threw: ${err.message}`,
+      { cause: err }
+    );
+  }
+  if (!isPlainObject(result)) {
+    throw new ShapeError("Dynamic shape function must return a plain object");
+  }
+  return result;
+}
+function resolveShape(input, body, contextFn, caller) {
+  if (isSingleShape(input)) {
+    const wasDynamic2 = typeof input === "function";
+    const shape2 = wasDynamic2 ? resolveDynamicShape(input, contextFn) : input;
+    const parsed2 = body === void 0 || body === null ? {} : requireBody(body);
+    return { shape: shape2, body: parsed2, matchedKey: "_default", wasDynamic: wasDynamic2 };
+  }
+  const namedMap = input;
+  for (const key of Object.keys(namedMap)) {
+    if (GUARD_SHAPE_KEYS.has(key)) {
+      throw new ShapeError(
+        `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
+      );
     }
-    const patterns = Object.keys(namedMap);
-    const matched = matchCallerPattern(patterns, caller);
-    if (!matched) {
-      throw new CallerError(
-        `Unknown caller: "${caller}". Allowed: ${patterns.map((k) => `"${k}"`).join(", ")}`
+    const val = namedMap[key];
+    if (typeof val !== "function" && !isGuardShape(val)) {
+      throw new ShapeError(
+        `Named shape value for "${key}" must be a guard shape object or function`
       );
     }
-    const shapeOrFn = namedMap[matched];
-    const wasDynamic = typeof shapeOrFn === "function";
-    const shape = wasDynamic ? shapeOrFn(contextFn()) : shapeOrFn;
-    const { caller: _, ...rest } = parsed;
-    return { shape, body: rest, matchedKey: matched, wasDynamic };
   }
-  function requireBody(body) {
-    if (!isPlainObject(body))
-      throw new ShapeError("Request body must be an object");
-    return body;
+  const parsed = requireBody(body);
+  if ("caller" in parsed) {
+    throw new CallerError(
+      "Pass caller as second argument to .guard() or via context function, not in the request body."
+    );
+  }
+  if (typeof caller !== "string") {
+    const patterns2 = Object.keys(namedMap);
+    throw new CallerError(
+      `Missing caller. This guard uses named shape routing with keys: ${patterns2.map((k) => `"${k}"`).join(", ")}. Provide caller as second argument to .guard() or set "caller" in the context function.`
+    );
   }
-  function validateAndMergeData(bodyData, cached, method) {
-    if (bodyData === void 0 || bodyData === null) {
-      throw new ShapeError(`${method} requires "data" in request body`);
-    }
-    const validated = cached.schema.parse(bodyData);
-    return { ...validated, ...cached.forced };
+  const patterns = Object.keys(namedMap);
+  const matched = matchCallerPattern(patterns, caller);
+  if (!matched) {
+    throw new CallerError(
+      `Unknown caller: "${caller}". Allowed: ${patterns.map((k) => `"${k}"`).join(", ")}`
+    );
+  }
+  const shapeOrFn = namedMap[matched];
+  const wasDynamic = typeof shapeOrFn === "function";
+  const shape = wasDynamic ? resolveDynamicShape(shapeOrFn, contextFn) : shapeOrFn;
+  return { shape, body: parsed, matchedKey: matched, wasDynamic };
+}
+
+// src/runtime/model-guard.ts
+var UNIQUE_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete"]);
+var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "updateMany",
+  "updateManyAndReturn",
+  "deleteMany"
+]);
+var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "delete",
+  "createManyAndReturn",
+  "updateManyAndReturn"
+]);
+var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set([
+  "createMany",
+  "createManyAndReturn"
+]);
+function createModelGuardExtension(config) {
+  const { typeMap, enumMap, zodChains, zodDefaults, uniqueMap, scopeMap, contextFn } = config;
+  const wrapZodErrors = config.wrapZodErrors ?? false;
+  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap);
+  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap);
+  const modelScopeFks = /* @__PURE__ */ new Map();
+  for (const [model, entries] of Object.entries(scopeMap)) {
+    const fks = /* @__PURE__ */ new Set();
+    for (const entry of entries)
+      fks.add(entry.fk);
+    modelScopeFks.set(model, fks);
   }
   function maybeValidateUniqueWhere(modelName, shape, method) {
     if (!UNIQUE_MUTATION_METHODS.has(method))
       return;
     if (!shape.where)
       return;
-    validateUniqueEquality(modelName, shape.where, method, uniqueMap);
+    validateUniqueEquality(modelName, shape.where, method, uniqueMap, typeMap);
   }
-  function hasDataRefines(dataConfig) {
-    for (const value of Object.values(dataConfig)) {
-      if (typeof value === "function")
-        return true;
-    }
-    return false;
-  }
-  function createGuardedMethods(modelName, modelDelegate, input) {
+  function createGuardedMethods(modelName, modelDelegate, input, explicitCaller) {
     function callDelegate(method, args) {
       if (typeof modelDelegate[method] !== "function") {
         throw new ShapeError(`Method "${method}" is not available on this model`);
       }
       return modelDelegate[method](args);
     }
+    function resolveCaller() {
+      if (explicitCaller !== void 0)
+        return explicitCaller;
+      const ctx = validateContext(contextFn());
+      const c = ctx.caller;
+      if (typeof c === "string")
+        return c;
+      return void 0;
+    }
     const readShapeCache = /* @__PURE__ */ new Map();
     const dataSchemaCache = /* @__PURE__ */ new Map();
     const whereBuiltCache = /* @__PURE__ */ new Map();
@@ -2272,11 +2523,11 @@ function createModelGuardExtension(config) {
         const cached = dataSchemaCache.get(cacheKey);
         if (cached)
           return cached;
-        const built = buildDataSchema(modelName, dataConfig, mode);
+        const built = buildDataSchema(modelName, dataConfig, mode, typeMap, schemaBuilder);
         dataSchemaCache.set(cacheKey, built);
         return built;
       }
-      return buildDataSchema(modelName, dataConfig, mode);
+      return buildDataSchema(modelName, dataConfig, mode, typeMap, schemaBuilder);
     }
     function getWhereBuilt(whereConfig, matchedKey, wasDynamic) {
       if (!wasDynamic) {
@@ -2317,7 +2568,7 @@ function createModelGuardExtension(config) {
         forcedSelectCountWhere = result.forcedCountWhere;
       }
       return {
-        zodSchema: z5.object(schemaFields).strict(),
+        zodSchema: z9.object(schemaFields).strict(),
         forcedIncludeTree,
         forcedSelectTree,
         forcedIncludeCountWhere,
@@ -2383,8 +2634,8 @@ function createModelGuardExtension(config) {
       if (built.schema) {
         validatedWhere = built.schema.parse(bodyWhere);
       }
-      if (Object.keys(built.forced).length > 0) {
-        return preserveUnique ? mergeUniqueForced(validatedWhere, built.forced) : mergeForced(validatedWhere, built.forced);
+      if (hasWhereForced(built.forced)) {
+        return preserveUnique ? mergeUniqueWhereForced(validatedWhere, built.forced) : mergeWhereForced(validatedWhere, built.forced);
       }
       return validatedWhere ?? {};
     }
@@ -2397,14 +2648,15 @@ function createModelGuardExtension(config) {
     }
     function makeReadMethod(method) {
       return (body) => {
-        const { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
-        if (shape.data) {
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (resolved.shape.data) {
           throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
         }
-        const { data: _, ...queryShape } = shape;
-        const built = getReadShape(method, queryShape, matchedKey, wasDynamic);
+        const { data: _, ...queryShape } = resolved.shape;
+        const built = getReadShape(method, queryShape, resolved.matchedKey, resolved.wasDynamic);
         const isUnique = UNIQUE_READ_METHODS.has(method);
-        const args = applyBuiltShape(built, parsed, isUnique);
+        const args = applyBuiltShape(built, resolved.body, isUnique);
         if (isUnique && args.where) {
           validateResolvedUniqueWhere(
             modelName,
@@ -2417,33 +2669,51 @@ function createModelGuardExtension(config) {
       };
     }
     function makeCreateMethod(method) {
+      const isBatch = BATCH_CREATE_METHODS.has(method);
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
-      const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_CREATE_PROJECTION : ALLOWED_BODY_KEYS_CREATE;
+      let allowedBodyKeys;
+      if (isBatch && supportsProjection) {
+        allowedBodyKeys = ALLOWED_BODY_KEYS_CREATE_MANY_PROJECTION;
+      } else if (isBatch) {
+        allowedBodyKeys = ALLOWED_BODY_KEYS_CREATE_MANY;
+      } else if (supportsProjection) {
+        allowedBodyKeys = ALLOWED_BODY_KEYS_CREATE_PROJECTION;
+      } else {
+        allowedBodyKeys = ALLOWED_BODY_KEYS_CREATE;
+      }
       const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_CREATE_PROJECTION : VALID_SHAPE_KEYS_CREATE;
       return (body) => {
-        const { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
-        if (!shape.data)
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (!resolved.shape.data)
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
-        validateMutationShapeKeys(shape, allowedShapeKeys, method);
-        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
-        validateCreateCompleteness(modelName, shape.data);
-        const dataSchema = getDataSchema("create", shape.data, matchedKey, wasDynamic);
+        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
+        validateCreateCompleteness(modelName, resolved.shape.data, typeMap, fks, zodDefaults);
+        const dataSchema = getDataSchema("create", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
         let args;
         if (method === "create") {
-          const data = validateAndMergeData(parsed.data, dataSchema, method);
+          const data = validateAndMergeData(resolved.body.data, dataSchema, method);
           args = { data };
         } else {
-          if (!Array.isArray(parsed.data))
+          if (!Array.isArray(resolved.body.data))
             throw new ShapeError(`${method} expects data to be an array`);
-          if (parsed.data.length === 0)
+          if (resolved.body.data.length === 0)
             throw new ShapeError(`${method} received empty data array`);
-          const data = parsed.data.map(
+          const data = resolved.body.data.map(
             (item) => validateAndMergeData(item, dataSchema, method)
           );
           args = { data };
         }
+        if (isBatch && resolved.body.skipDuplicates !== void 0) {
+          if (typeof resolved.body.skipDuplicates !== "boolean") {
+            throw new ShapeError(`${method} skipDuplicates must be a boolean`);
+          }
+          args.skipDuplicates = resolved.body.skipDuplicates;
+        }
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(shape, parsed, method, matchedKey, wasDynamic);
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -2456,18 +2726,19 @@ function createModelGuardExtension(config) {
       const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_UPDATE_PROJECTION : ALLOWED_BODY_KEYS_UPDATE;
       const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_UPDATE_PROJECTION : VALID_SHAPE_KEYS_UPDATE;
       return (body) => {
-        const { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
-        if (!shape.data)
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (!resolved.shape.data)
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
-        validateMutationShapeKeys(shape, allowedShapeKeys, method);
-        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
-        if (isBulk && !shape.where) {
+        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        if (isBulk && !resolved.shape.where) {
           throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
         }
-        maybeValidateUniqueWhere(modelName, shape, method);
-        const dataSchema = getDataSchema("update", shape.data, matchedKey, wasDynamic);
-        const data = validateAndMergeData(parsed.data, dataSchema, method);
-        const where = isUniqueWhere ? requireWhere(shape, parsed.where, method, true, matchedKey, wasDynamic) : buildWhereFromShape(shape, parsed.where, false, matchedKey, wasDynamic);
+        maybeValidateUniqueWhere(modelName, resolved.shape, method);
+        const dataSchema = getDataSchema("update", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
+        const data = validateAndMergeData(resolved.body.data, dataSchema, method);
+        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
         if (isBulk && Object.keys(where).length === 0) {
           throw new ShapeError(`${method} requires at least one where condition`);
         }
@@ -2476,7 +2747,7 @@ function createModelGuardExtension(config) {
         }
         const args = { data, where };
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(shape, parsed, method, matchedKey, wasDynamic);
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -2489,16 +2760,17 @@ function createModelGuardExtension(config) {
       const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_DELETE_PROJECTION : ALLOWED_BODY_KEYS_DELETE;
       const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_DELETE_PROJECTION : VALID_SHAPE_KEYS_DELETE;
       return (body) => {
-        const { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
-        if (shape.data)
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (resolved.shape.data)
           throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
-        validateMutationShapeKeys(shape, allowedShapeKeys, method);
-        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
-        if (isBulk && !shape.where) {
+        validateMutationShapeKeys(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        if (isBulk && !resolved.shape.where) {
           throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
         }
-        maybeValidateUniqueWhere(modelName, shape, method);
-        const where = isUniqueWhere ? requireWhere(shape, parsed.where, method, true, matchedKey, wasDynamic) : buildWhereFromShape(shape, parsed.where, false, matchedKey, wasDynamic);
+        maybeValidateUniqueWhere(modelName, resolved.shape, method);
+        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
         if (isBulk && Object.keys(where).length === 0) {
           throw new ShapeError(`${method} requires at least one where condition`);
         }
@@ -2507,7 +2779,7 @@ function createModelGuardExtension(config) {
         }
         const args = { where };
         if (supportsProjection) {
-          const projectionArgs = resolveProjection(shape, parsed, method, matchedKey, wasDynamic);
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
           Object.assign(args, projectionArgs);
         }
         return callDelegate(method, args);
@@ -2539,7 +2811,7 @@ function createModelGuardExtension(config) {
         try {
           return fn(body);
         } catch (err) {
-          if (err instanceof z5.ZodError) {
+          if (err instanceof z9.ZodError) {
             throw new ShapeError(
               `Validation failed: ${formatZodError(err)}`,
               { cause: err }
@@ -2553,16 +2825,16 @@ function createModelGuardExtension(config) {
   }
   return {
     $allModels: {
-      guard(input) {
+      guard(input, caller) {
         const modelName = this.$name;
-        const delegateKey = modelName[0].toLowerCase() + modelName.slice(1);
+        const delegateKey = toDelegateKey(modelName);
         const modelDelegate = this.$parent[delegateKey];
         if (!modelDelegate) {
           throw new ShapeError(
             `Could not resolve Prisma delegate for model "${modelName}" (key: "${delegateKey}")`
           );
         }
-        const methods = createGuardedMethods(modelName, modelDelegate, input);
+        const methods = createGuardedMethods(modelName, modelDelegate, input, caller);
         if (!wrapZodErrors)
           return methods;
         return wrapMethods(methods);
@@ -2572,12 +2844,6 @@ function createModelGuardExtension(config) {
 }
 
 // src/runtime/guard.ts
-function formatZodError2(err) {
-  return err.issues.map((i) => {
-    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
-    return `${p}${i.message}`;
-  }).join("; ");
-}
 function createGuard(config) {
   const schemaBuilder = createSchemaBuilder(
     config.typeMap,
@@ -2593,7 +2859,7 @@ function createGuard(config) {
   const wrapZodErrors = config.wrapZodErrors ?? false;
   function rethrowZod(err) {
     if (err instanceof ZodError) {
-      throw new ShapeError(`Validation failed: ${formatZodError2(err)}`, { cause: err });
+      throw new ShapeError(`Validation failed: ${formatZodError(err)}`, { cause: err });
     }
     throw err;
   }
@@ -2630,16 +2896,24 @@ function createGuard(config) {
       };
     },
     extension: (contextFn) => {
+      const scopeRoots = /* @__PURE__ */ new Set();
+      for (const entries of Object.values(config.scopeMap)) {
+        for (const entry of entries) {
+          scopeRoots.add(entry.root);
+        }
+      }
       const scopeCtxFn = () => {
-        const ctx = contextFn();
+        const ctx = validateContext(contextFn());
         const scopeCtx = {};
         for (const key of Object.keys(ctx)) {
+          if (!scopeRoots.has(key))
+            continue;
           const val = ctx[key];
           if (typeof val === "string" || typeof val === "number" || typeof val === "bigint") {
             scopeCtx[key] = val;
           } else if (val !== null && val !== void 0) {
             log.warn(
-              `prisma-guard: Context key "${key}" has non-primitive value (${typeof val}). Only string, number, and bigint values are used for scope context.`
+              `prisma-guard: Scope root "${key}" has non-primitive value (${typeof val}). Only string, number, and bigint values are used for scope context.`
             );
           }
         }
@@ -2655,6 +2929,7 @@ function createGuard(config) {
         typeMap: config.typeMap,
         enumMap: config.enumMap,
         zodChains: config.zodChains,
+        zodDefaults: config.zodDefaults ?? {},
         uniqueMap: config.uniqueMap ?? {},
         scopeMap: config.scopeMap,
         contextFn,