prisma-guard 1.1.0 → 1.2.1

package/dist/runtime/index.js

@@ -26,19 +26,25 @@ var CallerError = class extends Error {
     this.name = "CallerError";
   }
 };
-
-// src/runtime/schema-builder.ts
-import { z as z3 } from "zod";
-
-// src/runtime/zod-type-map.ts
-import { z as z2 } from "zod";
+function formatZodError(err) {
+  return err.issues.map((i) => {
+    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+    return `${p}${i.message}`;
+  }).join("; ");
+}
 
 // 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 +58,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 +73,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;
       }
@@ -73,39 +83,54 @@ function isJsonSafe(value) {
   }
   return true;
 }
-var SCALAR_BASE = {
-  String: () => z.string(),
-  Int: () => z.number().int(),
-  Float: () => z.number(),
-  Decimal: () => z.union([
-    z.number(),
-    z.string().refine(
-      (s) => /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/.test(s),
-      "Invalid decimal string"
-    )
-  ]),
-  BigInt: () => z.union([
-    z.bigint(),
-    z.number().int().refine(
-      (v) => v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER,
-      "Number exceeds safe integer range for BigInt conversion"
-    ).transform((v) => BigInt(v)),
-    z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
-  ]),
-  Boolean: () => z.boolean(),
-  DateTime: () => z.union([
-    z.date(),
-    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)"),
-  Bytes: () => z.union([
-    z.string(),
-    z.custom((v) => v instanceof Uint8Array)
-  ])
-};
+var DECIMAL_REGEX = /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/;
+var decimalStringSchema = z.string().refine(
+  (s) => DECIMAL_REGEX.test(s),
+  "Invalid decimal string"
+);
+var decimalObjectSchema = z.custom(
+  (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
+  "Expected Decimal-compatible object"
+);
+function createDecimalFactory(strict) {
+  if (strict) {
+    return () => z.union([decimalStringSchema, decimalObjectSchema]);
+  }
+  return () => z.union([z.number(), decimalStringSchema, decimalObjectSchema]);
+}
+function createScalarBase(strictDecimal) {
+  return {
+    String: () => z.string(),
+    Int: () => z.number().int(),
+    Float: () => z.number(),
+    Decimal: createDecimalFactory(strictDecimal),
+    BigInt: () => z.union([
+      z.bigint(),
+      z.number().int().refine(
+        (v) => v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER,
+        "Number exceeds safe integer range for BigInt conversion"
+      ).transform((v) => BigInt(v)),
+      z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
+    ]),
+    Boolean: () => z.boolean(),
+    DateTime: () => z.union([
+      z.date(),
+      z.string().datetime({ offset: true })
+    ]).pipe(z.coerce.date()),
+    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)
+    ])
+  };
+}
+var SCALAR_BASE = createScalarBase(false);
+
+// src/runtime/schema-builder.ts
+import { z as z3 } from "zod";
 
 // src/runtime/zod-type-map.ts
+import { z as z2 } from "zod";
 var SCALAR_OPERATORS = {
   String: /* @__PURE__ */ new Set(["equals", "not", "contains", "startsWith", "endsWith", "in", "notIn"]),
   Int: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
@@ -130,7 +155,7 @@ function getSupportedOperators(fieldMeta) {
     return [];
   return [...ops];
 }
-function createBaseType(fieldMeta, enumMap) {
+function createBaseType(fieldMeta, enumMap, scalarBase) {
   let base;
   if (fieldMeta.isEnum) {
     const values = enumMap[fieldMeta.type];
@@ -139,7 +164,7 @@ function createBaseType(fieldMeta, enumMap) {
     }
     base = z2.enum(values);
   } else {
-    const factory = SCALAR_BASE[fieldMeta.type];
+    const factory = scalarBase[fieldMeta.type];
     if (!factory) {
       throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
     }
@@ -150,7 +175,7 @@ function createBaseType(fieldMeta, enumMap) {
   }
   return base;
 }
-function createScalarListOperatorSchema(fieldMeta, operator, enumMap) {
+function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   if (!SCALAR_LIST_OPERATORS.has(operator)) {
     throw new ShapeError(`Operator "${operator}" not supported for scalar list fields`);
   }
@@ -159,19 +184,19 @@ function createScalarListOperatorSchema(fieldMeta, operator, enumMap) {
   }
   if (operator === "equals") {
     const itemMeta2 = { ...fieldMeta, isList: false };
-    const itemBase2 = createBaseType(itemMeta2, enumMap);
+    const itemBase2 = createBaseType(itemMeta2, enumMap, scalarBase);
     return fieldMeta.isRequired ? z2.array(itemBase2) : z2.union([z2.array(itemBase2), z2.null()]);
   }
   const itemMeta = { ...fieldMeta, isList: false };
-  const itemBase = createBaseType(itemMeta, enumMap);
+  const itemBase = createBaseType(itemMeta, enumMap, scalarBase);
   if (operator === "has") {
     return !fieldMeta.isRequired ? z2.union([itemBase, z2.null()]) : itemBase;
   }
   return z2.array(itemBase);
 }
-function createOperatorSchema(fieldMeta, operator, enumMap) {
+function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   if (fieldMeta.isList) {
-    return createScalarListOperatorSchema(fieldMeta, operator, enumMap);
+    return createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase);
   }
   if (fieldMeta.isEnum) {
     const values = enumMap[fieldMeta.type];
@@ -200,7 +225,7 @@ function createOperatorSchema(fieldMeta, operator, enumMap) {
   if (!supportedOps.has(operator)) {
     throw new ShapeError(`Operator "${operator}" not supported for type "${fieldMeta.type}"`);
   }
-  const factory = SCALAR_BASE[fieldMeta.type];
+  const factory = scalarBase[fieldMeta.type];
   if (!factory) {
     throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
   }
@@ -217,6 +242,24 @@ function createOperatorSchema(fieldMeta, operator, enumMap) {
   return scalar;
 }
 
+// src/shared/utils.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;
+}
+function schemaProducesValueForUndefined(schema) {
+  const result = schema.safeParse(void 0);
+  return result.success && result.data !== void 0;
+}
+function isZodSchema(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.parse === "function" && typeof v.optional === "function";
+}
+
 // src/runtime/schema-builder.ts
 var DEFAULT_MAX_CACHE = 500;
 var DEFAULT_MAX_DEPTH = 5;
@@ -238,7 +281,7 @@ function lruSet(cache, key, value, maxSize) {
       cache.delete(oldest);
   }
 }
-function createSchemaBuilder(typeMap, zodChains, enumMap) {
+function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults) {
   const chainCache = /* @__PURE__ */ new Map();
   function buildFieldSchema(model, field) {
     const cacheKey = `${model}.${field}`;
@@ -251,7 +294,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
     const fieldMeta = modelFields[field];
     if (!fieldMeta)
       throw new ShapeError(`Unknown field "${field}" on model "${model}"`);
-    const base = createBaseType(fieldMeta, enumMap);
+    const base = createBaseType(fieldMeta, enumMap, scalarBase);
     let result = base;
     const chainFn = zodChains[model]?.[field];
     if (chainFn) {
@@ -274,17 +317,19 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
     const fieldMeta = modelFields[field];
     if (!fieldMeta)
       throw new ShapeError(`Unknown field "${field}" on model "${model}"`);
-    return createBaseType(fieldMeta, enumMap);
+    return createBaseType(fieldMeta, enumMap, scalarBase);
   }
   function buildInputSchema(model, opts) {
     if (opts.pick && opts.omit) {
       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}`);
+    const zodDefaultFields = zodDefaults[model];
+    const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
     let fieldNames = Object.keys(modelFields).filter((name) => {
       const meta = modelFields[name];
       return !meta.isRelation && !meta.isUpdatedAt;
@@ -310,16 +355,39 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
     for (const name of fieldNames) {
       const fieldMeta = modelFields[name];
       let fieldSchema;
+      let handlesUndefined;
       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;
+        handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
       } else {
         fieldSchema = buildFieldSchema(model, name);
+        handlesUndefined = zodDefaultSet !== void 0 && zodDefaultSet.has(name);
       }
       if (mode === "create") {
         if (!fieldMeta.isRequired) {
-          fieldSchema = allowNull ? fieldSchema.nullable().optional() : fieldSchema.optional();
+          if (handlesUndefined) {
+            fieldSchema = allowNull ? fieldSchema.nullable() : fieldSchema;
+          } else {
+            fieldSchema = allowNull ? fieldSchema.nullable().optional() : fieldSchema.optional();
+          }
         } else if (fieldMeta.hasDefault) {
-          fieldSchema = fieldSchema.optional();
+          if (!handlesUndefined) {
+            fieldSchema = fieldSchema.optional();
+          }
         }
       } else {
         if (!fieldMeta.isRequired && allowNull) {
@@ -380,7 +448,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap) {
     const schemaMap = {};
     for (const name of scalarNames) {
       const fieldMeta = modelFields[name];
-      let fieldSchema = createBaseType(fieldMeta, enumMap);
+      let fieldSchema = createBaseType(fieldMeta, enumMap, scalarBase);
       if (!fieldMeta.isRequired) {
         fieldSchema = fieldSchema.nullable();
       }
@@ -410,10 +478,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 +494,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 +511,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([
@@ -461,8 +533,26 @@ var SHAPE_CONFIG_KEYS = /* @__PURE__ */ new Set([
 ]);
 var GUARD_SHAPE_KEYS = /* @__PURE__ */ new Set([
   "data",
+  "create",
+  "update",
   ...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);
+}
+var FORCED_MARKER = Symbol.for("prisma-guard.forced");
+function isForcedValue(v) {
+  return v !== null && typeof v === "object" && v[FORCED_MARKER] === true;
+}
+function force(value) {
+  const wrapper = { value };
+  wrapper[FORCED_MARKER] = true;
+  return wrapper;
+}
 
 // src/shared/match-caller.ts
 function matchCallerPattern(patterns, caller) {
@@ -504,124 +594,124 @@ function requireContext(ctx, label) {
     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/shared/deep-clone.ts
+function deepClone(value) {
+  if (value === null || value === void 0)
+    return value;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+      return value;
+    case "object": {
+      if (value instanceof Date)
+        return new Date(value.getTime());
+      if (value instanceof Uint8Array)
+        return value.slice();
+      if (Array.isArray(value))
+        return value.map(deepClone);
+      const proto = Object.getPrototypeOf(value);
+      if (proto !== Object.prototype && proto !== null)
+        return value;
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = deepClone(v);
+      }
+      return result;
+    }
+    default:
+      return value;
+  }
 }
-function mergeForced(where, forced) {
-  if (!where)
-    return forced;
-  return { AND: [where, forced] };
+
+// 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 mergeWhereForced(where, forced) {
+  if (!hasWhereForced(forced))
+    return where ?? {};
+  let result = where ? deepClone(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 = deepClone(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 = [deepClone(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,19 +721,24 @@ 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;
 }
+function buildCountForPlacement(countWhere) {
+  const countSelect = {};
+  for (const [countRel, countForced] of Object.entries(countWhere)) {
+    countSelect[countRel] = { where: mergeWhereForced(void 0, countForced) };
+  }
+  return { _count: { select: countSelect } };
+}
 function applyForcedTree(validated, key, tree) {
   const container = validated[key];
   if (!container)
@@ -654,8 +749,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);
@@ -665,13 +761,11 @@ function applyForcedTree(validated, key, tree) {
         applyForcedTree(expanded, "select", 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) };
-        }
-        expanded._count = { select: countSelect };
+        const placement = forced._countWherePlacement ?? "include";
+        if (!expanded[placement])
+          expanded[placement] = {};
+        const placementObj = expanded[placement];
+        Object.assign(placementObj, buildCountForPlacement(forced._countWhere));
       }
       if (expanded.include && expanded.select) {
         throw new ShapeError(
@@ -683,10 +777,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) {
@@ -700,7 +794,11 @@ function applyForcedTree(validated, key, tree) {
         applyForcedTree(relObj, "select", forced.select);
       }
       if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
-        applyForcedCountWhere(relObj, forced._countWhere);
+        const placement = forced._countWherePlacement ?? "include";
+        const projContainer = relObj[placement];
+        if (projContainer) {
+          applyForcedCountWhere(projContainer, forced._countWhere);
+        }
       }
       if (relObj.include && relObj.select) {
         throw new ShapeError(
@@ -714,20 +812,19 @@ 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) };
-      }
-      nested._count = { select: countSelect };
+      const placement = forced._countWherePlacement ?? "include";
+      if (!nested[placement])
+        nested[placement] = {};
+      const placementObj = nested[placement];
+      Object.assign(placementObj, buildCountForPlacement(forced._countWhere));
     }
     result[relName] = Object.keys(nested).length > 0 ? nested : true;
   }
@@ -747,12 +844,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,21 +886,38 @@ function validateResolvedUniqueWhere(model, where, method, uniqueMap) {
     );
   }
 }
-function validateUniqueEquality(model, where, method, uniqueMap) {
+function collectEqualityFields(where, model, typeMap) {
+  const combinators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const fields = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "AND") {
+      if (isPlainObject(value)) {
+        for (const f of collectEqualityFields(value, model, typeMap)) {
+          fields.add(f);
+        }
+      }
+      continue;
+    }
+    if (combinators.has(key))
+      continue;
+    if (typeMap && model && typeMap[model]?.[key]?.isRelation)
+      continue;
+    if (!value || !isPlainObject(value))
+      continue;
+    if (Object.keys(value).every((op) => op === "equals")) {
+      fields.add(key);
+    }
+  }
+  return fields;
+}
+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 valid = constraints.some((constraint) => {
-    if (!constraint.every((field) => whereFields.has(field)))
-      return false;
-    return constraint.every((field) => {
-      const ops = where[field];
-      if (!ops)
-        return false;
-      return Object.keys(ops).every((op) => op === "equals");
-    });
-  });
+  const equalityFields = collectEqualityFields(where, model, typeMap);
+  const valid = constraints.some(
+    (constraint) => constraint.every((field) => equalityFields.has(field))
+  );
   if (!valid) {
     const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
     throw new ShapeError(
@@ -811,226 +925,430 @@ 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"]);
+var MAX_WHERE_DEPTH = 10;
+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 buildWhereSchema(model, whereConfig) {
+}
+function createWhereBuilder(typeMap, enumMap, scalarBase) {
+  function buildWhereSchema(model, whereConfig, depth) {
+    const currentDepth = depth ?? 0;
+    if (currentDepth > MAX_WHERE_DEPTH) {
+      throw new ShapeError(
+        `Where schema for model "${model}" exceeds maximum nesting depth (${MAX_WHERE_DEPTH}). Check for circular relation references in the shape.`
+      );
+    }
     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,
+          currentDepth
         );
-      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,
+          model,
+          fieldSchemas,
+          relationForced,
+          currentDepth
         );
+        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}`
-            );
-          }
-          fieldForced[op] = parsed;
-        }
+      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
       }
-      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.`
+    };
+  }
+  function processCombinator(key, value, model, fieldSchemas, parentConditions, parentRelations, depth) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`"${key}" in where shape must be an object defining allowed fields`);
+    }
+    const result = buildWhereSchema(model, value, depth + 1);
+    if (!result.schema && !hasWhereForced(result.forced)) {
+      throw new ShapeError(
+        `Empty "${key}" combinator in where shape for model "${model}". Define at least one field.`
+      );
+    }
+    if (result.schema) {
+      let elementSchema = result.schema;
+      if (!hasWhereForced(result.forced)) {
+        elementSchema = result.schema.refine(
+          (v) => v !== void 0 && v !== null && Object.keys(v).some((k) => v[k] !== void 0),
+          { message: `"${key}" member must specify at least one condition` }
         );
       }
-      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) {
-        forced[fieldName] = fieldForced;
+      if (key === "NOT") {
+        fieldSchemas[key] = z4.union([elementSchema, z4.array(elementSchema).min(1)]).optional();
+      } else {
+        fieldSchemas[key] = z4.array(elementSchema).min(1).optional();
       }
     }
-    const schema = Object.keys(fieldSchemas).length > 0 ? z4.object(fieldSchemas).strict().optional() : null;
-    return { schema, forced };
-  }
-  function buildCountFieldSchema(model, config, context) {
-    if (config === true) {
-      return z4.literal(true).optional();
-    }
-    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)
-          throw new ShapeError(
-            `Relation field "${fieldName}" cannot be used in ${context}`
-          );
+    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;
+          }
+        }
       }
-      fieldSchemas[fieldName] = z4.literal(true).optional();
     }
-    return z4.object(fieldSchemas).strict().optional();
   }
-  function buildIncludeCountSchema(model, config) {
-    const modelFields = typeMap[model];
-    if (!modelFields)
-      throw new ShapeError(`Unknown model: ${model}`);
-    if (config === true) {
-      return { schema: z4.literal(true).optional(), forcedCountWhere: {} };
+  function processRelationFilter(key, value, fieldMeta, model, fieldSchemas, parentRelations, depth) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`Relation filter for "${key}" must be an object with operators (some, every, none, is, isNot)`);
     }
-    if (!isPlainObject(config) || !("select" in config)) {
+    const allowedOps = fieldMeta.isList ? TO_MANY_RELATION_OPS : TO_ONE_RELATION_OPS;
+    if (Object.keys(value).length === 0) {
       throw new ShapeError(
-        `Invalid _count config on model "${model}". Expected true or { select: { ... } }`
+        `Empty relation filter for "${key}" on model "${model}". Define at least one operator: ${[...allowedOps].join(", ")}`
       );
     }
-    for (const key of Object.keys(config)) {
-      if (key !== "select") {
+    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(
-          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
+          `Operator "${op}" not supported for ${fieldMeta.isList ? "to-many" : "to-one"} relation "${key}". Allowed: ${allowed}`
         );
       }
-    }
-    const selectObj = config.select;
-    const countSelectFields = {};
-    const forcedCountWhere = {};
-    for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
+      if (!isPlainObject(opValue)) {
         throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in _count.select`
+          `Relation filter operator "${op}" on "${key}" must be an object defining nested where fields`
         );
-      if (!fieldMeta.isRelation)
+      }
+      const nested = buildWhereSchema(fieldMeta.type, opValue, depth + 1);
+      if (!nested.schema && !hasWhereForced(nested.forced)) {
         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}"`
+          `Empty nested where for relation "${key}.${op}" on model "${model}". Define at least one field.`
         );
-        if (fieldConfig.where) {
-          const relatedType = fieldMeta.type;
-          const { schema: whereSchema, forced } = buildWhereSchema(
-            relatedType,
-            fieldConfig.where
+      }
+      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` }
           );
-          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();
+          opSchemas[op] = nested.schema;
         }
+        hasClientOps = true;
+      }
+      if (hasWhereForced(nested.forced)) {
+        opForced[op] = nested.forced;
+      }
+    }
+    if (!hasClientOps && Object.keys(opForced).length === 0) {
+      throw new ShapeError(
+        `Relation filter for "${key}" on model "${model}" produced no conditions. Define at least one nested field in the operator shape.`
+      );
+    }
+    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 {
-        throw new ShapeError(
-          `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
-        );
+        fieldSchemas[key] = opObjSchema.optional();
       }
     }
-    const selectSchema = z4.object(countSelectFields).strict();
-    return {
-      schema: z4.object({ select: selectSchema }).strict().optional(),
-      forcedCountWhere
-    };
+    if (Object.keys(opForced).length > 0) {
+      parentRelations[key] = opForced;
+    }
   }
-  function buildAggregateFieldSchema(model, opName, fieldConfig) {
+  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 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, scalarBase).optional();
+        hasClientOps = true;
+        clientOpKeys.push(op);
+        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+          hasStringModeOp = true;
+        }
+      } else {
+        const actualOpValue = isForcedValue(opValue) ? opValue.value : opValue;
+        const opSchema = createOperatorSchema(fieldMeta, op, enumMap, scalarBase);
+        let parsed;
+        try {
+          parsed = opSchema.parse(actualOpValue);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid forced value for "${model}.${fieldName}.${op}": ${err.message}`
+          );
+        }
+        fieldForced[op] = parsed;
+      }
+    }
+    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;
+    }
+  }
+  return { buildWhereSchema };
+}
+
+// src/runtime/query-builder-args.ts
+import { z as z5 } from "zod";
+var UNSUPPORTED_BY_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+function requireConfigTrue(config, context) {
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== true) {
+      throw new ShapeError(
+        `Config value for "${key}" in ${context} must be true, got ${typeof value}`
+      );
+    }
+  }
+}
+function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
+  function buildOrderBySchema(model, orderByConfig) {
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
-    const isNumericOnly = opName === "_avg" || opName === "_sum";
-    const isComparableOnly = opName === "_min" || opName === "_max";
+    requireConfigTrue(orderByConfig, `orderBy on model "${model}"`);
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(fieldConfig)) {
-      if (fieldName === "_all" && opName === "_count") {
-        fieldSchemas[fieldName] = z4.literal(true).optional();
-        continue;
-      }
+    for (const fieldName of Object.keys(orderByConfig)) {
       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}"`);
       if (fieldMeta.isRelation)
-        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.`
-        );
+        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();
+    }
+    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}`);
+    }
+    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 (isComparableOnly && !COMPARABLE_TYPES.has(fieldMeta.type)) {
+      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}`);
+    requireConfigTrue(cursorConfig, `cursor on model "${model}"`);
+    const cursorFields = new Set(Object.keys(cursorConfig));
+    const constraints = uniqueMap[model];
+    if (constraints && constraints.length > 0) {
+      const covered = constraints.some(
+        (constraint) => constraint.length === cursorFields.size && constraint.every((field) => cursorFields.has(field))
+      );
+      if (!covered) {
+        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
         throw new ShapeError(
-          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only comparable types (Int, Float, Decimal, BigInt, String, DateTime) are supported.`
+          `cursor on model "${model}" must exactly match a unique constraint: ${constraintDesc}`
         );
       }
-      fieldSchemas[fieldName] = z4.literal(true).optional();
     }
-    return z4.object(fieldSchemas).strict().optional();
+    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, scalarBase);
+    }
+    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) {
@@ -1042,84 +1360,285 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
     for (const fieldName of byConfig) {
       const fieldMeta = modelFields[fieldName];
       if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in by`
-        );
+        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`
-        );
+        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`
-        );
+        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in by`);
       }
-      if (fieldMeta.isList) {
+      if (fieldMeta.isList)
         throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
-      }
     }
-    const enumSchema = z4.enum(byConfig);
-    return z4.union([enumSchema, z4.array(enumSchema).min(1)]);
+    const enumSchema = z5.enum(byConfig);
+    return z5.union([enumSchema, z5.array(enumSchema).min(1)]);
   }
-  function buildCursorSchema(model, cursorConfig) {
+  function buildHavingSchema(model, havingConfig) {
     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}`
-        );
+    requireConfigTrue(havingConfig, `having on 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, scalarBase).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];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(fieldConfig, `${opName} on model "${model}"`);
+    const isNumericOnly = opName === "_avg" || opName === "_sum";
+    const isComparableOnly = opName === "_min" || opName === "_max";
     const fieldSchemas = {};
-    for (const fieldName of Object.keys(cursorConfig)) {
+    for (const fieldName of Object.keys(fieldConfig)) {
+      if (fieldName === "_all" && opName === "_count") {
+        fieldSchemas[fieldName] = 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 ${opName}`);
       if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${opName}`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in ${opName}`);
+      if (isNumericOnly && !NUMERIC_TYPES.has(fieldMeta.type)) {
         throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in cursor`
+          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only numeric types (Int, Float, Decimal, BigInt) are supported.`
         );
-      if (fieldMeta.isList)
+      }
+      if (isComparableOnly && !COMPARABLE_TYPES.has(fieldMeta.type)) {
         throw new ShapeError(
-          `List field "${fieldName}" cannot be used in cursor`
+          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only comparable types (Int, Float, Decimal, BigInt, String, DateTime) are supported.`
         );
-      fieldSchemas[fieldName] = createBaseType(fieldMeta, enumMap);
+      }
+      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 buildDistinctSchema(model, distinctConfig) {
+  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 distinctConfig) {
+    requireConfigTrue(config, `${context} on 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)
+          throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${context}`);
+      }
+      fieldSchemas[fieldName] = z5.literal(true).optional();
+    }
+    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 buildCountSelectSchema(model, selectConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(selectConfig, `count select on model "${model}"`);
+    const fieldSchemas = {};
+    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 distinct`
-        );
+        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] = z5.literal(true).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();
+  }
+  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"]);
+var MAX_PROJECTION_DEPTH = 10;
+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}`);
+    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(
-          `Relation field "${fieldName}" cannot be used in distinct`
+          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
         );
-      if (fieldMeta.isList)
+      }
+    }
+    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)) {
+        if (Object.keys(fieldConfig).length === 0) {
+          throw new ShapeError(
+            `Empty config for _count.select.${fieldName} on model "${model}". Use true or { where: { ... } }.`
+          );
+        }
+        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 } = 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 countSelectKeys = Object.keys(countSelectFields);
+    const selectSchema = z6.object(countSelectFields).strict().refine(
+      (v) => countSelectKeys.some((k) => v[k] !== void 0),
+      { message: "_count.select must specify at least one field" }
+    );
+    return {
+      schema: z6.object({ select: selectSchema }).strict().optional(),
+      forcedCountWhere
+    };
   }
-  function buildIncludeSchema(model, includeConfig) {
+  function buildIncludeSchema(model, includeConfig, depth) {
+    const currentDepth = depth ?? 0;
+    if (currentDepth > MAX_PROJECTION_DEPTH) {
+      throw new ShapeError(
+        `Include schema for model "${model}" exceeds maximum nesting depth (${MAX_PROJECTION_DEPTH}). Check for circular relation references in the shape.`
+      );
+    }
+    if (Object.keys(includeConfig).length === 0) {
+      throw new ShapeError(
+        `Empty include config on model "${model}". Define at least one relation.`
+      );
+    }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
@@ -1128,10 +1647,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 +1656,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 +1666,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,62 +1678,77 @@ 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) {
-          const nested = buildIncludeSchema(fieldMeta.type, config.include);
+          const nested = buildIncludeSchema(fieldMeta.type, config.include, currentDepth + 1);
           nestedSchemas["include"] = nested.schema;
           if (Object.keys(nested.forcedTree).length > 0)
             relForced.include = nested.forcedTree;
-          if (Object.keys(nested.forcedCountWhere).length > 0)
+          if (Object.keys(nested.forcedCountWhere).length > 0) {
             relForced._countWhere = nested.forcedCountWhere;
+            relForced._countWherePlacement = "include";
+          }
         }
         if (config.select) {
-          const nested = buildSelectSchema(fieldMeta.type, config.select);
+          const nested = buildSelectSchema(fieldMeta.type, config.select, currentDepth + 1);
           nestedSchemas["select"] = nested.schema;
           if (Object.keys(nested.forcedTree).length > 0)
             relForced.select = nested.forcedTree;
-          if (Object.keys(nested.forcedCountWhere).length > 0)
+          if (Object.keys(nested.forcedCountWhere).length > 0) {
             relForced._countWhere = nested.forcedCountWhere;
+            relForced._countWherePlacement = "select";
+          }
         }
         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;
       }
     }
+    const includeFieldKeys = Object.keys(fieldSchemas);
+    const baseSchema = z6.object(fieldSchemas).strict();
+    const schema = includeFieldKeys.length > 0 ? baseSchema.refine(
+      (v) => includeFieldKeys.some((k) => v[k] !== void 0),
+      { message: "include must specify at least one field" }
+    ).optional() : baseSchema.optional();
     return {
-      schema: z4.object(fieldSchemas).strict().optional(),
+      schema,
       forcedTree,
       forcedCountWhere: topLevelForcedCountWhere
     };
   }
-  function buildSelectSchema(model, selectConfig) {
+  function buildSelectSchema(model, selectConfig, depth) {
+    const currentDepth = depth ?? 0;
+    if (currentDepth > MAX_PROJECTION_DEPTH) {
+      throw new ShapeError(
+        `Select schema for model "${model}" exceeds maximum nesting depth (${MAX_PROJECTION_DEPTH}). Check for circular relation references in the shape.`
+      );
+    }
+    if (Object.keys(selectConfig).length === 0) {
+      throw new ShapeError(
+        `Empty select config on model "${model}". Define at least one field.`
+      );
+    }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
@@ -1230,26 +1757,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),
@@ -1266,208 +1786,114 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
         const nestedSchemas = {};
         const relForced = {};
         if (config.select) {
-          const nested = buildSelectSchema(fieldMeta.type, config.select);
+          const nested = buildSelectSchema(fieldMeta.type, config.select, currentDepth + 1);
           nestedSchemas["select"] = nested.schema;
           if (Object.keys(nested.forcedTree).length > 0)
             relForced.select = nested.forcedTree;
-          if (Object.keys(nested.forcedCountWhere).length > 0)
+          if (Object.keys(nested.forcedCountWhere).length > 0) {
             relForced._countWhere = nested.forcedCountWhere;
+            relForced._countWherePlacement = "select";
+          }
         }
         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
-          );
-        }
-        if (config.cursor) {
-          nestedSchemas["cursor"] = buildCursorSchema(
-            fieldMeta.type,
-            config.cursor
-          );
-        }
-        if (config.take) {
-          nestedSchemas["take"] = buildTakeSchema(config.take);
-        }
-        if (config.skip) {
-          nestedSchemas["skip"] = z4.number().int().min(0).optional();
-        }
-        const nestedObj = z4.object(nestedSchemas).strict();
-        fieldSchemas[fieldName] = z4.union([z4.literal(true), nestedObj]).optional();
-        if (Object.keys(relForced).length > 0)
-          forcedTree[fieldName] = relForced;
-      }
-    }
-    return {
-      schema: z4.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;
+          nestedSchemas["orderBy"] = deps.buildOrderBySchema(fieldMeta.type, config.orderBy);
+        }
+        if (config.cursor) {
+          nestedSchemas["cursor"] = deps.buildCursorSchema(fieldMeta.type, config.cursor);
+        }
+        if (config.take) {
+          nestedSchemas["take"] = deps.buildTakeSchema(config.take);
+        }
+        if (config.skip) {
+          nestedSchemas["skip"] = z6.number().int().min(0).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;
       }
-      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();
+    const selectFieldKeys = Object.keys(fieldSchemas);
+    const baseSchema = z6.object(fieldSchemas).strict();
+    const schema = selectFieldKeys.length > 0 ? baseSchema.refine(
+      (v) => selectFieldKeys.some((k) => v[k] !== void 0),
+      { message: "select must specify at least one field" }
+    ).optional() : baseSchema.optional();
+    return {
+      schema,
+      forcedTree,
+      forcedCountWhere: topLevelForcedCountWhere
+    };
+  }
+  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, scalarBase) {
+  const whereBuilder = createWhereBuilder(typeMap, enumMap, scalarBase);
+  const argsBuilder = createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  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 +1901,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 +1911,80 @@ 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 !== void 0) {
+      if (shape.skip !== true) {
+        throw new ShapeError('Shape config "skip" must be true');
+      }
+      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 +1999,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));
         }
       }
     }
@@ -1625,57 +2022,54 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
         [...builtCache.entries()].map(([k, v]) => [k, v.zodSchema])
       ),
       parse(body, opts) {
+        const normalizedBody = body === void 0 || body === null ? {} : body;
         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(normalizedBody))
             throw new ShapeError("Request body must be an object");
+          if ("caller" in normalizedBody) {
+            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);
+        return applyBuiltShape(built, normalizedBody, isUnique);
       }
     };
   }
   return {
     buildQuerySchema,
     buildShapeZodSchema,
-    buildWhereSchema,
-    buildIncludeSchema,
-    buildSelectSchema
+    buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildIncludeSchema: projectionBuilder.buildIncludeSchema,
+    buildSelectSchema: projectionBuilder.buildSelectSchema
   };
 }
 
@@ -1853,10 +2247,24 @@ function createScopeExtension(scopeMap, contextFn, guardConfig, logger) {
         const overrides = Object.fromEntries(
           presentScopes.map((s) => [s.fk, ctx[s.root]])
         );
+        const nextArgs = { ...args };
         if (operation === "upsert") {
-          throw new PolicyError(
-            `Scoped model "${model}" cannot use upsert via extension. Handle upsert explicitly in route logic.`
-          );
+          nextArgs.where = buildScopedUniqueWhere(args.where, conditions);
+          if (args.create !== void 0 && args.create !== null) {
+            if (typeof args.create !== "object" || Array.isArray(args.create)) {
+              throw new ShapeError(`upsert expects create to be an object`);
+            }
+            nextArgs.create = { ...args.create };
+            enforceDataScope(nextArgs.create, scopes, overrides, log, model, operation, onScopeRelationWrite, "create");
+          }
+          if (args.update !== void 0 && args.update !== null) {
+            if (typeof args.update !== "object" || Array.isArray(args.update)) {
+              throw new ShapeError(`upsert expects update to be an object`);
+            }
+            nextArgs.update = { ...args.update };
+            enforceDataScope(nextArgs.update, scopes, overrides, log, model, operation, onScopeRelationWrite, "mutate");
+          }
+          return query(nextArgs);
         }
         if (FIND_UNIQUE_OPS.has(operation)) {
           if (findUniqueMode === "reject") {
@@ -1866,7 +2274,6 @@ function createScopeExtension(scopeMap, contextFn, guardConfig, logger) {
           }
           return handleFindUnique(args, query, conditions, scopes, operation, log);
         }
-        const nextArgs = { ...args };
         if (READ_OPS.has(operation)) {
           nextArgs.where = buildAndConditions(args.where, conditions);
           return query(nextArgs);
@@ -1948,77 +2355,332 @@ async function handleFindUnique(args, query, conditions, scopes, operation, log)
       }
     }
   }
-  const result = await query(nextArgs);
-  if (result === null)
-    return result;
-  if (typeof result !== "object" || result === null) {
-    throw new ShapeError("findUnique result must be an object or null");
+  const result = await query(nextArgs);
+  if (result === null)
+    return result;
+  if (typeof result !== "object" || result === null) {
+    throw new ShapeError("findUnique result must be an object or null");
+  }
+  const resultObj = result;
+  let verifyObj = resultObj;
+  const missingFks = pickMissingFksFromResult(resultObj, fks);
+  if (missingFks.length > 0) {
+    const where = args?.where;
+    if (!where || typeof where !== "object" || Array.isArray(where)) {
+      throw new PolicyError(
+        `prisma-guard: Cannot verify scope \u2014 missing FK fields (${missingFks.join(", ")}) and findUnique args.where is not a valid object.`
+      );
+    }
+    let verifyResult;
+    try {
+      verifyResult = await query({ where, select: buildFkSelect(fks) });
+    } catch (err) {
+      throw new PolicyError(
+        `prisma-guard: Scope verification query failed for findUnique: ${err?.message ?? String(err)}`
+      );
+    }
+    if (verifyResult === null) {
+      throw new PolicyError("prisma-guard: Scope verification query returned null for an existing findUnique result");
+    }
+    if (typeof verifyResult !== "object" || verifyResult === null) {
+      throw new PolicyError("prisma-guard: Scope verification result must be an object");
+    }
+    verifyObj = verifyResult;
+  }
+  for (const condition of conditions) {
+    const [fk, value] = Object.entries(condition)[0];
+    if (!(fk in verifyObj)) {
+      throw new PolicyError(
+        `prisma-guard: Cannot verify scope on "${fk}" \u2014 field not present in verification result. Ensure FK fields are selectable.`
+      );
+    }
+    if (!looseEqual(verifyObj[fk], value, log, fk)) {
+      if (operation === "findUniqueOrThrow") {
+        throw new PolicyError("Record not accessible in current scope");
+      }
+      return null;
+    }
+  }
+  if (injectedFks.length > 0) {
+    const cleaned = { ...resultObj };
+    for (const fk of injectedFks) {
+      delete cleaned[fk];
+    }
+    return cleaned;
+  }
+  return result;
+}
+
+// src/runtime/model-guard.ts
+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"]);
+var ALLOWED_BODY_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
+var ALLOWED_BODY_KEYS_UPSERT = /* @__PURE__ */ new Set(["where", "create", "update", "select", "include"]);
+var VALID_SHAPE_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
+var VALID_SHAPE_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
+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 VALID_SHAPE_KEYS_UPSERT = /* @__PURE__ */ new Set(["where", "create", "update", "select", "include"]);
+function validateMutationBodyKeys(body, allowed, method) {
+  for (const key of Object.keys(body)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+function validateMutationShapeKeys(shape, allowed, method) {
+  for (const key of Object.keys(shape)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+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, typeMap, schemaBuilder, zodDefaults) {
+  const modelFields = typeMap[model];
+  if (!modelFields)
+    throw new ShapeError(`Unknown model: ${model}`);
+  const zodDefaultFields = zodDefaults[model];
+  const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
+  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 (!isZodSchema(refined)) {
+        throw new ShapeError(`Inline refine for "${model}.${fieldName}" must return a Zod schema`);
+      }
+      let fieldSchema = refined;
+      const handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = handlesUndefined ? fieldSchema.nullable() : fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          if (!handlesUndefined) {
+            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);
+      const isZodDefaultField = zodDefaultSet !== void 0 && zodDefaultSet.has(fieldName);
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = isZodDefaultField ? fieldSchema.nullable() : fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          if (!isZodDefaultField) {
+            fieldSchema = fieldSchema.optional();
+          }
+        }
+      } else {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else {
+          fieldSchema = fieldSchema.optional();
+        }
+      }
+      schemaMap[fieldName] = fieldSchema;
+    } else {
+      const actualValue = isForcedValue(value) ? value.value : value;
+      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      if (!fieldMeta.isRequired) {
+        fieldSchema = fieldSchema.nullable();
+      }
+      let parsed;
+      try {
+        parsed = fieldSchema.parse(actualValue);
+      } catch (err) {
+        throw new ShapeError(
+          `Invalid forced data value for "${model}.${fieldName}": ${err.message}`
+        );
+      }
+      forced[fieldName] = parsed;
+    }
+  }
+  if (mode === "create" && zodDefaultFields) {
+    for (const fieldName of zodDefaultFields) {
+      if (fieldName in dataConfig)
+        continue;
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        continue;
+      if (fieldMeta.isRelation)
+        continue;
+      if (fieldMeta.isUpdatedAt)
+        continue;
+      const fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      const result = fieldSchema.safeParse(void 0);
+      if (result.success && result.data !== void 0) {
+        forced[fieldName] = result.data;
+      } else {
+        throw new ShapeError(
+          `Field "${fieldName}" on model "${model}" has @zod default/catch but its schema does not produce a value for undefined input`
+        );
+      }
+    }
+  }
+  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, ...deepClone(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");
   }
-  const resultObj = result;
-  let verifyObj = resultObj;
-  const missingFks = pickMissingFksFromResult(resultObj, fks);
-  if (missingFks.length > 0) {
-    const where = args?.where;
-    if (!where || typeof where !== "object" || Array.isArray(where)) {
-      throw new PolicyError(
-        `prisma-guard: Cannot verify scope \u2014 missing FK fields (${missingFks.join(", ")}) and findUnique args.where is not a valid 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.`
       );
     }
-    let verifyResult;
-    try {
-      verifyResult = await query({ where, select: buildFkSelect(fks) });
-    } catch (err) {
-      throw new PolicyError(
-        `prisma-guard: Scope verification query failed for findUnique: ${err?.message ?? String(err)}`
+    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`
       );
     }
-    if (verifyResult === null) {
-      throw new PolicyError("prisma-guard: Scope verification query returned null for an existing findUnique result");
-    }
-    if (typeof verifyResult !== "object" || verifyResult === null) {
-      throw new PolicyError("prisma-guard: Scope verification result must be an object");
-    }
-    verifyObj = verifyResult;
   }
-  for (const condition of conditions) {
-    const [fk, value] = Object.entries(condition)[0];
-    if (!(fk in verifyObj)) {
-      throw new PolicyError(
-        `prisma-guard: Cannot verify scope on "${fk}" \u2014 field not present in verification result. Ensure FK fields are selectable.`
-      );
-    }
-    if (!looseEqual(verifyObj[fk], value, log, fk)) {
-      if (operation === "findUniqueOrThrow") {
-        throw new PolicyError("Record not accessible in current scope");
-      }
-      return null;
-    }
+  const parsed = body === void 0 || body === null ? {} : 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 (injectedFks.length > 0) {
-    const cleaned = { ...resultObj };
-    for (const fk of injectedFks) {
-      delete cleaned[fk];
-    }
-    return cleaned;
+  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.`
+    );
   }
-  return result;
+  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
-import { z as z5 } 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_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"]);
-var ALLOWED_BODY_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
-var VALID_SHAPE_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
-var VALID_SHAPE_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
-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_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete", "upsert"]);
 var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
 var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateMany",
@@ -2028,228 +2690,187 @@ var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
 var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "create",
   "update",
+  "upsert",
   "delete",
   "createManyAndReturn",
   "updateManyAndReturn"
 ]);
-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 validateMutationBodyKeys(body, allowed, method) {
-  for (const key of Object.keys(body)) {
-    if (!allowed.has(key)) {
-      throw new ShapeError(
-        `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
-      );
+var BATCH_CREATE_METHODS = /* @__PURE__ */ new Set([
+  "createMany",
+  "createManyAndReturn"
+]);
+function buildDefaultSelectInput(config) {
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      result[key] = buildDefaultCountInput(value);
+      continue;
+    }
+    if (value === true) {
+      result[key] = true;
+    } else {
+      const nested = {};
+      if (value.select)
+        nested.select = buildDefaultSelectInput(value.select);
+      result[key] = Object.keys(nested).length > 0 ? nested : true;
     }
   }
+  return result;
 }
-function validateMutationShapeKeys(shape, allowed, method) {
-  for (const key of Object.keys(shape)) {
-    if (!allowed.has(key)) {
-      throw new ShapeError(
-        `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`
-      );
+function buildDefaultIncludeInput(config) {
+  const result = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      result[key] = buildDefaultCountInput(value);
+      continue;
+    }
+    if (value === true) {
+      result[key] = true;
+    } else {
+      const nested = {};
+      if (value.include)
+        nested.include = buildDefaultIncludeInput(value.include);
+      if (value.select)
+        nested.select = buildDefaultSelectInput(value.select);
+      result[key] = Object.keys(nested).length > 0 ? nested : true;
     }
   }
+  return result;
 }
-function formatZodError(err) {
-  return err.issues.map((i) => {
-    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
-    return `${p}${i.message}`;
-  }).join("; ");
+function buildDefaultCountInput(config) {
+  if (config === true)
+    return true;
+  if (!isPlainObject(config) || !config.select || !isPlainObject(config.select))
+    return true;
+  const selectObj = config.select;
+  const result = {};
+  for (const key of Object.keys(selectObj)) {
+    result[key] = true;
+  }
+  return { select: result };
 }
-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 buildDefaultProjectionBody(shape) {
+  if (shape.select) {
+    return { select: buildDefaultSelectInput(shape.select) };
   }
-  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`
-      );
-    }
+  if (shape.include) {
+    return { include: buildDefaultIncludeInput(shape.include) };
   }
-  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 }
-          );
-        }
-        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 || fieldMeta.hasDefault) {
-            fieldSchema = fieldSchema.optional();
-          }
-        } else {
-          if (!fieldMeta.isRequired) {
-            fieldSchema = fieldSchema.nullable().optional();
-          } else {
-            fieldSchema = fieldSchema.optional();
+  return {};
+}
+function hasClientControlledValues(obj) {
+  for (const value of Object.values(obj)) {
+    if (isForcedValue(value))
+      continue;
+    if (value === true)
+      return true;
+    if (isPlainObject(value) && hasClientControlledValues(value))
+      return true;
+  }
+  return false;
+}
+function checkIncludeForClientArgs(config) {
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      if (value !== true && isPlainObject(value) && isPlainObject(value.select)) {
+        const selectObj = value.select;
+        for (const entryVal of Object.values(selectObj)) {
+          if (isPlainObject(entryVal) && entryVal.where) {
+            const w = entryVal.where;
+            if (isPlainObject(w) && hasClientControlledValues(w))
+              return true;
           }
         }
-        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}`
-          );
-        }
-        forced[fieldName] = parsed;
       }
+      continue;
     }
-    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.`
-        );
-      }
-      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`
-        );
+    if (value === true)
+      continue;
+    if (value.orderBy || value.cursor || value.take || value.skip)
+      return true;
+    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where))
+      return true;
+    if (value.include && checkIncludeForClientArgs(value.include))
+      return true;
+    if (value.select && checkSelectForClientArgs(value.select))
+      return true;
+  }
+  return false;
+}
+function checkSelectForClientArgs(config) {
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      if (value !== true && isPlainObject(value) && isPlainObject(value.select)) {
+        const selectObj = value.select;
+        for (const entryVal of Object.values(selectObj)) {
+          if (isPlainObject(entryVal) && entryVal.where) {
+            const w = entryVal.where;
+            if (isPlainObject(w) && hasClientControlledValues(w))
+              return true;
+          }
+        }
       }
+      continue;
     }
-    const parsed = requireBody(body);
-    const caller = parsed.caller;
-    if (typeof caller !== "string") {
-      throw new CallerError('Missing "caller" field in request body');
-    }
-    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 ? shapeOrFn(contextFn()) : shapeOrFn;
-    const { caller: _, ...rest } = parsed;
-    return { shape, body: rest, matchedKey: matched, wasDynamic };
+    if (value === true)
+      continue;
+    if (value.orderBy || value.cursor || value.take || value.skip)
+      return true;
+    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where))
+      return true;
+    if (value.select && checkSelectForClientArgs(value.select))
+      return true;
+  }
+  return false;
+}
+function hasNestedClientControlledArgs(shape) {
+  if (shape.include) {
+    if (checkIncludeForClientArgs(shape.include))
+      return true;
   }
-  function requireBody(body) {
-    if (!isPlainObject(body))
-      throw new ShapeError("Request body must be an object");
-    return body;
+  if (shape.select) {
+    if (checkSelectForClientArgs(shape.select))
+      return true;
   }
-  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 };
+  return false;
+}
+function createModelGuardExtension(config) {
+  const { typeMap, enumMap, zodChains, zodDefaults, uniqueMap, scopeMap, guardConfig, contextFn } = config;
+  const wrapZodErrors = config.wrapZodErrors ?? false;
+  const enforceProjection = guardConfig.enforceProjection ?? false;
+  const scalarBase = createScalarBase(guardConfig.strictDecimal ?? false);
+  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults);
+  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  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);
-  }
-  function hasDataRefines(dataConfig) {
-    for (const value of Object.values(dataConfig)) {
-      if (typeof value === "function")
-        return true;
-    }
-    return false;
+    validateUniqueEquality(modelName, shape.where, method, uniqueMap, typeMap);
   }
-  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 +2893,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, zodDefaults);
         dataSchemaCache.set(cacheKey, built);
         return built;
       }
-      return buildDataSchema(modelName, dataConfig, mode);
+      return buildDataSchema(modelName, dataConfig, mode, typeMap, schemaBuilder, zodDefaults);
     }
     function getWhereBuilt(whereConfig, matchedKey, wasDynamic) {
       if (!wasDynamic) {
@@ -2317,7 +2938,7 @@ function createModelGuardExtension(config) {
         forcedSelectCountWhere = result.forcedCountWhere;
       }
       return {
-        zodSchema: z5.object(schemaFields).strict(),
+        zodSchema: z9.object(schemaFields).strict(),
         forcedIncludeTree,
         forcedSelectTree,
         forcedIncludeCountWhere,
@@ -2346,12 +2967,26 @@ function createModelGuardExtension(config) {
       }
       if (!hasShapeProjection)
         return {};
+      if (!hasBodyProjection && !enforceProjection)
+        return {};
+      if (!hasBodyProjection && enforceProjection) {
+        if (hasNestedClientControlledArgs(shape)) {
+          throw new ShapeError(
+            `Guard shape defines nested client-controlled projection args (orderBy/take/cursor/skip/where) but the client did not provide select/include in the ${method} body. With enforceProjection enabled, either always provide projection in the body or remove client-controlled nested args from the shape.`
+          );
+        }
+      }
       const projection = getProjection(shape, matchedKey, wasDynamic);
-      const projectionBody = {};
-      if ("select" in parsed)
-        projectionBody.select = parsed.select;
-      if ("include" in parsed)
-        projectionBody.include = parsed.include;
+      let projectionBody;
+      if (hasBodyProjection) {
+        projectionBody = {};
+        if ("select" in parsed)
+          projectionBody.select = parsed.select;
+        if ("include" in parsed)
+          projectionBody.include = parsed.include;
+      } else {
+        projectionBody = buildDefaultProjectionBody(shape);
+      }
       const validated = projection.zodSchema.parse(projectionBody);
       if (Object.keys(projection.forcedIncludeTree).length > 0) {
         applyForcedTree(validated, "include", projection.forcedIncludeTree);
@@ -2382,9 +3017,15 @@ function createModelGuardExtension(config) {
       let validatedWhere;
       if (built.schema) {
         validatedWhere = built.schema.parse(bodyWhere);
+      } else if (bodyWhere !== void 0) {
+        if (bodyWhere === null || !isPlainObject(bodyWhere) || Object.keys(bodyWhere).length > 0) {
+          throw new ShapeError(
+            "Guard shape where contains only forced conditions. Client where input is not accepted."
+          );
+        }
       }
-      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 +3038,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 +3059,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 +3116,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 +3137,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 +3150,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,12 +3169,76 @@ 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);
       };
     }
+    function makeUpsertMethod() {
+      return (body) => {
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (resolved.shape.data) {
+          throw new ShapeError('Guard shape "data" is not valid for upsert. Use "create" and "update" instead.');
+        }
+        if (!resolved.shape.create) {
+          throw new ShapeError('Guard shape requires "create" for upsert');
+        }
+        if (!resolved.shape.update) {
+          throw new ShapeError('Guard shape requires "update" for upsert');
+        }
+        if (!resolved.shape.where) {
+          throw new ShapeError('Guard shape requires "where" for upsert');
+        }
+        validateMutationShapeKeys(
+          resolved.shape,
+          VALID_SHAPE_KEYS_UPSERT,
+          "upsert"
+        );
+        validateMutationBodyKeys(resolved.body, ALLOWED_BODY_KEYS_UPSERT, "upsert");
+        maybeValidateUniqueWhere(modelName, resolved.shape, "upsert");
+        const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
+        validateCreateCompleteness(modelName, resolved.shape.create, typeMap, fks, zodDefaults);
+        const createDataSchema = getDataSchema(
+          "create",
+          resolved.shape.create,
+          `upsert:create\0${resolved.matchedKey}`,
+          resolved.wasDynamic
+        );
+        const createData = validateAndMergeData(resolved.body.create, createDataSchema, "upsert (create)");
+        const updateDataSchema = getDataSchema(
+          "update",
+          resolved.shape.update,
+          `upsert:update\0${resolved.matchedKey}`,
+          resolved.wasDynamic
+        );
+        const updateData = validateAndMergeData(resolved.body.update, updateDataSchema, "upsert (update)");
+        const where = requireWhere(
+          resolved.shape,
+          resolved.body.where,
+          "upsert",
+          true,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
+        validateResolvedUniqueWhere(modelName, where, "upsert", uniqueMap);
+        const args = {
+          where,
+          create: createData,
+          update: updateData
+        };
+        const projectionArgs = resolveProjection(
+          resolved.shape,
+          resolved.body,
+          "upsert",
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
+        Object.assign(args, projectionArgs);
+        return callDelegate("upsert", args);
+      };
+    }
     return {
       findMany: makeReadMethod("findMany"),
       findFirst: makeReadMethod("findFirst"),
@@ -2528,6 +3254,7 @@ function createModelGuardExtension(config) {
       update: makeUpdateMethod("update"),
       updateMany: makeUpdateMethod("updateMany"),
       updateManyAndReturn: makeUpdateMethod("updateManyAndReturn"),
+      upsert: makeUpsertMethod(),
       delete: makeDeleteMethod("delete"),
       deleteMany: makeDeleteMethod("deleteMany")
     };
@@ -2539,7 +3266,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 +3280,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,28 +3299,26 @@ 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 scalarBase = createScalarBase(config.guardConfig.strictDecimal ?? false);
   const schemaBuilder = createSchemaBuilder(
     config.typeMap,
     config.zodChains,
-    config.enumMap
+    config.enumMap,
+    scalarBase,
+    config.zodDefaults ?? {}
   );
   const queryBuilder = createQueryBuilder(
     config.typeMap,
     config.enumMap,
-    config.uniqueMap ?? {}
+    config.uniqueMap ?? {},
+    scalarBase
   );
   const log = config.logger ?? { warn: (msg) => console.warn(msg) };
   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 +3355,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.`
+            throw new PolicyError(
+              `prisma-guard: Scope root "${key}" has non-primitive value (${typeof val}). Only string, number, and bigint values are accepted for scope context.`
             );
           }
         }
@@ -2655,8 +3388,10 @@ function createGuard(config) {
         typeMap: config.typeMap,
         enumMap: config.enumMap,
         zodChains: config.zodChains,
+        zodDefaults: config.zodDefaults ?? {},
         uniqueMap: config.uniqueMap ?? {},
         scopeMap: config.scopeMap,
+        guardConfig: config.guardConfig,
         contextFn,
         wrapZodErrors
       });
@@ -2672,6 +3407,7 @@ export {
   CallerError,
   PolicyError,
   ShapeError,
-  createGuard
+  createGuard,
+  force
 };
 //# sourceMappingURL=index.js.map