prisma-guard 1.27.1 → 1.28.1

package/dist/runtime/index.cjs

@@ -29,9 +29,6 @@ __export(runtime_exports, {
 });
 module.exports = __toCommonJS(runtime_exports);
 
-// src/runtime/guard.ts
-var import_zod10 = require("zod");
-
 // src/shared/errors.ts
 var PolicyError = class extends Error {
   status = 403;
@@ -61,10 +58,16 @@ function formatIssue(issue) {
   const path = issue.path.length > 0 ? `${issue.path.join(".")}: ` : "";
   const code = issue.code;
   if (code === "invalid_union") {
-    const unionErrors = issue.unionErrors;
-    if (unionErrors && unionErrors.length > 0) {
-      const branches = unionErrors.map((ue, i) => {
-        const nested = ue.issues.map(formatIssue).join(", ");
+    const raw = issue;
+    let branchIssues = null;
+    if (Array.isArray(raw.errors) && raw.errors.length > 0) {
+      branchIssues = raw.errors;
+    } else if (Array.isArray(raw.unionErrors) && raw.unionErrors.length > 0) {
+      branchIssues = raw.unionErrors.map((ue) => ue.issues);
+    }
+    if (branchIssues) {
+      const branches = branchIssues.map((issues, i) => {
+        const nested = issues.map(formatIssue).join(", ");
         return `branch ${i + 1}: [${nested}]`;
       }).join(" | ");
       return `${path}No matching variant (${branches})`;
@@ -83,6 +86,9 @@ function formatIssue(issue) {
     if (expected && received) {
       return `${path}Expected ${expected}, received ${received}`;
     }
+    if (expected) {
+      return `${path}Expected ${expected}`;
+    }
   }
   if (code === "invalid_enum_value") {
     const options = issue.options;
@@ -92,28 +98,28 @@ function formatIssue(issue) {
   }
   if (code === "too_small") {
     const minimum = issue.minimum;
-    const type = issue.type;
-    if (type === "string" && minimum !== void 0) {
+    const origin = issue.origin ?? issue.type;
+    if (origin === "string" && minimum !== void 0) {
       return `${path}String must contain at least ${minimum} character(s)`;
     }
-    if (type === "array" && minimum !== void 0) {
+    if (origin === "array" && minimum !== void 0) {
       return `${path}Array must contain at least ${minimum} element(s)`;
     }
-    if (type === "number" && minimum !== void 0) {
+    if (origin === "number" && minimum !== void 0) {
       return `${path}Number must be >= ${minimum}`;
     }
     return `${path}${issue.message}`;
   }
   if (code === "too_big") {
     const maximum = issue.maximum;
-    const type = issue.type;
-    if (type === "string" && maximum !== void 0) {
+    const origin = issue.origin ?? issue.type;
+    if (origin === "string" && maximum !== void 0) {
       return `${path}String must contain at most ${maximum} character(s)`;
     }
-    if (type === "array" && maximum !== void 0) {
+    if (origin === "array" && maximum !== void 0) {
       return `${path}Array must contain at most ${maximum} element(s)`;
     }
-    if (type === "number" && maximum !== void 0) {
+    if (origin === "number" && maximum !== void 0) {
       return `${path}Number must be <= ${maximum}`;
     }
     return `${path}${issue.message}`;
@@ -135,18 +141,42 @@ function formatIssue(issue) {
 function formatZodError(err) {
   return err.issues.map(formatIssue).join("; ");
 }
-function wrapParseError(err, context) {
+function isZodErrorLike(err) {
+  return !!err && typeof err === "object" && "issues" in err;
+}
+function wrapZod(err, context) {
   if (err instanceof ShapeError) {
     throw new ShapeError(`${context}: ${err.message}`, { cause: err });
   }
-  if (err && typeof err === "object" && "issues" in err) {
+  if (isZodErrorLike(err)) {
     throw new ShapeError(`${context}: ${formatZodError(err)}`, { cause: err });
   }
   throw err;
 }
+function wrapParseError(err, context) {
+  return wrapZod(err, context);
+}
+function toShapeError(err, prefix = "Validation failed") {
+  if (isZodErrorLike(err)) {
+    return new ShapeError(`${prefix}: ${formatZodError(err)}`, { cause: err });
+  }
+  return err;
+}
 
 // src/shared/scalar-base.ts
 var import_zod = require("zod");
+function isPrismaNullSentinel(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const tag = value._tag;
+  if (tag === "DbNull" || tag === "JsonNull" || tag === "AnyNull")
+    return true;
+  const constructorName = value.constructor?.name;
+  if (constructorName === "DbNull" || constructorName === "JsonNull" || constructorName === "AnyNull") {
+    return true;
+  }
+  return false;
+}
 function isJsonSafe(value) {
   const stack = [{ tag: "visit", value }];
   const ancestors = /* @__PURE__ */ new Set();
@@ -161,6 +191,8 @@ function isJsonSafe(value) {
       return false;
     if (current === null)
       continue;
+    if (isPrismaNullSentinel(current))
+      continue;
     switch (typeof current) {
       case "string":
       case "boolean":
@@ -245,8 +277,8 @@ function wrapWithInputCoercion(fieldType, isList, schema) {
       break;
     case "Int":
       itemCoercion = import_zod.z.union([
-        import_zod.z.number().transform((v) => Math.trunc(v)).pipe(import_zod.z.number().int()),
-        import_zod.z.string().regex(/^-?\d+(\.\d+)?$/).transform((v) => Math.trunc(Number(v)))
+        import_zod.z.number().int(),
+        import_zod.z.string().regex(/^-?\d+$/).transform((v) => Number(v))
       ]);
       break;
     case "Float":
@@ -263,10 +295,10 @@ function wrapWithInputCoercion(fieldType, isList, schema) {
 }
 
 // src/runtime/schema-builder.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/runtime/zod-type-map.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/shared/utils.ts
 function isPlainObject(v) {
@@ -295,7 +327,7 @@ function coerceToArray(value) {
   const keys = Object.keys(value);
   if (keys.length === 0)
     return value;
-  const allNumeric = keys.every((k) => /^\d+$/.test(k));
+  const allNumeric = keys.every((k) => /^\d+$/.test(k) && String(Number(k)) === k);
   if (!allNumeric)
     return value;
   const indices = keys.map(Number).sort((a, b) => a - b);
@@ -311,6 +343,48 @@ function coerceToArray(value) {
   return result;
 }
 
+// src/shared/zod-helpers.ts
+var import_zod2 = require("zod");
+function strictObjectRequiringOne(shape, message) {
+  const keys = Object.keys(shape);
+  return import_zod2.z.object(shape).strict().refine(
+    (v) => keys.some((k) => v[k] !== void 0),
+    { message }
+  );
+}
+function singleOrArraySchema(single) {
+  return import_zod2.z.union([
+    single,
+    import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(single).min(1))
+  ]);
+}
+function optionalOneOrMany(single) {
+  return import_zod2.z.union([single, import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(single))]).optional();
+}
+function wrapRelationOp(isList, single) {
+  if (!isList)
+    return single.optional();
+  return optionalOneOrMany(single);
+}
+function buildLiteralTrueSchema(fieldNames, message, validate) {
+  const fieldSchemas = {};
+  for (const fieldName of fieldNames) {
+    if (validate)
+      validate(fieldName);
+    fieldSchemas[fieldName] = import_zod2.z.literal(true).optional();
+  }
+  return strictObjectRequiringOne(fieldSchemas, message).optional();
+}
+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}`
+      );
+    }
+  }
+}
+
 // src/runtime/zod-type-map.ts
 var SCALAR_OPERATORS = {
   String: /* @__PURE__ */ new Set([
@@ -398,13 +472,13 @@ function getSupportedOperators(input, isList = false, isEnum = false) {
 function createBaseType(fieldMeta, enumMap, scalarBase) {
   let base;
   if (fieldMeta.isUnsupported) {
-    base = import_zod2.z.unknown();
+    base = import_zod3.z.unknown();
   } else if (fieldMeta.isEnum) {
     const values = enumMap[fieldMeta.type];
     if (!values || values.length === 0) {
       throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
     }
-    base = import_zod2.z.enum(values);
+    base = import_zod3.z.enum(values);
   } else {
     const factory = scalarBase[fieldMeta.type];
     if (!factory) {
@@ -413,7 +487,7 @@ function createBaseType(fieldMeta, enumMap, scalarBase) {
     base = factory();
   }
   if (fieldMeta.isList) {
-    base = import_zod2.z.array(base);
+    base = import_zod3.z.array(base);
   }
   return base;
 }
@@ -424,35 +498,38 @@ function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase
     );
   }
   if (operator === "isEmpty") {
-    return import_zod2.z.boolean();
+    return import_zod3.z.boolean();
   }
   const itemMeta = { ...fieldMeta, isList: false };
   const itemBase = createBaseType(itemMeta, enumMap, scalarBase);
   if (operator === "has") {
-    return !fieldMeta.isRequired ? import_zod2.z.union([itemBase, import_zod2.z.null()]) : itemBase;
+    return !fieldMeta.isRequired ? import_zod3.z.union([itemBase, import_zod3.z.null()]) : itemBase;
   }
   if (operator === "equals") {
-    const arrSchema = import_zod2.z.array(itemBase);
-    return fieldMeta.isRequired ? import_zod2.z.preprocess(coerceToArray, arrSchema) : import_zod2.z.union([import_zod2.z.preprocess(coerceToArray, arrSchema), import_zod2.z.null()]);
+    const arrSchema = import_zod3.z.array(itemBase);
+    return fieldMeta.isRequired ? import_zod3.z.preprocess(coerceToArray, arrSchema) : import_zod3.z.union([import_zod3.z.preprocess(coerceToArray, arrSchema), import_zod3.z.null()]);
   }
-  return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemBase));
+  return import_zod3.z.preprocess(coerceToArray, import_zod3.z.array(itemBase));
 }
 function createJsonOperatorSchema(fieldMeta, operator) {
-  const jsonValue = import_zod2.z.unknown();
+  const jsonValue = import_zod3.z.unknown();
   if (operator === "equals") {
-    return !fieldMeta.isRequired ? import_zod2.z.union([jsonValue, import_zod2.z.null()]) : jsonValue;
+    return !fieldMeta.isRequired ? import_zod3.z.union([jsonValue, import_zod3.z.null()]) : jsonValue;
   }
   if (operator === "path") {
-    return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(import_zod2.z.string()).min(1));
+    return import_zod3.z.preprocess(coerceToArray, import_zod3.z.array(import_zod3.z.string()).min(1));
   }
   if (JSON_STRING_OPERATORS.has(operator)) {
-    return import_zod2.z.string();
+    return import_zod3.z.string();
   }
   if (JSON_ARRAY_OPERATORS.has(operator)) {
     return jsonValue;
   }
   throw new ShapeError(`Operator "${operator}" not supported for Json fields`);
 }
+function nullableIfOptional(fieldMeta, base) {
+  return !fieldMeta.isRequired ? import_zod3.z.union([base, import_zod3.z.null()]) : base;
+}
 function buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase) {
   const allOps = getSupportedOperators(fieldMeta);
   const nestedOps = allOps.filter((op) => op !== "not");
@@ -468,14 +545,15 @@ function buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase) {
       scalarBase
     ).optional();
   }
-  const nestedKeys = Object.keys(nestedSchemas);
-  const nestedObj = import_zod2.z.object(nestedSchemas).strict().refine(
-    (value) => nestedKeys.some(
-      (key) => value[key] !== void 0
-    ),
-    { message: "not filter must specify at least one operator" }
+  const nestedObj = strictObjectRequiringOne(
+    nestedSchemas,
+    "not filter must specify at least one operator"
   );
-  return import_zod2.z.union([scalarSchema, nestedObj]);
+  return import_zod3.z.union([scalarSchema, nestedObj]);
+}
+function buildNotOperator(fieldMeta, scalarBaseSchema, enumMap, scalarBase) {
+  const scalarSchema = nullableIfOptional(fieldMeta, scalarBaseSchema);
+  return buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase);
 }
 function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   const allowedOps = getSupportedOperators(fieldMeta);
@@ -512,32 +590,19 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
     if (!values || values.length === 0) {
       throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
     }
-    const enumSchema = import_zod2.z.enum(values);
+    const enumSchema = import_zod3.z.enum(values);
     if (operator === "equals") {
-      return !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
+      return nullableIfOptional(fieldMeta, enumSchema);
     }
     if (operator === "not") {
-      const scalarSchema = !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
-      return buildNotFilterSchema(
-        fieldMeta,
-        scalarSchema,
-        enumMap,
-        scalarBase
-      );
+      return buildNotOperator(fieldMeta, enumSchema, enumMap, scalarBase);
     }
-    const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
-    return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
+    const itemSchema = nullableIfOptional(fieldMeta, enumSchema);
+    return import_zod3.z.preprocess(coerceToArray, import_zod3.z.array(itemSchema));
   }
   if (fieldMeta.type === "Json") {
     if (operator === "not") {
-      const jsonValue = import_zod2.z.unknown();
-      const scalarSchema = !fieldMeta.isRequired ? import_zod2.z.union([jsonValue, import_zod2.z.null()]) : jsonValue;
-      return buildNotFilterSchema(
-        fieldMeta,
-        scalarSchema,
-        enumMap,
-        scalarBase
-      );
+      return buildNotOperator(fieldMeta, import_zod3.z.unknown(), enumMap, scalarBase);
     }
     return createJsonOperatorSchema(fieldMeta, operator);
   }
@@ -548,15 +613,14 @@ function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
   const scalar = factory();
   const coerced = wrapWithInputCoercion(fieldMeta.type, false, scalar);
   if (operator === "equals") {
-    return !fieldMeta.isRequired ? import_zod2.z.union([coerced, import_zod2.z.null()]) : coerced;
+    return nullableIfOptional(fieldMeta, coerced);
   }
   if (operator === "not") {
-    const scalarSchema = !fieldMeta.isRequired ? import_zod2.z.union([coerced, import_zod2.z.null()]) : coerced;
-    return buildNotFilterSchema(fieldMeta, scalarSchema, enumMap, scalarBase);
+    return buildNotOperator(fieldMeta, coerced, enumMap, scalarBase);
   }
   if (operator === "in" || operator === "notIn") {
-    const itemSchema = !fieldMeta.isRequired ? import_zod2.z.union([coerced, import_zod2.z.null()]) : coerced;
-    return import_zod2.z.preprocess(coerceToArray, import_zod2.z.array(itemSchema));
+    const itemSchema = nullableIfOptional(fieldMeta, coerced);
+    return import_zod3.z.preprocess(coerceToArray, import_zod3.z.array(itemSchema));
   }
   return coerced;
 }
@@ -582,6 +646,26 @@ function lruSet(cache, key, value, maxSize) {
       cache.delete(oldest);
   }
 }
+function applyCreateUpdateNullability(fieldMeta, fieldSchema, options) {
+  const { mode, handlesUndefined } = options;
+  const allowNull = options.allowNull ?? true;
+  if (mode === "create") {
+    if (!fieldMeta.isRequired) {
+      if (handlesUndefined) {
+        return allowNull ? fieldSchema.nullable() : fieldSchema;
+      }
+      return allowNull ? fieldSchema.nullable().optional() : fieldSchema.optional();
+    }
+    if (fieldMeta.hasDefault) {
+      return handlesUndefined ? fieldSchema : fieldSchema.optional();
+    }
+    return fieldSchema;
+  }
+  if (!fieldMeta.isRequired && allowNull) {
+    return fieldSchema.nullable().optional();
+  }
+  return fieldSchema.optional();
+}
 function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults) {
   const chainCache = /* @__PURE__ */ new Map();
   function buildFieldSchema(model, field) {
@@ -636,20 +720,25 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
     let fieldNames = Object.keys(modelFields).filter((name) => {
       const meta = modelFields[name];
-      return !meta.isRelation && !meta.isUpdatedAt;
+      return !meta.isRelation && !meta.isUpdatedAt && !meta.isUnsupported;
     });
     if (opts.pick) {
       for (const name of opts.pick) {
-        if (!modelFields[name])
+        const meta = modelFields[name];
+        if (!meta)
           throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
-        if (modelFields[name].isRelation)
+        if (meta.isRelation)
           throw new ShapeError(
             `Field "${name}" cannot be used in input schema (relation field)`
           );
-        if (modelFields[name].isUpdatedAt)
+        if (meta.isUpdatedAt)
           throw new ShapeError(
             `Field "${name}" cannot be used in input schema (updatedAt field)`
           );
+        if (meta.isUnsupported)
+          throw new ShapeError(
+            `Field "${name}" on model "${model}" has an Unsupported type and cannot be used in input schema`
+          );
       }
       fieldNames = fieldNames.filter((n) => opts.pick.includes(n));
     } else if (opts.omit) {
@@ -662,7 +751,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     const schemaMap = {};
     for (const name of fieldNames) {
       const fieldMeta = modelFields[name];
-      let fieldSchema;
+      let baseSchema;
       let handlesUndefined;
       if (opts.refine?.[name]) {
         let refined;
@@ -679,34 +768,19 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
             `Refine function for "${model}.${name}" must return a Zod schema`
           );
         }
-        fieldSchema = refined;
-        handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
+        baseSchema = refined;
+        handlesUndefined = schemaProducesValueForUndefined(baseSchema);
       } else {
-        fieldSchema = buildFieldSchema(model, name);
+        baseSchema = buildFieldSchema(model, name);
         handlesUndefined = zodDefaultSet !== void 0 && zodDefaultSet.has(name);
       }
-      if (mode === "create") {
-        if (!fieldMeta.isRequired) {
-          if (handlesUndefined) {
-            fieldSchema = allowNull ? fieldSchema.nullable() : fieldSchema;
-          } else {
-            fieldSchema = allowNull ? fieldSchema.nullable().optional() : fieldSchema.optional();
-          }
-        } else if (fieldMeta.hasDefault) {
-          if (!handlesUndefined) {
-            fieldSchema = fieldSchema.optional();
-          }
-        }
-      } else {
-        if (!fieldMeta.isRequired && allowNull) {
-          fieldSchema = fieldSchema.nullable().optional();
-        } else {
-          fieldSchema = fieldSchema.optional();
-        }
-      }
-      schemaMap[name] = fieldSchema;
+      schemaMap[name] = applyCreateUpdateNullability(fieldMeta, baseSchema, {
+        mode,
+        handlesUndefined,
+        allowNull
+      });
     }
-    let schema = import_zod3.z.object(schemaMap).strict();
+    let schema = import_zod4.z.object(schemaMap).strict();
     if (opts.partial) {
       schema = schema.partial();
     }
@@ -733,13 +807,18 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     const includeKeys = new Set(Object.keys(opts.include ?? {}));
     if (opts.pick) {
       for (const name of opts.pick) {
-        if (!modelFields[name])
+        const meta = modelFields[name];
+        if (!meta)
           throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
-        if (modelFields[name].isRelation && !includeKeys.has(name)) {
+        if (meta.isRelation && !includeKeys.has(name)) {
           throw new ShapeError(
             `Field "${name}" is a relation on model "${model}". Use include: { ${name}: ... } instead of pick.`
           );
         }
+        if (meta.isUnsupported)
+          throw new ShapeError(
+            `Field "${name}" on model "${model}" has an Unsupported type and cannot be used in output schema`
+          );
       }
     }
     if (opts.omit) {
@@ -750,7 +829,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
     }
     let scalarNames = Object.keys(modelFields).filter((name) => {
       const meta = modelFields[name];
-      return !meta.isRelation;
+      return !meta.isRelation && !meta.isUnsupported;
     });
     if (opts.pick) {
       scalarNames = scalarNames.filter((n) => opts.pick.includes(n));
@@ -787,7 +866,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
         effectiveMaxDepth
       );
       if (fieldMeta.isList) {
-        relSchema = import_zod3.z.array(relSchema);
+        relSchema = import_zod4.z.array(relSchema);
       } else if (!fieldMeta.isRequired) {
         relSchema = relSchema.nullable();
       }
@@ -800,9 +879,9 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
       if (opts._count === true) {
         const countFields = {};
         for (const relName of listRelationNames) {
-          countFields[relName] = import_zod3.z.number().int().min(0);
+          countFields[relName] = import_zod4.z.number().int().min(0);
         }
-        schemaMap["_count"] = import_zod3.z.object(countFields);
+        schemaMap["_count"] = import_zod4.z.object(countFields);
       } else {
         const countFields = {};
         for (const relName of Object.keys(opts._count)) {
@@ -818,12 +897,12 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
             throw new ShapeError(
               `Field "${relName}" is a to-one relation on model "${model}" in _count. Only to-many relations support _count.`
             );
-          countFields[relName] = import_zod3.z.number().int().min(0);
+          countFields[relName] = import_zod4.z.number().int().min(0);
         }
-        schemaMap["_count"] = import_zod3.z.object(countFields);
+        schemaMap["_count"] = import_zod4.z.object(countFields);
       }
     }
-    let schema = import_zod3.z.object(schemaMap);
+    let schema = import_zod4.z.object(schemaMap);
     if (opts.strict) {
       schema = schema.strict();
     }
@@ -838,7 +917,7 @@ function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefault
 }
 
 // src/runtime/query-builder.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/shared/constants.ts
 var SHAPE_CONFIG_KEY_LIST = [
@@ -894,6 +973,8 @@ function unsupported() {
 
 // src/shared/match-caller.ts
 function matchCallerPattern(patterns, caller) {
+  if (typeof caller !== "string" || caller.trim().length === 0)
+    return null;
   if (patterns.includes(caller))
     return caller;
   const matches = [];
@@ -947,7 +1028,7 @@ function validateContext(ctx) {
 }
 
 // src/runtime/query-builder-where.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/shared/deep-clone.ts
 function deepClone(value) {
@@ -982,44 +1063,75 @@ function deepClone(value) {
   }
 }
 
-// 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 forcedScalarsEqual(a, b) {
+// src/shared/deep-equal.ts
+function deepEqual(a, b) {
   if (a === b)
     return true;
   if (a === null || b === null)
     return false;
-  if (typeof a !== typeof b)
+  if (a === void 0 || b === void 0)
+    return false;
+  const ta = typeof a;
+  const tb = typeof b;
+  if (ta !== tb)
+    return false;
+  if (ta === "bigint")
+    return a === b;
+  if (ta !== "object")
     return false;
   if (a instanceof Date && b instanceof Date) {
     return a.getTime() === b.getTime();
   }
+  if (a instanceof Date || b instanceof Date)
+    return false;
   if (a instanceof RegExp && b instanceof RegExp) {
     return a.source === b.source && a.flags === b.flags;
   }
+  if (a instanceof RegExp || b instanceof RegExp)
+    return false;
   if (Array.isArray(a)) {
     if (!Array.isArray(b))
       return false;
     if (a.length !== b.length)
       return false;
-    return a.every((v, i) => forcedScalarsEqual(v, b[i]));
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i]))
+        return false;
+    }
+    return true;
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
+  if (Array.isArray(b))
+    return false;
+  if (!isPlainObject(a) || !isPlainObject(b))
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  for (const key of aKeys) {
+    if (!(key in b))
+      return false;
+    if (!deepEqual(a[key], b[key]))
       return false;
-    return aKeys.every(
-      (k) => k in b && forcedScalarsEqual(a[k], b[k])
-    );
   }
-  return false;
+  return true;
+}
+
+// src/shared/unique-constraints.ts
+function formatUniqueConstraint(constraint) {
+  return constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`;
+}
+function formatUniqueConstraints(constraints) {
+  return constraints.map(formatUniqueConstraint).join(" | ");
+}
+
+// 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 tryInlineForcedField(result, field, forcedValue) {
   if (!(field in result))
@@ -1038,7 +1150,7 @@ function tryInlineForcedField(result, field, forcedValue) {
   const merged = { ...existing };
   for (const [op, value] of Object.entries(forcedValue)) {
     if (op in merged) {
-      if (!forcedScalarsEqual(merged[op], value)) {
+      if (!deepEqual(merged[op], value)) {
         throw new ShapeError(
           `Conflicting where values for "${field}.${op}": client provided a different value than the forced shape`
         );
@@ -1069,6 +1181,17 @@ function mergeWhereForced(where, forced) {
   if (Object.keys(forced.conditions).length > 0) {
     const remaining = {};
     for (const [field, forcedValue] of Object.entries(forced.conditions)) {
+      if (field === "NOT") {
+        const existing = result[field];
+        const forcedArr = Array.isArray(forcedValue) ? forcedValue.map(deepClone) : [deepClone(forcedValue)];
+        if (existing === void 0) {
+          result[field] = forcedArr.length === 1 ? forcedArr[0] : forcedArr;
+        } else {
+          const existingArr = Array.isArray(existing) ? existing : [existing];
+          result[field] = [...existingArr, ...forcedArr];
+        }
+        continue;
+      }
       const inlined = tryInlineForcedField(result, field, forcedValue);
       if (!inlined) {
         remaining[field] = deepClone(forcedValue);
@@ -1084,32 +1207,6 @@ function mergeWhereForced(where, forced) {
   }
   return result;
 }
-function uniqueValuesEqual(a, b) {
-  if (a === b)
-    return true;
-  if (a === null || b === null)
-    return false;
-  if (typeof a !== typeof b)
-    return false;
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
-  }
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b))
-      return false;
-    if (a.length !== b.length)
-      return false;
-    return a.every((v, i) => uniqueValuesEqual(v, b[i]));
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-      return false;
-    return aKeys.every((key) => key in b && uniqueValuesEqual(a[key], b[key]));
-  }
-  return false;
-}
 function mergeUniqueValue(target, key, value) {
   const cloned = deepClone(value);
   if (!(key in target)) {
@@ -1120,7 +1217,7 @@ function mergeUniqueValue(target, key, value) {
   if (isPlainObject(existing) && isPlainObject(cloned)) {
     const merged = { ...existing };
     for (const [nestedKey, nestedValue] of Object.entries(cloned)) {
-      if (nestedKey in merged && !uniqueValuesEqual(merged[nestedKey], nestedValue)) {
+      if (nestedKey in merged && !deepEqual(merged[nestedKey], nestedValue)) {
         throw new ShapeError(
           `Conflicting unique where value for "${key}.${nestedKey}"`
         );
@@ -1130,7 +1227,7 @@ function mergeUniqueValue(target, key, value) {
     target[key] = merged;
     return;
   }
-  if (!uniqueValuesEqual(existing, cloned)) {
+  if (!deepEqual(existing, cloned)) {
     throw new ShapeError(`Conflicting unique where value for "${key}"`);
   }
 }
@@ -1157,7 +1254,30 @@ function applyBuiltShape(built, body, isUniqueMethod, modelName) {
       throw new ShapeError('Request cannot define both "include" and "select"');
     }
     if ("where" in bodyObj) {
-      if (!hasWhereInSchema) {
+      if (bodyObj.where === void 0 || bodyObj.where === null) {
+        const { where: _, ...rest } = bodyObj;
+        parseable = rest;
+      } else if (!hasWhereInSchema) {
+        const context = modelName ? ` on model "${modelName}"` : "";
+        if (!hasWhereForced(built.forcedWhere)) {
+          throw new ShapeError(
+            `Guard shape does not allow "where"${context}`
+          );
+        }
+        if (!isPlainObject(bodyObj.where)) {
+          throw new ShapeError(
+            `Invalid "where"${context}: must be a plain object`
+          );
+        }
+        const remaining = stripUniqueWhereForcedInput(
+          bodyObj.where,
+          built.forcedWhere
+        );
+        if (Object.keys(remaining).length > 0) {
+          throw new ShapeError(
+            `Guard shape where${context} contains only forced conditions. Client where input is not accepted.`
+          );
+        }
         const { where: _, ...rest } = bodyObj;
         parseable = rest;
       } else if (isUniqueMethod && hasWhereForced(built.forcedWhere) && isPlainObject(bodyObj.where)) {
@@ -1233,6 +1353,86 @@ function buildCountForPlacement(countWhere) {
   }
   return { _count: { select: countSelect } };
 }
+function collectSubtree(forced) {
+  const nested = {};
+  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 placement = forced._countWherePlacement ?? "include";
+    if (!nested[placement])
+      nested[placement] = {};
+    const placementObj = nested[placement];
+    Object.assign(placementObj, buildCountForPlacement(forced._countWhere));
+  }
+  return nested;
+}
+function applyForcedToRelValue(relName, relVal, forced) {
+  if (relVal === true) {
+    const expanded = collectSubtree(forced);
+    if (forced.include) {
+      applyForcedTree(expanded, "include", forced.include);
+    }
+    if (forced.select) {
+      applyForcedTree(expanded, "select", forced.select);
+    }
+    if (expanded.include && expanded.select) {
+      throw new ShapeError(
+        `Forced tree for relation "${relName}" produces both "include" and "select". Prisma does not allow both at the same level.`
+      );
+    }
+    return Object.keys(expanded).length > 0 ? expanded : true;
+  }
+  if (!isPlainObject(relVal))
+    return relVal;
+  const relObj = relVal;
+  if (forced.where && hasWhereForced(forced.where)) {
+    relObj.where = mergeWhereForced(
+      relObj.where,
+      forced.where
+    );
+  }
+  if (forced.include) {
+    if (!relObj.include) {
+      relObj.include = buildForcedOnlyContainer(forced.include);
+    }
+    applyForcedTree(relObj, "include", forced.include);
+  }
+  if (forced.select) {
+    if (!relObj.select) {
+      relObj.select = buildForcedOnlyContainer(forced.select);
+    }
+    applyForcedTree(relObj, "select", forced.select);
+  }
+  if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
+    const placement = forced._countWherePlacement ?? "include";
+    const existing = relObj[placement];
+    let placementObj;
+    if (!isPlainObject(existing)) {
+      placementObj = {};
+      relObj[placement] = placementObj;
+    } else {
+      placementObj = existing;
+    }
+    if (!("_count" in placementObj)) {
+      Object.assign(placementObj, buildCountForPlacement(forced._countWhere));
+    } else {
+      applyForcedCountWhere(placementObj, forced._countWhere);
+    }
+  }
+  if (relObj.include && relObj.select) {
+    throw new ShapeError(
+      `Relation "${relName}" has both "include" and "select" after forced tree merge. Prisma does not allow both at the same level.`
+    );
+  }
+  return relObj;
+}
 function applyForcedTree(validated, key, tree) {
   const container = validated[key];
   if (!container)
@@ -1241,89 +1441,13 @@ function applyForcedTree(validated, key, tree) {
     const relVal = container[relName];
     if (relVal === void 0)
       continue;
-    if (relVal === true) {
-      const expanded = {};
-      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);
-      }
-      if (forced.select) {
-        expanded.select = buildForcedOnlyContainer(forced.select);
-        applyForcedTree(expanded, "select", forced.select);
-      }
-      if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
-        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(
-          `Forced tree for relation "${relName}" produces both "include" and "select". Prisma does not allow both at the same level.`
-        );
-      }
-      container[relName] = Object.keys(expanded).length > 0 ? expanded : true;
-      continue;
-    }
-    if (isPlainObject(relVal)) {
-      const relObj = relVal;
-      if (forced.where && hasWhereForced(forced.where)) {
-        relObj.where = mergeWhereForced(
-          relObj.where,
-          forced.where
-        );
-      }
-      if (forced.include) {
-        if (!relObj.include) {
-          relObj.include = buildForcedOnlyContainer(forced.include);
-        }
-        applyForcedTree(relObj, "include", forced.include);
-      }
-      if (forced.select) {
-        if (!relObj.select) {
-          relObj.select = buildForcedOnlyContainer(forced.select);
-        }
-        applyForcedTree(relObj, "select", forced.select);
-      }
-      if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
-        const placement = forced._countWherePlacement ?? "include";
-        const projContainer = relObj[placement];
-        if (projContainer) {
-          applyForcedCountWhere(projContainer, forced._countWhere);
-        }
-      }
-      if (relObj.include && relObj.select) {
-        throw new ShapeError(
-          `Relation "${relName}" has both "include" and "select" after forced tree merge. Prisma does not allow both at the same level.`
-        );
-      }
-    }
+    container[relName] = applyForcedToRelValue(relName, relVal, forced);
   }
 }
 function buildForcedOnlyContainer(tree) {
   const result = {};
   for (const [relName, forced] of Object.entries(tree)) {
-    const nested = {};
-    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 placement = forced._countWherePlacement ?? "include";
-      if (!nested[placement])
-        nested[placement] = {};
-      const placementObj = nested[placement];
-      Object.assign(placementObj, buildCountForPlacement(forced._countWhere));
-    }
+    const nested = collectSubtree(forced);
     result[relName] = Object.keys(nested).length > 0 ? nested : true;
   }
   return result;
@@ -1339,11 +1463,15 @@ function applyForcedCountWhere(container, forcedCountWhere) {
   const selectObj = selectVal;
   for (const [relName, forced] of Object.entries(forcedCountWhere)) {
     const relVal = selectObj[relName];
-    if (relVal === void 0)
+    if (relVal === void 0) {
+      selectObj[relName] = { where: mergeWhereForced(void 0, forced) };
       continue;
+    }
     if (relVal === true) {
       selectObj[relName] = { where: mergeWhereForced(void 0, forced) };
-    } else if (isPlainObject(relVal)) {
+      continue;
+    }
+    if (isPlainObject(relVal)) {
       const relObj = relVal;
       relObj.where = mergeWhereForced(
         relObj.where,
@@ -1352,12 +1480,6 @@ function applyForcedCountWhere(container, forcedCountWhere) {
     }
   }
 }
-function formatUniqueConstraint(constraint) {
-  return constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`;
-}
-function formatUniqueConstraints(constraints) {
-  return constraints.map(formatUniqueConstraint).join(" | ");
-}
 function resolvedWhereCoversConstraint(where, constraint) {
   if (constraint.fields.length === 1) {
     return constraint.fields[0] in where;
@@ -1463,7 +1585,12 @@ function stripUniqueWhereForcedInput(where, forced) {
     const currentValue = result[key];
     if (isPlainObject(currentValue) && isPlainObject(forcedValue)) {
       const nested = { ...currentValue };
-      for (const nestedKey of Object.keys(forcedValue)) {
+      for (const [nestedKey, nestedForcedValue] of Object.entries(forcedValue)) {
+        if (nestedKey in nested && !deepEqual(nested[nestedKey], nestedForcedValue)) {
+          throw new ShapeError(
+            `Client unique where value for "${key}.${nestedKey}" conflicts with forced value`
+          );
+        }
         delete nested[nestedKey];
       }
       if (Object.keys(nested).length === 0) {
@@ -1473,11 +1600,25 @@ function stripUniqueWhereForcedInput(where, forced) {
       }
       continue;
     }
+    if (!deepEqual(currentValue, forcedValue)) {
+      throw new ShapeError(
+        `Client unique where value for "${key}" conflicts with forced value`
+      );
+    }
     delete result[key];
   }
   return result;
 }
 
+// src/runtime/direct-scalar-schema.ts
+function buildDirectScalarSchema(fieldMeta, enumMap, scalarBase) {
+  const base = createBaseType(fieldMeta, enumMap, scalarBase);
+  if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
+    return wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, base);
+  }
+  return base;
+}
+
 // src/runtime/query-builder-where.ts
 var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Bytes"]);
 var STRING_MODE_OPS = /* @__PURE__ */ new Set([
@@ -1491,47 +1632,40 @@ var JSON_STRING_MODE_OPS = /* @__PURE__ */ new Set([
   "string_starts_with",
   "string_ends_with"
 ]);
+var NEGATIVE_RELATION_OPS = /* @__PURE__ */ new Set(["none", "isNot"]);
 var MAX_WHERE_DEPTH = 10;
-function safeStringify(v) {
-  if (typeof v === "bigint")
-    return `${v}n`;
+function safeStringify(value) {
+  if (typeof value === "bigint")
+    return `${value}n`;
+  if (typeof value === "undefined")
+    return "undefined";
+  if (typeof value === "function")
+    return "[function]";
+  if (typeof value === "symbol")
+    return value.toString();
+  const seen = /* @__PURE__ */ new WeakSet();
   try {
-    return JSON.stringify(v);
+    const json = JSON.stringify(value, (_key, current) => {
+      if (typeof current === "bigint")
+        return `${current}n`;
+      if (typeof current === "undefined")
+        return "[undefined]";
+      if (typeof current === "function")
+        return "[function]";
+      if (typeof current === "symbol")
+        return current.toString();
+      if (current && typeof current === "object") {
+        if (seen.has(current))
+          return "[Circular]";
+        seen.add(current);
+      }
+      return current;
+    });
+    return json === void 0 ? String(value) : json;
   } catch {
-    return String(v);
+    return String(value);
   }
 }
-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];
@@ -1549,7 +1683,7 @@ function mergeScalarConditions(target, source) {
       for (const [op, val] of Object.entries(ops)) {
         if (op in existing) {
           const existingVal = existing[op];
-          if (!forcedValuesEqual(existingVal, val)) {
+          if (!deepEqual(existingVal, val)) {
             throw new ShapeError(
               `Conflicting forced where values for "${field}.${op}": shape defines both ${safeStringify(existingVal)} and ${safeStringify(val)}`
             );
@@ -1559,7 +1693,7 @@ function mergeScalarConditions(target, source) {
       Object.assign(existing, ops);
       continue;
     }
-    if (!forcedValuesEqual(existing, ops)) {
+    if (!deepEqual(existing, ops)) {
       throw new ShapeError(`Conflicting forced where values for "${field}"`);
     }
   }
@@ -1650,27 +1784,27 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
         scalarConditions
       );
     }
-    for (const key of Object.keys(scalarConditions)) {
+    const forcedOnlyKeys = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(whereConfig)) {
       if (COMBINATOR_KEYS.has(key))
         continue;
       if (!(key in fieldSchemas)) {
-        fieldSchemas[key] = import_zod4.z.object({}).strict().optional();
+        forcedOnlyKeys.add(key);
       }
     }
-    for (const key of Object.keys(relationForced)) {
+    for (const key of Object.keys(scalarConditions)) {
+      if (COMBINATOR_KEYS.has(key))
+        continue;
       if (!(key in fieldSchemas)) {
-        fieldSchemas[key] = import_zod4.z.object({}).strict().optional();
+        fieldSchemas[key] = import_zod5.z.object({}).strict().optional();
       }
     }
-    const schema = Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict().optional() : null;
-    const forcedOnlyKeys = /* @__PURE__ */ new Set();
-    for (const key of Object.keys(whereConfig)) {
-      if (COMBINATOR_KEYS.has(key))
-        continue;
+    for (const key of Object.keys(relationForced)) {
       if (!(key in fieldSchemas)) {
-        forcedOnlyKeys.add(key);
+        fieldSchemas[key] = import_zod5.z.object({}).strict().optional();
       }
     }
+    const schema = Object.keys(fieldSchemas).length > 0 ? import_zod5.z.object(fieldSchemas).strict().optional() : null;
     return {
       schema,
       forced: {
@@ -1701,12 +1835,12 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
         );
       }
       if (key === "NOT") {
-        fieldSchemas[key] = import_zod4.z.union([
+        fieldSchemas[key] = import_zod5.z.union([
           elementSchema,
-          import_zod4.z.preprocess(coerceToArray, import_zod4.z.array(elementSchema).min(1))
+          import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(elementSchema).min(1))
         ]).optional();
       } else {
-        fieldSchemas[key] = import_zod4.z.preprocess(coerceToArray, import_zod4.z.array(elementSchema).min(1)).optional();
+        fieldSchemas[key] = import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(elementSchema).min(1)).optional();
       }
     }
     if (hasWhereForced(result.forced)) {
@@ -1775,6 +1909,11 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
           `Empty nested where for relation "${key}.${op}" on model "${model}". Define at least one field.`
         );
       }
+      if (NEGATIVE_RELATION_OPS.has(op) && nested.schema && hasWhereForced(nested.forced)) {
+        throw new ShapeError(
+          `Relation filter "${key}.${op}" on model "${model}" mixes client-controlled and forced conditions. Under negative relation operators (none, isNot), merging weakens the filter. Either move forced conditions to a separate top-level "${op}" branch, or make all conditions under this operator client-controlled or all forced.`
+        );
+      }
       if (nested.schema) {
         if (!hasWhereForced(nested.forced)) {
           opSchemas[op] = nested.schema.refine(
@@ -1799,7 +1938,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
     }
     if (hasClientOps) {
       const clientOpKeys = Object.keys(opSchemas);
-      const opObjSchema = import_zod4.z.object(opSchemas).strict();
+      const opObjSchema = import_zod5.z.object(opSchemas).strict();
       if (Object.keys(opForced).length === 0 && !hasForcedNull) {
         fieldSchemas[key] = opObjSchema.refine(
           (v) => clientOpKeys.some(
@@ -1885,10 +2024,10 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
         );
       }
       if (modeConfigValue === true) {
-        opSchemas.mode = import_zod4.z.enum(["default", "insensitive"]).optional();
+        opSchemas.mode = import_zod5.z.enum(["default", "insensitive"]).optional();
       } else {
         const actualModeValue = isForcedValue(modeConfigValue) ? modeConfigValue.value : modeConfigValue;
-        const modeSchema = import_zod4.z.enum(["default", "insensitive"]);
+        const modeSchema = import_zod5.z.enum(["default", "insensitive"]);
         let parsed;
         try {
           parsed = modeSchema.parse(actualModeValue);
@@ -1900,10 +2039,10 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
         fieldForced.mode = parsed;
       }
     } else if (hasModeCompatibleOp) {
-      opSchemas.mode = import_zod4.z.enum(["default", "insensitive"]).optional();
+      opSchemas.mode = import_zod5.z.enum(["default", "insensitive"]).optional();
     }
     if (hasClientOps) {
-      const opObj = import_zod4.z.object(opSchemas).strict();
+      const opObj = import_zod5.z.object(opSchemas).strict();
       const refined = opObj.refine(
         (v) => clientOpKeys.some(
           (k) => v[k] !== void 0
@@ -1919,7 +2058,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
           enumMap,
           scalarBase
         );
-        fieldSchemas[fieldName] = import_zod4.z.union([refined, equalsBase]).optional();
+        fieldSchemas[fieldName] = import_zod5.z.union([refined, equalsBase]).optional();
       } else {
         fieldSchemas[fieldName] = refined.optional();
       }
@@ -1933,15 +2072,8 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
       (constraint) => constraint.selector === selector
     ) ?? null;
   }
-  function buildDirectUniqueSchema(fieldMeta) {
-    const base = createBaseType(fieldMeta, enumMap, scalarBase);
-    if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
-      return wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, base);
-    }
-    return base;
-  }
   function parseForcedUniqueValue(model, fieldName, fieldMeta, value) {
-    const schema = buildDirectUniqueSchema(fieldMeta);
+    const schema = buildDirectScalarSchema(fieldMeta, enumMap, scalarBase);
     const actual = isForcedValue(value) ? value.value : value;
     try {
       return schema.parse(actual);
@@ -2019,7 +2151,11 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
               `Invalid compound unique where shape for "${model}.${key}.${fieldName}". Prisma compound unique selectors do not accept filter operator objects${operators.length ? `: ${operators.join(", ")}` : ""}. Use direct values only.`
             );
           }
-          const directSchema2 = buildDirectUniqueSchema(fieldMeta2);
+          const directSchema2 = buildDirectScalarSchema(
+            fieldMeta2,
+            enumMap,
+            scalarBase
+          );
           if (fieldValue === true) {
             nestedSchemas[fieldName] = directSchema2;
           } else {
@@ -2032,7 +2168,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
           }
         }
         if (Object.keys(nestedSchemas).length > 0) {
-          fieldSchemas[key] = import_zod4.z.object(nestedSchemas).strict();
+          fieldSchemas[key] = import_zod5.z.object(nestedSchemas).strict();
         }
         if (Object.keys(forcedCompound).length > 0) {
           forcedConditions[key] = forcedCompound;
@@ -2066,7 +2202,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
           `Invalid unique where shape for "${model}.${key}". Prisma WhereUniqueInput does not accept operators: ${keys.join(", ")}. Use a direct unique value shape, for example { ${key}: true }.`
         );
       }
-      const directSchema = buildDirectUniqueSchema(fieldMeta);
+      const directSchema = buildDirectScalarSchema(fieldMeta, enumMap, scalarBase);
       if (value === true) {
         fieldSchemas[key] = directSchema;
         continue;
@@ -2080,7 +2216,7 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
       forcedOnlyKeys.add(key);
     }
     return {
-      schema: Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict() : null,
+      schema: Object.keys(fieldSchemas).length > 0 ? import_zod5.z.object(fieldSchemas).strict() : null,
       forced: {
         conditions: forcedConditions,
         relations: {}
@@ -2092,31 +2228,13 @@ function createWhereBuilder(typeMap, enumMap, scalarBase, uniqueMap = {}) {
 }
 
 // src/runtime/query-builder-args.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("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 isPlainRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function formatUniqueConstraint2(constraint) {
-  return constraint.fields.length === 1 ? constraint.selector : `${constraint.selector}(${constraint.fields.join(", ")})`;
-}
-function formatUniqueConstraints2(constraints) {
-  return constraints.map(formatUniqueConstraint2).join(" | ");
-}
 function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
-  const sortEnum = import_zod5.z.enum(["asc", "desc"]);
-  const nullsEnum = import_zod5.z.enum(["first", "last"]);
-  const sortWithNulls = import_zod5.z.object({ sort: sortEnum, nulls: nullsEnum.optional() }).strict();
-  const scalarOrderSchema = import_zod5.z.union([sortEnum, sortWithNulls]);
+  const sortEnum = import_zod6.z.enum(["asc", "desc"]);
+  const nullsEnum = import_zod6.z.enum(["first", "last"]);
+  const sortWithNulls = import_zod6.z.object({ sort: sortEnum, nulls: nullsEnum.optional() }).strict();
+  const scalarOrderSchema = import_zod6.z.union([sortEnum, sortWithNulls]);
   function validateScalarOrderByField(fieldName, model, modelFields) {
     const fieldMeta = modelFields[fieldName];
     if (!fieldMeta)
@@ -2135,6 +2253,16 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       );
   }
   function buildOrderBySchema(model, orderByConfig) {
+    if (!isPlainObject(orderByConfig)) {
+      throw new ShapeError(
+        `orderBy shape config on model "${model}" must be an object of fields`
+      );
+    }
+    if (Object.keys(orderByConfig).length === 0) {
+      throw new ShapeError(
+        `Empty orderBy config on model "${model}". Define at least one field.`
+      );
+    }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
@@ -2150,53 +2278,35 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         fieldSchemas[fieldName] = scalarOrderSchema.optional();
         continue;
       }
-      if (!isPlainRecord(config)) {
+      if (!isPlainObject(config)) {
         throw new ShapeError(
-          `orderBy config for "${fieldName}" on model "${model}" must be true or a relation aggregate object`
+          `orderBy config for "${fieldName}" on model "${model}" must be true or a relation config object`
         );
       }
       if (!fieldMeta.isRelation) {
-        const allowedOps = getSupportedOperators(
-          fieldMeta.type,
-          fieldMeta.isList
+        throw new ShapeError(
+          `orderBy config for scalar field "${model}.${fieldName}" must be true. Operator objects are not valid in orderBy.`
         );
-        const opSchemas = {};
-        for (const [op, enabled] of Object.entries(config)) {
-          if (enabled !== true) {
-            throw new ShapeError(
-              `orderBy operator config for "${model}.${fieldName}.${op}" must be true`
-            );
-          }
-          if (!allowedOps.includes(op)) {
-            throw new ShapeError(
-              `Operator "${op}" not supported for orderBy field "${model}.${fieldName}"`
-            );
-          }
-          opSchemas[op] = scalarOrderSchema.optional();
-        }
-        const opKeys = Object.keys(opSchemas);
-        fieldSchemas[fieldName] = import_zod5.z.object(opSchemas).strict().refine(
-          (v) => opKeys.some(
-            (k) => v[k] !== void 0
-          ),
-          {
-            message: `orderBy field "${fieldName}" must specify at least one operator`
-          }
-        ).optional();
-        continue;
       }
       if (fieldMeta.isList) {
-        if (!("_count" in config)) {
+        const configKeys = Object.keys(config);
+        if (!configKeys.includes("_count")) {
           throw new ShapeError(
             `To-many relation orderBy "${fieldName}" only supports _count`
           );
         }
+        const extraKeys = configKeys.filter((k) => k !== "_count");
+        if (extraKeys.length > 0) {
+          throw new ShapeError(
+            `To-many relation orderBy "${fieldName}" only supports _count. Unexpected keys: ${extraKeys.join(", ")}`
+          );
+        }
         if (config._count !== true) {
           throw new ShapeError(
             `orderBy relation aggregate "${fieldName}._count" must be true`
           );
         }
-        fieldSchemas[fieldName] = import_zod5.z.object({
+        fieldSchemas[fieldName] = import_zod6.z.object({
           _count: sortEnum.optional()
         }).strict().optional();
         continue;
@@ -2207,17 +2317,11 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       );
       fieldSchemas[fieldName] = nested;
     }
-    const fieldKeys = Object.keys(fieldSchemas);
-    const singleSchema = import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => fieldKeys.some(
-        (k) => v[k] !== void 0
-      ),
-      { message: "orderBy must specify at least one field" }
+    const singleSchema = strictObjectRequiringOne(
+      fieldSchemas,
+      "orderBy must specify at least one field"
     );
-    return import_zod5.z.union([
-      singleSchema,
-      import_zod5.z.preprocess(coerceToArray, import_zod5.z.array(singleSchema).min(1))
-    ]).optional();
+    return singleOrArraySchema(singleSchema).optional();
   }
   function buildTakeSchema(config) {
     if (typeof config === "number") {
@@ -2227,7 +2331,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       if (config <= 0) {
         throw new ShapeError("take must be a positive integer");
       }
-      return import_zod5.z.literal(config).optional();
+      return import_zod6.z.number().int().min(1).max(config).default(config);
     }
     if (!config || typeof config !== "object" || Array.isArray(config)) {
       throw new ShapeError("take config must be a number or { max, default? }");
@@ -2252,9 +2356,9 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       if (config.default > config.max) {
         throw new ShapeError("take.default cannot exceed take.max");
       }
-      return import_zod5.z.number().int().min(1).max(config.max).default(config.default);
+      return import_zod6.z.number().int().min(1).max(config.max).default(config.default);
     }
-    return import_zod5.z.number().int().min(1).max(config.max).optional();
+    return import_zod6.z.number().int().min(1).max(config.max).optional();
   }
   function buildCursorFieldSchema(model, fieldName) {
     const modelFields = typeMap[model];
@@ -2276,11 +2380,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         `List field "${fieldName}" cannot be used in cursor`
       );
     }
-    const base = createBaseType(fieldMeta, enumMap, scalarBase);
-    if (!fieldMeta.isEnum && !fieldMeta.isRelation && !fieldMeta.isUnsupported) {
-      return wrapWithInputCoercion(fieldMeta.type, fieldMeta.isList, base);
-    }
-    return base;
+    return buildDirectScalarSchema(fieldMeta, enumMap, scalarBase);
   }
   function cursorConfigMatchesConstraint(cursorConfig, constraint) {
     if (!(constraint.selector in cursorConfig))
@@ -2289,66 +2389,55 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     if (constraint.fields.length === 1) {
       return value === true;
     }
-    if (!isPlainRecord(value))
+    if (!isPlainObject(value))
       return false;
     const keys = Object.keys(value);
     if (keys.length !== constraint.fields.length)
       return false;
     return constraint.fields.every((field) => value[field] === true);
   }
-  function getUniqueConstraints(model) {
-    const constraints = uniqueMap[model];
-    if (constraints && constraints.length > 0) {
-      return constraints;
-    }
-    const modelFields = typeMap[model];
-    if (!modelFields) {
-      throw new ShapeError(`Unknown model: ${model}`);
-    }
-    const inferred = [];
-    for (const [fieldName, fieldMeta] of Object.entries(modelFields)) {
-      if (fieldMeta.isRelation)
-        continue;
-      if (fieldMeta.isId || fieldMeta.isUnique) {
-        inferred.push({
-          selector: fieldName,
-          fields: [fieldName]
-        });
-      }
-    }
-    return inferred;
-  }
   function buildCursorSchema(model, cursorConfig) {
-    const constraints = getUniqueConstraints(model);
+    const constraints = uniqueMap[model] ?? [];
     if (constraints.length === 0) {
       throw new ShapeError(
         `cursor on model "${model}" requires at least one unique constraint`
       );
     }
-    const matching = constraints.find(
+    const matching = constraints.filter(
       (constraint) => cursorConfigMatchesConstraint(cursorConfig, constraint)
     );
-    if (!matching) {
+    if (matching.length === 0) {
       throw new ShapeError(
-        `cursor on model "${model}" must exactly match a unique selector: ${formatUniqueConstraints2(constraints)}`
+        `cursor on model "${model}" must match a unique selector: ${formatUniqueConstraints(constraints)}`
       );
     }
+    const coveredKeys = new Set(matching.map((c) => c.selector));
+    for (const key of Object.keys(cursorConfig)) {
+      if (!coveredKeys.has(key)) {
+        throw new ShapeError(
+          `cursor field "${key}" on model "${model}" does not match any unique selector. Unique selectors: ${formatUniqueConstraints(constraints)}`
+        );
+      }
+    }
     const fieldSchemas = {};
-    if (matching.fields.length === 1) {
-      fieldSchemas[matching.selector] = buildCursorFieldSchema(
-        model,
-        matching.fields[0]
-      ).optional();
-    } else {
-      const nestedSchemas = {};
-      for (const field of matching.fields) {
-        nestedSchemas[field] = buildCursorFieldSchema(model, field);
+    for (const constraint of matching) {
+      if (constraint.fields.length === 1) {
+        fieldSchemas[constraint.selector] = buildCursorFieldSchema(
+          model,
+          constraint.fields[0]
+        ).optional();
+      } else {
+        const nestedSchemas = {};
+        for (const field of constraint.fields) {
+          nestedSchemas[field] = buildCursorFieldSchema(model, field);
+        }
+        fieldSchemas[constraint.selector] = import_zod6.z.object(nestedSchemas).strict().optional();
       }
-      fieldSchemas[matching.selector] = import_zod5.z.object(nestedSchemas).strict().optional();
     }
-    return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => v[matching.selector] !== void 0,
-      { message: `cursor must specify "${matching.selector}"` }
+    const selectorKeys = matching.map((c) => c.selector);
+    return strictObjectRequiringOne(
+      fieldSchemas,
+      `cursor must specify one of: ${selectorKeys.join(", ")}`
     ).optional();
   }
   function buildDistinctSchema(model, distinctConfig) {
@@ -2373,10 +2462,8 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         );
       allowedFields.add(fieldName);
     }
-    return import_zod5.z.union([
-      import_zod5.z.enum([...allowedFields]),
-      import_zod5.z.array(import_zod5.z.enum([...allowedFields])).min(1)
-    ]).optional();
+    const fieldEnum = import_zod6.z.enum([...allowedFields]);
+    return import_zod6.z.union([fieldEnum, import_zod6.z.array(fieldEnum).min(1)]).optional();
   }
   function buildBySchema(model, byConfig) {
     const modelFields = typeMap[model];
@@ -2409,7 +2496,7 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       }
       allowedFields.add(fieldName);
     }
-    return import_zod5.z.array(import_zod5.z.enum([...allowedFields])).min(1);
+    return import_zod6.z.array(import_zod6.z.enum([...allowedFields])).min(1);
   }
   function buildHavingSchema(model, havingConfig) {
     const modelFields = typeMap[model];
@@ -2450,22 +2537,21 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
         ).optional();
       }
       if (fieldMeta.type === "String") {
-        opSchemas.mode = import_zod5.z.enum(["default", "insensitive"]).optional();
+        opSchemas.mode = import_zod6.z.enum(["default", "insensitive"]).optional();
       }
       const opKeys = Object.keys(opSchemas).filter((key) => key !== "mode");
-      fieldSchemas[fieldName] = import_zod5.z.object(opSchemas).strict().refine(
+      const opShape = { ...opSchemas };
+      const opObjSchema = import_zod6.z.object(opShape).strict().refine(
         (v) => opKeys.some((k) => v[k] !== void 0),
         {
           message: `having field "${fieldName}" must specify at least one operator`
         }
-      ).optional();
+      );
+      fieldSchemas[fieldName] = opObjSchema.optional();
     }
-    const fieldKeys = Object.keys(fieldSchemas);
-    return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => fieldKeys.some(
-        (k) => v[k] !== void 0
-      ),
-      { message: "having must specify at least one field" }
+    return strictObjectRequiringOne(
+      fieldSchemas,
+      "having must specify at least one field"
     ).optional();
   }
   function buildAggregateFieldSchema(model, op, config) {
@@ -2474,47 +2560,45 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       throw new ShapeError(`Unknown model: ${model}`);
     requireConfigTrue(config, `${op} on model "${model}"`);
     const allowedTypes = op === "_avg" || op === "_sum" ? NUMERIC_TYPES : COMPARABLE_TYPES;
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(config)) {
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(
-          `Unknown field "${fieldName}" on model "${model}" in ${op}`
-        );
-      if (fieldMeta.isRelation)
-        throw new ShapeError(
-          `Relation field "${fieldName}" cannot be used in ${op}`
-        );
-      if (fieldMeta.isList)
-        throw new ShapeError(
-          `List field "${fieldName}" cannot be used in ${op}`
-        );
-      if (!allowedTypes.has(fieldMeta.type)) {
-        throw new ShapeError(
-          `Field "${fieldName}" of type "${fieldMeta.type}" cannot be used in ${op}`
-        );
+    return buildLiteralTrueSchema(
+      Object.keys(config),
+      `${op} must specify at least one field`,
+      (fieldName) => {
+        const fieldMeta = modelFields[fieldName];
+        if (!fieldMeta)
+          throw new ShapeError(
+            `Unknown field "${fieldName}" on model "${model}" in ${op}`
+          );
+        if (fieldMeta.isRelation)
+          throw new ShapeError(
+            `Relation field "${fieldName}" cannot be used in ${op}`
+          );
+        if (fieldMeta.isList)
+          throw new ShapeError(
+            `List field "${fieldName}" cannot be used in ${op}`
+          );
+        if (!allowedTypes.has(fieldMeta.type)) {
+          throw new ShapeError(
+            `Field "${fieldName}" of type "${fieldMeta.type}" cannot be used in ${op}`
+          );
+        }
       }
-      fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
-    }
-    const aggregateFieldKeys = Object.keys(fieldSchemas);
-    return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => aggregateFieldKeys.some(
-        (k) => v[k] !== void 0
-      ),
-      { message: `${op} must specify at least one field` }
-    ).optional();
+    );
   }
   function buildCountFieldSchema(model, config, context) {
     if (config === true) {
-      return import_zod5.z.literal(true).optional();
+      return import_zod6.z.literal(true).optional();
     }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
     requireConfigTrue(config, `${context} on model "${model}"`);
-    const fieldSchemas = {};
-    for (const fieldName of Object.keys(config)) {
-      if (fieldName !== "_all") {
+    return buildLiteralTrueSchema(
+      Object.keys(config),
+      `${context} must specify at least one field`,
+      (fieldName) => {
+        if (fieldName === "_all")
+          return;
         const fieldMeta = modelFields[fieldName];
         if (!fieldMeta)
           throw new ShapeError(
@@ -2525,45 +2609,30 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
             `Relation field "${fieldName}" cannot be used in ${context}`
           );
       }
-      fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
-    }
-    const countFieldKeys = Object.keys(fieldSchemas);
-    return import_zod5.z.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 = import_zod5.z.literal(true).optional();
-        continue;
+    return buildLiteralTrueSchema(
+      Object.keys(selectConfig),
+      "count select must specify at least one field",
+      (fieldName) => {
+        if (fieldName === "_all")
+          return;
+        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`
+          );
       }
-      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] = import_zod5.z.literal(true).optional();
-    }
-    const countSelectKeys = Object.keys(fieldSchemas);
-    return import_zod5.z.object(fieldSchemas).strict().refine(
-      (v) => countSelectKeys.some(
-        (k) => v[k] !== void 0
-      ),
-      { message: "count select must specify at least one field" }
-    ).optional();
+    );
   }
   return {
     buildOrderBySchema,
@@ -2579,25 +2648,64 @@ function createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
 }
 
 // src/runtime/query-builder-projection.ts
-var import_zod6 = require("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",
-  "include",
-  "where",
-  "orderBy",
-  "cursor",
-  "take",
-  "skip"
-]);
+var import_zod7 = require("zod");
+
+// src/shared/projection-defaults.ts
+function buildDefaultProjectionInput(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 {
+      result[key] = buildRelationArgsSkeleton(value);
+    }
+  }
+  return result;
+}
+function buildRelationArgsSkeleton(config) {
+  const skeleton = {};
+  if (config.select) {
+    skeleton.select = buildDefaultProjectionInput(config.select);
+  }
+  if (config.include) {
+    skeleton.include = buildDefaultProjectionInput(config.include);
+  }
+  return skeleton;
+}
+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 buildDefaultProjectionBody(shape) {
+  if (shape.select) {
+    return { select: buildDefaultProjectionInput(shape.select) };
+  }
+  if (shape.include) {
+    return { include: buildDefaultProjectionInput(shape.include) };
+  }
+  return {};
+}
+
+// src/runtime/query-builder-projection.ts
+var KNOWN_NESTED_KEYS = {
+  include: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip"]),
+  select: /* @__PURE__ */ new Set(["select", "include", "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) {
@@ -2609,13 +2717,25 @@ function validateNestedKeys(keys, allowed, context) {
     }
   }
 }
-function createProjectionBuilder(typeMap, enumMap, deps) {
+function hasDefinedKeys(v) {
+  return Object.values(v).some((value) => value !== void 0);
+}
+function wrapRelationSchema(nestedObj, skeleton) {
+  const collapsed = nestedObj.transform(
+    (v) => isPlainObject(v) && !hasDefinedKeys(v) ? true : v
+  );
+  return import_zod7.z.preprocess(
+    (v) => v === true ? deepClone(skeleton) : v,
+    collapsed
+  );
+}
+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: import_zod6.z.literal(true).optional(), forcedCountWhere: {} };
+      return { schema: import_zod7.z.literal(true).optional(), forcedCountWhere: {} };
     }
     if (!isPlainObject(config) || !("select" in config)) {
       throw new ShapeError(
@@ -2651,294 +2771,196 @@ function createProjectionBuilder(typeMap, enumMap, deps) {
       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] = import_zod6.z.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 = import_zod6.z.object(nestedSchemas).strict();
-          countSelectFields[fieldName] = import_zod6.z.union([import_zod6.z.literal(true), nestedObj]).optional();
-          if (hasWhereForced(forced)) {
-            forcedCountWhere[fieldName] = forced;
-          }
-        } else {
-          countSelectFields[fieldName] = import_zod6.z.literal(true).optional();
-        }
-      } else {
+        countSelectFields[fieldName] = import_zod7.z.literal(true).optional();
+        continue;
+      }
+      if (!isPlainObject(fieldConfig)) {
         throw new ShapeError(
           `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
         );
       }
+      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 = import_zod7.z.object(nestedSchemas).strict();
+        countSelectFields[fieldName] = import_zod7.z.union([import_zod7.z.literal(true), nestedObj]).optional();
+        if (hasWhereForced(forced)) {
+          forcedCountWhere[fieldName] = forced;
+        }
+      } else {
+        countSelectFields[fieldName] = import_zod7.z.literal(true).optional();
+      }
     }
-    const countSelectKeys = Object.keys(countSelectFields);
-    const selectSchema = import_zod6.z.object(countSelectFields).strict().refine(
-      (v) => countSelectKeys.some((k) => v[k] !== void 0),
-      { message: "_count.select must specify at least one field" }
+    const selectSchema = strictObjectRequiringOne(
+      countSelectFields,
+      "_count.select must specify at least one field"
     );
     return {
-      schema: import_zod6.z.object({ select: selectSchema }).strict().optional(),
+      schema: import_zod7.z.object({ select: selectSchema }).strict().optional(),
       forcedCountWhere
     };
   }
-  function buildIncludeSchema(model, includeConfig, depth) {
+  function buildNestedRelSchemas(relatedType, config, depth) {
+    const nestedSchemas = {};
+    const relForced = {};
+    if (config.where) {
+      const { schema: whereSchema, forced } = deps.buildWhereSchema(
+        relatedType,
+        config.where
+      );
+      if (whereSchema)
+        nestedSchemas["where"] = whereSchema;
+      if (hasWhereForced(forced))
+        relForced.where = forced;
+    }
+    if (config.include) {
+      const nested = buildProjectionSchema("include", relatedType, config.include, depth + 1);
+      nestedSchemas["include"] = nested.schema;
+      if (Object.keys(nested.forcedTree).length > 0)
+        relForced.include = nested.forcedTree;
+      if (Object.keys(nested.forcedCountWhere).length > 0) {
+        relForced._countWhere = nested.forcedCountWhere;
+        relForced._countWherePlacement = "include";
+      }
+    }
+    if (config.select) {
+      const nested = buildProjectionSchema("select", relatedType, config.select, depth + 1);
+      nestedSchemas["select"] = nested.schema;
+      if (Object.keys(nested.forcedTree).length > 0)
+        relForced.select = nested.forcedTree;
+      if (Object.keys(nested.forcedCountWhere).length > 0) {
+        relForced._countWhere = nested.forcedCountWhere;
+        relForced._countWherePlacement = "select";
+      }
+    }
+    if (config.orderBy) {
+      nestedSchemas["orderBy"] = deps.buildOrderBySchema(relatedType, config.orderBy);
+    }
+    if (config.cursor) {
+      nestedSchemas["cursor"] = deps.buildCursorSchema(relatedType, config.cursor);
+    }
+    if (config.take) {
+      nestedSchemas["take"] = deps.buildTakeSchema(config.take);
+    }
+    if (config.skip) {
+      nestedSchemas["skip"] = import_zod7.z.number().int().min(0).optional();
+    }
+    return { nestedSchemas, relForced };
+  }
+  function buildProjectionSchema(mode, model, projectionConfig, 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.`
+        `${mode === "include" ? "Include" : "Select"} 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) {
+    if (Object.keys(projectionConfig).length === 0) {
       throw new ShapeError(
-        `Empty include config on model "${model}". Define at least one relation.`
+        `Empty ${mode} config on model "${model}". Define at least one ${mode === "include" ? "relation" : "field"}.`
       );
     }
     const modelFields = typeMap[model];
     if (!modelFields)
       throw new ShapeError(`Unknown model: ${model}`);
+    const allowedNestedKeys = KNOWN_NESTED_KEYS[mode];
     const fieldSchemas = {};
     const forcedTree = {};
     let topLevelForcedCountWhere = {};
-    for (const [relName, config] of Object.entries(includeConfig)) {
-      if (relName === "_count") {
+    for (const [fieldName, config] of Object.entries(projectionConfig)) {
+      if (fieldName === "_count") {
         const countResult = buildIncludeCountSchema(model, config);
         fieldSchemas["_count"] = countResult.schema;
         topLevelForcedCountWhere = countResult.forcedCountWhere;
         continue;
       }
-      const fieldMeta = modelFields[relName];
+      const fieldMeta = modelFields[fieldName];
       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(`Unknown field "${fieldName}" on model "${model}"`);
+      if (mode === "include" && !fieldMeta.isRelation) {
+        throw new ShapeError(`Field "${fieldName}" is not a relation on model "${model}"`);
+      }
       if (config === true) {
-        fieldSchemas[relName] = import_zod6.z.literal(true).optional();
-      } else {
-        validateNestedKeys(
-          Object.keys(config),
-          KNOWN_NESTED_INCLUDE_KEYS,
-          `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".`);
-        }
-        if (!fieldMeta.isList) {
-          if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
-            throw new ShapeError(
-              `Relation "${relName}" on model "${model}" is to-one. Only "include" and "select" are supported for to-one nested reads, not where/orderBy/cursor/take/skip.`
-            );
-          }
-        }
-        const nestedSchemas = {};
-        const relForced = {};
-        if (config.where) {
-          const { schema: whereSchema, forced } = deps.buildWhereSchema(
-            fieldMeta.type,
-            config.where
-          );
-          if (whereSchema)
-            nestedSchemas["where"] = whereSchema;
-          if (hasWhereForced(forced))
-            relForced.where = forced;
-        }
-        if (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) {
-            relForced._countWhere = nested.forcedCountWhere;
-            relForced._countWherePlacement = "include";
-          }
-        }
-        if (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) {
-            relForced._countWhere = nested.forcedCountWhere;
-            relForced._countWherePlacement = "select";
-          }
-        }
-        if (config.orderBy) {
-          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"] = import_zod6.z.number().int().min(0).optional();
-        }
-        const nestedObj = import_zod6.z.object(nestedSchemas).strict();
-        fieldSchemas[relName] = import_zod6.z.union([import_zod6.z.literal(true), nestedObj]).optional();
-        if (Object.keys(relForced).length > 0)
-          forcedTree[relName] = relForced;
-      }
-    }
-    const includeFieldKeys = Object.keys(fieldSchemas);
-    const baseSchema = import_zod6.z.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,
-      forcedTree,
-      forcedCountWhere: topLevelForcedCountWhere
-    };
-  }
-  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}`);
-    const fieldSchemas = {};
-    const forcedTree = {};
-    let topLevelForcedCountWhere = {};
-    for (const [fieldName, config] of Object.entries(selectConfig)) {
-      if (fieldName === "_count") {
-        const countResult = buildIncludeCountSchema(model, config);
-        fieldSchemas["_count"] = countResult.schema;
-        topLevelForcedCountWhere = countResult.forcedCountWhere;
+        fieldSchemas[fieldName] = import_zod7.z.literal(true).optional();
         continue;
       }
-      const fieldMeta = modelFields[fieldName];
-      if (!fieldMeta)
-        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
-      if (config === true) {
-        fieldSchemas[fieldName] = import_zod6.z.literal(true).optional();
-      } else {
-        if (!fieldMeta.isRelation) {
-          throw new ShapeError(`Nested select args only valid for relations, not scalar "${fieldName}" on model "${model}"`);
-        }
-        validateNestedKeys(
-          Object.keys(config),
-          KNOWN_NESTED_SELECT_KEYS,
-          `nested select for "${fieldName}" on model "${model}"`
-        );
-        if (config.select && config.include) {
-          throw new ShapeError(`Nested select for "${fieldName}" cannot define both "select" and "include".`);
-        }
-        if (!fieldMeta.isList) {
-          if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
-            throw new ShapeError(
-              `Relation "${fieldName}" on model "${model}" is to-one. Only "select" and "include" are supported for to-one nested reads, not where/orderBy/cursor/take/skip.`
-            );
-          }
-        }
-        const nestedSchemas = {};
-        const relForced = {};
-        if (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) {
-            relForced._countWhere = nested.forcedCountWhere;
-            relForced._countWherePlacement = "select";
-          }
-        }
-        if (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) {
-            relForced._countWhere = nested.forcedCountWhere;
-            relForced._countWherePlacement = "include";
-          }
-        }
-        if (config.where) {
-          const { schema: whereSchema, forced } = deps.buildWhereSchema(
-            fieldMeta.type,
-            config.where
+      if (mode === "select" && !fieldMeta.isRelation) {
+        throw new ShapeError(`Nested select args only valid for relations, not scalar "${fieldName}" on model "${model}"`);
+      }
+      const contextLabel = `nested ${mode} for "${fieldName}" on model "${model}"`;
+      validateNestedKeys(Object.keys(config), allowedNestedKeys, contextLabel);
+      if (config.select && config.include) {
+        throw new ShapeError(`Nested ${mode} for "${fieldName}" cannot define both "select" and "include".`);
+      }
+      if (!fieldMeta.isList) {
+        if (config.where || config.orderBy || config.cursor || config.take || config.skip) {
+          throw new ShapeError(
+            `Relation "${fieldName}" on model "${model}" is to-one. Only "select" and "include" are supported for to-one nested reads, not where/orderBy/cursor/take/skip.`
           );
-          if (whereSchema)
-            nestedSchemas["where"] = whereSchema;
-          if (hasWhereForced(forced))
-            relForced.where = forced;
-        }
-        if (config.orderBy) {
-          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"] = import_zod6.z.number().int().min(0).optional();
         }
-        const nestedObj = import_zod6.z.object(nestedSchemas).strict();
-        fieldSchemas[fieldName] = import_zod6.z.union([import_zod6.z.literal(true), nestedObj]).optional();
-        if (Object.keys(relForced).length > 0)
-          forcedTree[fieldName] = relForced;
-      }
-    }
-    const selectFieldKeys = Object.keys(fieldSchemas);
-    const baseSchema = import_zod6.z.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();
+      }
+      const { nestedSchemas, relForced } = buildNestedRelSchemas(fieldMeta.type, config, currentDepth);
+      const nestedObj = import_zod7.z.object(nestedSchemas).strict();
+      fieldSchemas[fieldName] = wrapRelationSchema(
+        nestedObj,
+        buildRelationArgsSkeleton(config)
+      ).optional();
+      if (Object.keys(relForced).length > 0)
+        forcedTree[fieldName] = relForced;
+    }
+    const schema = Object.keys(fieldSchemas).length > 0 ? strictObjectRequiringOne(
+      fieldSchemas,
+      `${mode} must specify at least one field`
+    ).optional() : import_zod7.z.object(fieldSchemas).strict().optional();
     return {
       schema,
       forcedTree,
       forcedCountWhere: topLevelForcedCountWhere
     };
   }
-  return { buildIncludeSchema, buildSelectSchema, buildIncludeCountSchema };
+  function buildIncludeSchema(model, includeConfig, depth) {
+    return buildProjectionSchema("include", model, includeConfig, depth);
+  }
+  function buildSelectSchema(model, selectConfig, depth) {
+    return buildProjectionSchema("select", model, selectConfig, depth);
+  }
+  return { buildIncludeSchema, buildSelectSchema, buildIncludeCountSchema, buildProjectionSchema };
 }
 
 // src/shared/operation-shape-keys.ts
 var OPERATION_SHAPE_KEYS = {
   findMany: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
+  findManyPaginated: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   findFirst: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   findFirstOrThrow: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   findUnique: ["where", "include", "select"],
   findUniqueOrThrow: ["where", "include", "select"],
-  findManyPaginated: ["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"],
   count: ["where", "select", "cursor", "orderBy", "skip", "take"],
   aggregate: ["where", "orderBy", "cursor", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"],
-  groupBy: ["where", "by", "having", "_count", "_avg", "_sum", "_min", "_max", "orderBy", "take", "skip"],
-  create: ["data", "select", "include"],
-  createMany: ["data"],
-  createManyAndReturn: ["data", "select", "include"],
-  update: ["data", "where", "select", "include"],
-  updateMany: ["data", "where"],
-  updateManyAndReturn: ["data", "where", "select", "include"],
-  upsert: ["where", "create", "update", "select", "include"],
-  delete: ["where", "select", "include"],
+  groupBy: ["where", "orderBy", "by", "having", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"],
+  create: ["data", "include", "select"],
+  createMany: ["data", "skipDuplicates"],
+  createManyAndReturn: ["data", "select", "skipDuplicates"],
+  update: ["where", "data", "include", "select"],
+  updateMany: ["where", "data"],
+  updateManyAndReturn: ["where", "data", "select"],
+  upsert: ["where", "create", "update", "include", "select"],
+  delete: ["where", "include", "select"],
   deleteMany: ["where"]
 };
 var READ_METHOD_ALLOWED_ARGS = {
@@ -2962,6 +2984,99 @@ var MUTATION_SHAPE_KEYS = {
   delete: new Set(OPERATION_SHAPE_KEYS.delete),
   deleteMany: new Set(OPERATION_SHAPE_KEYS.deleteMany)
 };
+var MUTATION_OPERATION_SPECS = {
+  create: {
+    bodyKeysBase: ["data"],
+    bodyKeysProjection: ["data", "select", "include"],
+    shapeKeysBase: ["data"],
+    shapeKeysProjection: ["data", "select", "include"],
+    supportsProjection: true
+  },
+  createMany: {
+    bodyKeysBase: ["data", "skipDuplicates"],
+    bodyKeysProjection: ["data", "select", "include", "skipDuplicates"],
+    shapeKeysBase: ["data"],
+    shapeKeysProjection: ["data"],
+    supportsProjection: false
+  },
+  createManyAndReturn: {
+    bodyKeysBase: ["data", "skipDuplicates"],
+    bodyKeysProjection: ["data", "select", "include", "skipDuplicates"],
+    shapeKeysBase: ["data"],
+    shapeKeysProjection: ["data", "select", "include"],
+    supportsProjection: true
+  },
+  update: {
+    bodyKeysBase: ["data", "where"],
+    bodyKeysProjection: ["data", "where", "select", "include"],
+    shapeKeysBase: ["data", "where"],
+    shapeKeysProjection: ["data", "where", "select", "include"],
+    supportsProjection: true
+  },
+  updateMany: {
+    bodyKeysBase: ["data", "where"],
+    bodyKeysProjection: ["data", "where"],
+    shapeKeysBase: ["data", "where"],
+    shapeKeysProjection: ["data", "where"],
+    supportsProjection: false
+  },
+  updateManyAndReturn: {
+    bodyKeysBase: ["data", "where"],
+    bodyKeysProjection: ["data", "where", "select", "include"],
+    shapeKeysBase: ["data", "where"],
+    shapeKeysProjection: ["data", "where", "select", "include"],
+    supportsProjection: true
+  },
+  upsert: {
+    bodyKeysBase: ["where", "create", "update", "select", "include"],
+    bodyKeysProjection: ["where", "create", "update", "select", "include"],
+    shapeKeysBase: ["where", "create", "update", "select", "include"],
+    shapeKeysProjection: ["where", "create", "update", "select", "include"],
+    supportsProjection: true
+  },
+  delete: {
+    bodyKeysBase: ["where"],
+    bodyKeysProjection: ["where", "select", "include"],
+    shapeKeysBase: ["where"],
+    shapeKeysProjection: ["where", "select", "include"],
+    supportsProjection: true
+  },
+  deleteMany: {
+    bodyKeysBase: ["where"],
+    bodyKeysProjection: ["where"],
+    shapeKeysBase: ["where"],
+    shapeKeysProjection: ["where"],
+    supportsProjection: false
+  }
+};
+var bodyKeyCache = /* @__PURE__ */ new Map();
+var shapeKeyCache = /* @__PURE__ */ new Map();
+function getAllowedBodyKeys(method, withProjection) {
+  const cacheKey = `${method}\0${withProjection ? "p" : "b"}`;
+  const cached = bodyKeyCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const spec = MUTATION_OPERATION_SPECS[method];
+  if (!spec)
+    throw new Error(`Unknown mutation method "${method}"`);
+  const keys = withProjection && spec.supportsProjection ? spec.bodyKeysProjection : spec.bodyKeysBase;
+  const set = new Set(keys);
+  bodyKeyCache.set(cacheKey, set);
+  return set;
+}
+function getAllowedShapeKeys(method, withProjection) {
+  const cacheKey = `${method}\0${withProjection ? "p" : "b"}`;
+  const cached = shapeKeyCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const spec = MUTATION_OPERATION_SPECS[method];
+  if (!spec)
+    throw new Error(`Unknown mutation method "${method}"`);
+  const keys = withProjection && spec.supportsProjection ? spec.shapeKeysProjection : spec.shapeKeysBase;
+  const set = new Set(keys);
+  shapeKeyCache.set(cacheKey, set);
+  return set;
+}
 
 // src/runtime/query-builder.ts
 var METHOD_ALLOWED_ARGS = READ_METHOD_ALLOWED_ARGS;
@@ -3062,6 +3177,90 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     }
     return shapeOrFn;
   }
+  function buildGroupByOrderBySchema(model, orderBy, by, sortEnum) {
+    const bySet = new Set(by);
+    if (orderBy === true) {
+      const groupByOrderFields2 = {};
+      for (const field of by) {
+        groupByOrderFields2[field] = sortEnum.optional();
+      }
+      groupByOrderFields2._count = sortEnum.optional();
+      const singleSchema2 = strictObjectRequiringOne(
+        groupByOrderFields2,
+        "orderBy must specify at least one field"
+      );
+      return import_zod8.z.union([
+        singleSchema2,
+        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(singleSchema2).min(1))
+      ]).optional();
+    }
+    if (!isPlainObject(orderBy)) {
+      throw new ShapeError(
+        `groupBy orderBy shape on model "${model}" must be true or an object of fields`
+      );
+    }
+    if (Object.keys(orderBy).length === 0) {
+      throw new ShapeError(
+        `Empty groupBy orderBy config on model "${model}". Define at least one field.`
+      );
+    }
+    const groupByOrderFields = {};
+    for (const [fieldName, config] of Object.entries(orderBy)) {
+      if (fieldName === "_count") {
+        if (config === true) {
+          groupByOrderFields._count = sortEnum.optional();
+        } else if (isPlainObject(config)) {
+          if (Object.keys(config).length === 0) {
+            throw new ShapeError(
+              `Empty groupBy orderBy "_count" config on model "${model}". Define at least one by-field.`
+            );
+          }
+          const countFields = {};
+          for (const [countField, countConfig] of Object.entries(config)) {
+            if (countConfig !== true) {
+              throw new ShapeError(
+                `groupBy orderBy "_count.${countField}" config on model "${model}" must be true`
+              );
+            }
+            if (!bySet.has(countField)) {
+              throw new ShapeError(
+                `orderBy _count field "${countField}" must be included in "by" for groupBy`
+              );
+            }
+            countFields[countField] = sortEnum.optional();
+          }
+          groupByOrderFields._count = strictObjectRequiringOne(
+            countFields,
+            "orderBy._count must specify at least one field"
+          ).optional();
+        } else {
+          throw new ShapeError(
+            `groupBy orderBy "_count" config on model "${model}" must be true or an object of by-fields`
+          );
+        }
+        continue;
+      }
+      if (config !== true) {
+        throw new ShapeError(
+          `groupBy orderBy field "${fieldName}" config on model "${model}" must be true`
+        );
+      }
+      if (!bySet.has(fieldName)) {
+        throw new ShapeError(
+          `orderBy field "${fieldName}" must be included in "by" for groupBy`
+        );
+      }
+      groupByOrderFields[fieldName] = sortEnum.optional();
+    }
+    const singleSchema = strictObjectRequiringOne(
+      groupByOrderFields,
+      "orderBy must specify at least one field"
+    );
+    return import_zod8.z.union([
+      singleSchema,
+      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(singleSchema).min(1))
+    ]).optional();
+  }
   function buildShapeZodSchema(model, method, shape) {
     validateShapeArgs(method, shape);
     validateUniqueWhere(model, method, shape);
@@ -3101,73 +3300,19 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
     }
     if (shape.orderBy) {
       if (method === "groupBy" && shape.by) {
-        const sortEnum = import_zod7.z.enum(["asc", "desc"]);
-        const bySet = new Set(shape.by);
+        const sortEnum = import_zod8.z.enum(["asc", "desc"]);
+        schemaFields.orderBy = buildGroupByOrderBySchema(
+          model,
+          shape.orderBy,
+          shape.by,
+          sortEnum
+        );
+      } else {
         if (shape.orderBy === true) {
-          const groupByOrderFields = {};
-          for (const field of shape.by) {
-            groupByOrderFields[field] = sortEnum.optional();
-          }
-          groupByOrderFields._count = sortEnum.optional();
-          const fieldKeys = Object.keys(groupByOrderFields);
-          const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
-            (v) => fieldKeys.some(
-              (k) => v[k] !== void 0
-            ),
-            { message: "orderBy must specify at least one field" }
-          );
-          schemaFields.orderBy = import_zod7.z.union([
-            singleSchema,
-            import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))
-          ]).optional();
-        } else {
-          const groupByOrderFields = {};
-          for (const [fieldName, config] of Object.entries(shape.orderBy)) {
-            if (fieldName === "_count") {
-              if (config === true) {
-                groupByOrderFields._count = sortEnum.optional();
-              } else if (typeof config === "object" && config !== null) {
-                const countFields = {};
-                for (const countField of Object.keys(config)) {
-                  if (!bySet.has(countField)) {
-                    throw new ShapeError(
-                      `orderBy _count field "${countField}" must be included in "by" for groupBy`
-                    );
-                  }
-                  countFields[countField] = sortEnum.optional();
-                }
-                const countKeys = Object.keys(countFields);
-                groupByOrderFields._count = import_zod7.z.object(countFields).strict().refine(
-                  (v) => countKeys.some(
-                    (k) => v[k] !== void 0
-                  ),
-                  {
-                    message: "orderBy._count must specify at least one field"
-                  }
-                ).optional();
-              }
-              continue;
-            }
-            if (!bySet.has(fieldName)) {
-              throw new ShapeError(
-                `orderBy field "${fieldName}" must be included in "by" for groupBy`
-              );
-            }
-            groupByOrderFields[fieldName] = sortEnum.optional();
-          }
-          const fieldKeys = Object.keys(groupByOrderFields);
-          const singleSchema = import_zod7.z.object(groupByOrderFields).strict().refine(
-            (v) => fieldKeys.some(
-              (k) => v[k] !== void 0
-            ),
-            { message: "orderBy must specify at least one field" }
+          throw new ShapeError(
+            `Shape config "orderBy: true" is only supported for groupBy. Define an object of allowed fields.`
           );
-          schemaFields.orderBy = import_zod7.z.union([
-            singleSchema,
-            import_zod7.z.preprocess(coerceToArray, import_zod7.z.array(singleSchema).min(1))
-          ]).optional();
         }
-      } else {
         schemaFields.orderBy = argsBuilder.buildOrderBySchema(
           model,
           shape.orderBy
@@ -3175,19 +3320,16 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       }
     }
     if (shape.cursor) {
-      schemaFields.cursor = argsBuilder.buildCursorSchema(
-        model,
-        shape.cursor
-      );
+      schemaFields.cursor = argsBuilder.buildCursorSchema(model, shape.cursor);
     }
-    if (shape.take) {
+    if (shape.take !== void 0) {
       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 = import_zod7.z.number().int().min(0).optional();
+      schemaFields.skip = import_zod8.z.number().int().min(0).optional();
     }
     if (shape.distinct) {
       schemaFields.distinct = argsBuilder.buildDistinctSchema(
@@ -3234,13 +3376,10 @@ function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
       schemaFields.by = argsBuilder.buildBySchema(model, shape.by);
     }
     if (shape.having) {
-      schemaFields.having = argsBuilder.buildHavingSchema(
-        model,
-        shape.having
-      );
+      schemaFields.having = argsBuilder.buildHavingSchema(model, shape.having);
     }
     return {
-      zodSchema: import_zod7.z.object(schemaFields).strict(),
+      zodSchema: import_zod8.z.object(schemaFields).strict(),
       forcedWhere,
       forcedOnlyWhereKeys,
       forcedIncludeTree,
@@ -3433,22 +3572,18 @@ function buildScopedUniqueWhere(existingWhere, conditions, scopeFks, log, model)
   allConditions.push(...conditions);
   return { ...topLevel, AND: allConditions };
 }
-function isComparableScopeValue(v) {
-  const t = typeof v;
-  return t === "string" || t === "number" || t === "bigint";
-}
-function looseEqual(a, b, log, fk) {
+function scopeValuesEqual(a, b) {
   if (a === b)
     return true;
-  if (!isComparableScopeValue(a) || !isComparableScopeValue(b))
-    return false;
-  const eq = String(a) === String(b);
-  if (eq && log && fk) {
-    log.warn(
-      `prisma-guard: Scope value for "${fk}" matched via type coercion (${typeof a} ${String(a)} vs ${typeof b} ${String(b)}). Consider normalizing types in the context function.`
-    );
+  const aIsBig = typeof a === "bigint";
+  const bIsBig = typeof b === "bigint";
+  if (aIsBig && typeof b === "number") {
+    return Number.isInteger(b) && a === BigInt(b);
+  }
+  if (bIsBig && typeof a === "number") {
+    return Number.isInteger(a) && b === BigInt(a);
   }
-  return eq;
+  return false;
 }
 function buildFkSelect(fks) {
   const select = {};
@@ -3738,7 +3873,7 @@ 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) {
+  if (typeof result !== "object") {
     throw new ShapeError(
       `${operation} on model "${model}" returned a non-object, non-null result`
     );
@@ -3769,7 +3904,7 @@ async function handleFindUnique(args, query, conditions, scopes, operation, log,
         `prisma-guard: Scope verification re-query on model "${model}" returned null for an existing ${operation} result. The record may have been deleted between the original query and verification.`
       );
     }
-    if (typeof verifyResult !== "object" || verifyResult === null) {
+    if (typeof verifyResult !== "object") {
       throw new PolicyError(
         `prisma-guard: Scope verification re-query on model "${model}" returned a non-object result.`
       );
@@ -3783,7 +3918,7 @@ async function handleFindUnique(args, query, conditions, scopes, operation, log,
         `prisma-guard: Cannot verify scope on model "${model}" \u2014 FK field "${fk}" not present in verification result. Ensure "${fk}" is selectable on model "${model}" (not excluded by select or field-level access).`
       );
     }
-    if (!looseEqual(verifyObj[fk], value, log, fk)) {
+    if (!scopeValuesEqual(verifyObj[fk], value)) {
       if (operation === "findUniqueOrThrow") {
         throw new PolicyError(
           `prisma-guard: Record on model "${model}" not accessible in current scope`
@@ -3803,97 +3938,158 @@ async function handleFindUnique(args, query, conditions, scopes, operation, log,
 }
 
 // src/runtime/model-guard.ts
+var import_zod11 = require("zod");
+
+// src/runtime/model-guard-data.ts
+var import_zod10 = require("zod");
+
+// src/runtime/unique-selector-schema.ts
 var import_zod9 = require("zod");
+function buildUniqueSelectorSchema(parentModel, parentField, relatedModel, config, typeMap, uniqueMap, enumMap, scalarBase, context) {
+  const modelFields = typeMap[relatedModel];
+  if (!modelFields) {
+    throw new ShapeError(
+      `Unknown related model "${relatedModel}" for ${context} on "${parentModel}.${parentField}"`
+    );
+  }
+  const constraints = uniqueMap[relatedModel] ?? [];
+  if (constraints.length === 0) {
+    throw new ShapeError(
+      `${context} on "${parentModel}.${parentField}" requires related model "${relatedModel}" to have at least one unique constraint`
+    );
+  }
+  const configKeys = Object.keys(config);
+  if (configKeys.length === 0) {
+    throw new ShapeError(
+      `${context} on "${parentModel}.${parentField}" must define at least one unique selector. Available: ${formatUniqueConstraints(constraints)}`
+    );
+  }
+  const fieldSchemas = {};
+  const fieldKeys = [];
+  for (const [key, value] of Object.entries(config)) {
+    const compoundConstraint = constraints.find(
+      (c) => c.selector === key && c.fields.length > 1
+    );
+    if (compoundConstraint) {
+      if (!isPlainObject(value)) {
+        throw new ShapeError(
+          `Compound unique selector "${key}" in ${context} on "${parentModel}.${parentField}" must be an object with fields: ${compoundConstraint.fields.join(", ")}`
+        );
+      }
+      const allowed = new Set(compoundConstraint.fields);
+      const nestedKeys = Object.keys(value);
+      for (const nestedKey of nestedKeys) {
+        if (!allowed.has(nestedKey)) {
+          throw new ShapeError(
+            `Unknown field "${nestedKey}" in compound unique selector "${key}" on "${parentModel}.${parentField}". Allowed: ${compoundConstraint.fields.join(", ")}`
+          );
+        }
+      }
+      for (const field of compoundConstraint.fields) {
+        if (!(field in value)) {
+          throw new ShapeError(
+            `Missing field "${field}" in compound unique selector "${key}" on "${parentModel}.${parentField}"`
+          );
+        }
+        const fieldValue = value[field];
+        if (fieldValue !== true) {
+          throw new ShapeError(
+            `Field "${field}" in compound unique selector "${key}" on "${parentModel}.${parentField}" must be true`
+          );
+        }
+      }
+      const nestedSchemas = {};
+      for (const field of compoundConstraint.fields) {
+        const fieldMeta2 = modelFields[field];
+        if (!fieldMeta2) {
+          throw new ShapeError(
+            `Unknown field "${field}" on related model "${relatedModel}"`
+          );
+        }
+        if (fieldMeta2.isRelation) {
+          throw new ShapeError(
+            `Relation field "${field}" cannot be used in compound unique selector`
+          );
+        }
+        nestedSchemas[field] = buildDirectScalarSchema(
+          fieldMeta2,
+          enumMap,
+          scalarBase
+        );
+      }
+      fieldSchemas[key] = import_zod9.z.object(nestedSchemas).strict().optional();
+      fieldKeys.push(key);
+      continue;
+    }
+    const singleConstraint = constraints.find(
+      (c) => c.fields.length === 1 && c.fields[0] === key && c.selector === key
+    );
+    if (!singleConstraint) {
+      const available = formatUniqueConstraints(constraints);
+      throw new ShapeError(
+        `Field "${key}" in ${context} on "${parentModel}.${parentField}" is not a unique selector on model "${relatedModel}". Available: ${available}`
+      );
+    }
+    if (value !== true) {
+      throw new ShapeError(
+        `Field "${key}" in ${context} on "${parentModel}.${parentField}" must be true`
+      );
+    }
+    const fieldMeta = modelFields[key];
+    if (!fieldMeta) {
+      throw new ShapeError(
+        `Unknown field "${key}" on related model "${relatedModel}"`
+      );
+    }
+    if (fieldMeta.isRelation) {
+      throw new ShapeError(
+        `Relation field "${key}" cannot be used in unique selector`
+      );
+    }
+    fieldSchemas[key] = buildDirectScalarSchema(
+      fieldMeta,
+      enumMap,
+      scalarBase
+    ).optional();
+    fieldKeys.push(key);
+  }
+  return import_zod9.z.object(fieldSchemas).strict().refine(
+    (v) => fieldKeys.some((k) => v[k] !== void 0),
+    {
+      message: `${context} on "${parentModel}.${parentField}" requires at least one unique selector value`
+    }
+  );
+}
 
 // src/runtime/model-guard-data.ts
-var import_zod8 = require("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"
-]);
-var KNOWN_RELATION_WRITE_OPS = /* @__PURE__ */ new Set([
-  "connect",
-  "connectOrCreate",
-  "create",
-  "createMany",
-  "disconnect",
-  "delete",
-  "set",
-  "update",
-  "updateMany",
-  "upsert",
-  "deleteMany"
-]);
-function validateMutationBodyKeys(body, allowed, method) {
-  for (const key of Object.keys(body)) {
+var RELATION_OP_ALLOWED_KEYS = {
+  connectOrCreate: /* @__PURE__ */ new Set(["where", "create"]),
+  createMany: /* @__PURE__ */ new Set(["data", "skipDuplicates"]),
+  "update.toMany": /* @__PURE__ */ new Set(["where", "data"]),
+  updateMany: /* @__PURE__ */ new Set(["where", "data"]),
+  "upsert.toOne": /* @__PURE__ */ new Set(["where", "create", "update"]),
+  "upsert.toMany": /* @__PURE__ */ new Set(["where", "create", "update"])
+};
+function validateRelationOpKeys(actual, opKey, model, field, opLabel) {
+  const allowed = RELATION_OP_ALLOWED_KEYS[opKey];
+  if (!allowed)
+    return;
+  for (const key of Object.keys(actual)) {
     if (!allowed.has(key)) {
       throw new ShapeError(
-        `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
+        `Unknown key "${key}" in ${opLabel} config on "${model}.${field}". Allowed: ${[...allowed].join(", ")}`
       );
     }
   }
 }
-function validateMutationShapeKeys(shape, allowed, method) {
-  for (const key of Object.keys(shape)) {
+function validateAllowedKeys(value, allowed, method, kind) {
+  for (const key of Object.keys(value)) {
     if (!allowed.has(key)) {
+      if (kind === "body") {
+        throw new ShapeError(
+          `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
+        );
+      }
       throw new ShapeError(
         `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`
       );
@@ -3935,24 +4131,24 @@ function buildWhereFieldsSchema(model, config, typeMap, schemaBuilder) {
   for (const [fieldName, value] of Object.entries(config)) {
     if (value !== true)
       throw new ShapeError(
-        `Field "${fieldName}" in connect/where config must be true`
+        `Field "${fieldName}" in filter config must be true`
       );
     const meta = modelFields[fieldName];
     if (!meta)
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     if (meta.isRelation)
       throw new ShapeError(
-        `Relation field "${fieldName}" cannot be used in connect/where`
+        `Relation field "${fieldName}" cannot be used in filter`
       );
     fieldSchemas[fieldName] = schemaBuilder.buildFieldSchema(model, fieldName).optional();
     fieldKeys.push(fieldName);
   }
-  return import_zod8.z.object(fieldSchemas).strict().refine(
+  return import_zod10.z.object(fieldSchemas).strict().refine(
     (v) => fieldKeys.some((k) => v[k] !== void 0),
-    { message: `At least one field required in connect/where` }
+    { message: `At least one field required in filter` }
   );
 }
-function buildNestedDataSchema(model, config, typeMap, schemaBuilder) {
+function buildNestedDataSchema(model, config, mode, typeMap, schemaBuilder) {
   const modelFields = typeMap[model];
   if (!modelFields)
     throw new ShapeError(`Unknown model: ${model}`);
@@ -3973,382 +4169,349 @@ function buildNestedDataSchema(model, config, typeMap, schemaBuilder) {
       throw new ShapeError(
         `updatedAt field "${fieldName}" cannot be used in nested data`
       );
-    let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
-    if (!meta.isRequired) {
-      fieldSchema = fieldSchema.nullable().optional();
-    } else if (meta.hasDefault) {
-      fieldSchema = fieldSchema.optional();
-    }
-    fieldSchemas[fieldName] = fieldSchema;
+    if (meta.isUnsupported)
+      throw new ShapeError(
+        `Field "${fieldName}" on model "${model}" has an Unsupported type and cannot be used in nested data`
+      );
+    const baseSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+    fieldSchemas[fieldName] = applyCreateUpdateNullability(meta, baseSchema, {
+      mode,
+      handlesUndefined: false
+    });
   }
-  return import_zod8.z.object(fieldSchemas).strict();
+  return import_zod10.z.object(fieldSchemas).strict();
 }
-function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, config, typeMap, schemaBuilder) {
-  const relatedFields = typeMap[relatedModelName];
-  if (!relatedFields)
+function requirePlainObjectConfig(value, message) {
+  if (!isPlainObject(value))
+    throw new ShapeError(message);
+  return value;
+}
+function requireNestedObject(cfg, key, message) {
+  const v = cfg[key];
+  if (!v || !isPlainObject(v))
+    throw new ShapeError(message);
+  return v;
+}
+function buildUniqueSelector(ctx, cfg, context) {
+  return buildUniqueSelectorSchema(
+    ctx.model,
+    ctx.fieldName,
+    ctx.relatedModelName,
+    cfg,
+    ctx.typeMap,
+    ctx.uniqueMap,
+    ctx.enumMap,
+    ctx.scalarBase,
+    context
+  );
+}
+function buildNestedData(ctx, cfg, mode) {
+  return buildNestedDataSchema(
+    ctx.relatedModelName,
+    cfg,
+    mode,
+    ctx.typeMap,
+    ctx.schemaBuilder
+  );
+}
+var handleConnect = (ctx) => {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `connect config on "${ctx.model}.${ctx.fieldName}" must be an object of unique selectors`
+  );
+  const schema = buildUniqueSelector(ctx, cfg, "connect");
+  return wrapRelationOp(ctx.isList, schema);
+};
+var handleConnectOrCreate = (ctx) => {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `connectOrCreate config on "${ctx.model}.${ctx.fieldName}" must be an object with "where" and "create"`
+  );
+  validateRelationOpKeys(cfg, "connectOrCreate", ctx.model, ctx.fieldName, "connectOrCreate");
+  const where = requireNestedObject(
+    cfg,
+    "where",
+    `connectOrCreate on "${ctx.model}.${ctx.fieldName}" requires "where" object`
+  );
+  const create = requireNestedObject(
+    cfg,
+    "create",
+    `connectOrCreate on "${ctx.model}.${ctx.fieldName}" requires "create" object`
+  );
+  const whereSchema = buildUniqueSelector(ctx, where, "connectOrCreate.where");
+  const createSchema = buildNestedData(ctx, create, "create");
+  const cocSchema = import_zod10.z.object({ where: whereSchema, create: createSchema }).strict();
+  return wrapRelationOp(ctx.isList, cocSchema);
+};
+var handleCreate = (ctx) => {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `create config on "${ctx.model}.${ctx.fieldName}" must be an object of field names`
+  );
+  const createSchema = buildNestedData(ctx, cfg, "create");
+  return wrapRelationOp(ctx.isList, createSchema);
+};
+var handleCreateMany = (ctx) => {
+  if (!ctx.isList) {
     throw new ShapeError(
-      `Unknown related model "${relatedModelName}" for field "${model}.${fieldName}"`
+      `createMany is only valid on to-many relations ("${ctx.model}.${ctx.fieldName}")`
     );
-  for (const key of Object.keys(config)) {
-    if (!KNOWN_RELATION_WRITE_OPS.has(key)) {
-      throw new ShapeError(
-        `Unknown relation write operation "${key}" on "${model}.${fieldName}". Allowed: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
-      );
-    }
   }
-  const opSchemas = {};
-  if (config.connect !== void 0) {
-    if (!isPlainObject(config.connect)) {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `createMany config on "${ctx.model}.${ctx.fieldName}" must be an object`
+  );
+  validateRelationOpKeys(cfg, "createMany", ctx.model, ctx.fieldName, "createMany");
+  const data = requireNestedObject(
+    cfg,
+    "data",
+    `createMany on "${ctx.model}.${ctx.fieldName}" requires "data" object`
+  );
+  const dataSchema = buildNestedData(ctx, data, "create");
+  const cmSchemaFields = {
+    data: import_zod10.z.preprocess(coerceToArray, import_zod10.z.array(dataSchema))
+  };
+  if ("skipDuplicates" in cfg) {
+    cmSchemaFields["skipDuplicates"] = import_zod10.z.boolean().optional();
+  }
+  return import_zod10.z.object(cmSchemaFields).strict().optional();
+};
+var handleDisconnect = (ctx) => {
+  if (ctx.config === true) {
+    if (ctx.isList) {
       throw new ShapeError(
-        `connect config on "${model}.${fieldName}" must be an object of field names`
+        `disconnect on to-many relation "${ctx.model}.${ctx.fieldName}" requires unique selector config, not true`
       );
     }
-    const connectSchema = buildWhereFieldsSchema(
-      relatedModelName,
-      config.connect,
-      typeMap,
-      schemaBuilder
+    return import_zod10.z.literal(true).optional();
+  }
+  if (!isPlainObject(ctx.config)) {
+    throw new ShapeError(
+      `disconnect config on "${ctx.model}.${ctx.fieldName}" must be true (to-one) or an object of unique selectors`
     );
-    opSchemas["connect"] = isList ? import_zod8.z.union([
-      connectSchema,
-      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(connectSchema))
-    ]).optional() : connectSchema.optional();
   }
-  if (config.connectOrCreate !== void 0) {
-    if (!isPlainObject(config.connectOrCreate)) {
-      throw new ShapeError(
-        `connectOrCreate config on "${model}.${fieldName}" must be an object with "where" and "create"`
-      );
-    }
-    const coc = config.connectOrCreate;
-    if (!coc.where || !isPlainObject(coc.where)) {
-      throw new ShapeError(
-        `connectOrCreate on "${model}.${fieldName}" requires "where" object`
-      );
-    }
-    if (!coc.create || !isPlainObject(coc.create)) {
+  const schema = buildUniqueSelector(ctx, ctx.config, "disconnect");
+  if (ctx.isList)
+    return wrapRelationOp(true, schema);
+  return import_zod10.z.union([import_zod10.z.literal(true), schema]).optional();
+};
+var handleDelete = (ctx) => {
+  if (ctx.config === true) {
+    if (ctx.isList) {
       throw new ShapeError(
-        `connectOrCreate on "${model}.${fieldName}" requires "create" object`
+        `delete on to-many relation "${ctx.model}.${ctx.fieldName}" requires unique selector config, not true`
       );
     }
-    const whereSchema = buildWhereFieldsSchema(
-      relatedModelName,
-      coc.where,
-      typeMap,
-      schemaBuilder
-    );
-    const createSchema = buildNestedDataSchema(
-      relatedModelName,
-      coc.create,
-      typeMap,
-      schemaBuilder
+    return import_zod10.z.literal(true).optional();
+  }
+  if (!isPlainObject(ctx.config)) {
+    throw new ShapeError(
+      `delete config on "${ctx.model}.${ctx.fieldName}" must be true (to-one) or an object of unique selectors`
     );
-    const cocSchema = import_zod8.z.object({ where: whereSchema, create: createSchema }).strict();
-    opSchemas["connectOrCreate"] = isList ? import_zod8.z.union([cocSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(cocSchema))]).optional() : cocSchema.optional();
   }
-  if (config.create !== void 0) {
-    if (!isPlainObject(config.create)) {
-      throw new ShapeError(
-        `create config on "${model}.${fieldName}" must be an object of field names`
-      );
-    }
-    const createSchema = buildNestedDataSchema(
-      relatedModelName,
-      config.create,
-      typeMap,
-      schemaBuilder
+  const schema = buildUniqueSelector(ctx, ctx.config, "delete");
+  if (ctx.isList)
+    return wrapRelationOp(true, schema);
+  return import_zod10.z.union([import_zod10.z.literal(true), schema]).optional();
+};
+var handleSet = (ctx) => {
+  if (!ctx.isList) {
+    throw new ShapeError(
+      `set is only valid on to-many relations ("${ctx.model}.${ctx.fieldName}")`
     );
-    opSchemas["create"] = isList ? import_zod8.z.union([
-      createSchema,
-      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(createSchema))
-    ]).optional() : createSchema.optional();
   }
-  if (config.createMany !== void 0) {
-    if (!isList) {
-      throw new ShapeError(
-        `createMany is only valid on to-many relations ("${model}.${fieldName}")`
-      );
-    }
-    if (!isPlainObject(config.createMany)) {
-      throw new ShapeError(
-        `createMany config on "${model}.${fieldName}" must be an object`
-      );
-    }
-    const cmConfig = config.createMany;
-    if (!cmConfig.data || !isPlainObject(cmConfig.data)) {
-      throw new ShapeError(
-        `createMany on "${model}.${fieldName}" requires "data" object`
-      );
-    }
-    const dataSchema = buildNestedDataSchema(
-      relatedModelName,
-      cmConfig.data,
-      typeMap,
-      schemaBuilder
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `set config on "${ctx.model}.${ctx.fieldName}" must be an object of unique selectors`
+  );
+  const schema = buildUniqueSelector(ctx, cfg, "set");
+  return wrapRelationOp(true, schema);
+};
+var handleUpdate = (ctx) => {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `update config on "${ctx.model}.${ctx.fieldName}" must be an object`
+  );
+  if (ctx.isList) {
+    validateRelationOpKeys(cfg, "update.toMany", ctx.model, ctx.fieldName, "update");
+    const where = requireNestedObject(
+      cfg,
+      "where",
+      `update on to-many "${ctx.model}.${ctx.fieldName}" requires "where" object`
     );
-    const cmSchemaFields = {
-      data: import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(dataSchema))
-    };
-    if ("skipDuplicates" in cmConfig) {
-      cmSchemaFields["skipDuplicates"] = import_zod8.z.boolean().optional();
-    }
-    opSchemas["createMany"] = import_zod8.z.object(cmSchemaFields).strict().optional();
+    const data = requireNestedObject(
+      cfg,
+      "data",
+      `update on to-many "${ctx.model}.${ctx.fieldName}" requires "data" object`
+    );
+    const whereSchema = buildUniqueSelector(ctx, where, "update.where");
+    const dataSchema2 = buildNestedData(ctx, data, "update");
+    const updateSchema = import_zod10.z.object({ where: whereSchema, data: dataSchema2 }).strict();
+    return wrapRelationOp(true, updateSchema);
   }
-  if (config.disconnect !== void 0) {
-    if (config.disconnect === true) {
-      if (isList) {
-        throw new ShapeError(
-          `disconnect on to-many relation "${model}.${fieldName}" requires field config, not true`
-        );
-      }
-      opSchemas["disconnect"] = import_zod8.z.literal(true).optional();
-    } else if (isPlainObject(config.disconnect)) {
-      const disconnectSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        config.disconnect,
-        typeMap,
-        schemaBuilder
-      );
-      if (isList) {
-        opSchemas["disconnect"] = import_zod8.z.union([
-          disconnectSchema,
-          import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(disconnectSchema))
-        ]).optional();
-      } else {
-        opSchemas["disconnect"] = import_zod8.z.union([import_zod8.z.literal(true), disconnectSchema]).optional();
-      }
-    } else {
-      throw new ShapeError(
-        `disconnect config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
-      );
-    }
+  const dataSchema = buildNestedData(ctx, cfg, "update");
+  return dataSchema.optional();
+};
+var handleUpsert = (ctx) => {
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `upsert config on "${ctx.model}.${ctx.fieldName}" must be an object`
+  );
+  validateRelationOpKeys(
+    cfg,
+    ctx.isList ? "upsert.toMany" : "upsert.toOne",
+    ctx.model,
+    ctx.fieldName,
+    "upsert"
+  );
+  const create = requireNestedObject(
+    cfg,
+    "create",
+    `upsert on "${ctx.model}.${ctx.fieldName}" requires "create" object`
+  );
+  const update = requireNestedObject(
+    cfg,
+    "update",
+    `upsert on "${ctx.model}.${ctx.fieldName}" requires "update" object`
+  );
+  const createSchema = buildNestedData(ctx, create, "create");
+  const updateSchema = buildNestedData(ctx, update, "update");
+  if (ctx.isList) {
+    const where = requireNestedObject(
+      cfg,
+      "where",
+      `upsert on to-many "${ctx.model}.${ctx.fieldName}" requires "where" object`
+    );
+    const whereSchema = buildUniqueSelector(ctx, where, "upsert.where");
+    const upsertSchema2 = import_zod10.z.object({ where: whereSchema, create: createSchema, update: updateSchema }).strict();
+    return wrapRelationOp(true, upsertSchema2);
   }
-  if (config.delete !== void 0) {
-    if (config.delete === true) {
-      if (isList) {
-        throw new ShapeError(
-          `delete on to-many relation "${model}.${fieldName}" requires field config, not true`
-        );
-      }
-      opSchemas["delete"] = import_zod8.z.literal(true).optional();
-    } else if (isPlainObject(config.delete)) {
-      const deleteSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        config.delete,
-        typeMap,
-        schemaBuilder
-      );
-      if (isList) {
-        opSchemas["delete"] = import_zod8.z.union([
-          deleteSchema,
-          import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(deleteSchema))
-        ]).optional();
-      } else {
-        opSchemas["delete"] = import_zod8.z.union([import_zod8.z.literal(true), deleteSchema]).optional();
-      }
-    } else {
+  const hasWhereKey = "where" in cfg;
+  if (hasWhereKey) {
+    if (!isPlainObject(cfg.where)) {
       throw new ShapeError(
-        `delete config on "${model}.${fieldName}" must be true (to-one) or an object of field names`
+        `upsert on to-one "${ctx.model}.${ctx.fieldName}" has invalid "where": must be a plain object of unique selectors`
       );
     }
+    const whereSchema = buildUniqueSelector(ctx, cfg.where, "upsert.where");
+    const upsertSchema2 = import_zod10.z.object({ where: whereSchema, create: createSchema, update: updateSchema }).strict();
+    return upsertSchema2.optional();
   }
-  if (config.set !== void 0) {
-    if (!isList) {
-      throw new ShapeError(
-        `set is only valid on to-many relations ("${model}.${fieldName}")`
-      );
-    }
-    if (!isPlainObject(config.set)) {
-      throw new ShapeError(
-        `set config on "${model}.${fieldName}" must be an object of field names`
-      );
-    }
-    const setSchema = buildWhereFieldsSchema(
-      relatedModelName,
-      config.set,
-      typeMap,
-      schemaBuilder
+  const upsertSchema = import_zod10.z.object({ create: createSchema, update: updateSchema }).strict();
+  return upsertSchema.optional();
+};
+var handleUpdateMany = (ctx) => {
+  if (!ctx.isList) {
+    throw new ShapeError(
+      `updateMany is only valid on to-many relations ("${ctx.model}.${ctx.fieldName}")`
     );
-    opSchemas["set"] = import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(setSchema)).optional();
-  }
-  if (config.update !== void 0) {
-    if (!isPlainObject(config.update)) {
-      throw new ShapeError(
-        `update config on "${model}.${fieldName}" must be an object`
-      );
-    }
-    const updateConfig = config.update;
-    if (isList) {
-      if (!updateConfig.where || !isPlainObject(updateConfig.where)) {
-        throw new ShapeError(
-          `update on to-many "${model}.${fieldName}" requires "where" object`
-        );
-      }
-      if (!updateConfig.data || !isPlainObject(updateConfig.data)) {
-        throw new ShapeError(
-          `update on to-many "${model}.${fieldName}" requires "data" object`
-        );
-      }
-      const whereSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        updateConfig.where,
-        typeMap,
-        schemaBuilder
-      );
-      const dataSchema = buildNestedDataSchema(
-        relatedModelName,
-        updateConfig.data,
-        typeMap,
-        schemaBuilder
-      );
-      const updateSchema = import_zod8.z.object({ where: whereSchema, data: dataSchema }).strict();
-      opSchemas["update"] = import_zod8.z.union([
-        updateSchema,
-        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(updateSchema))
-      ]).optional();
-    } else {
-      const dataSchema = buildNestedDataSchema(
-        relatedModelName,
-        updateConfig,
-        typeMap,
-        schemaBuilder
-      );
-      opSchemas["update"] = dataSchema.optional();
-    }
   }
-  if (config.upsert !== void 0) {
-    if (!isPlainObject(config.upsert)) {
-      throw new ShapeError(
-        `upsert config on "${model}.${fieldName}" must be an object`
-      );
-    }
-    const upsertConfig = config.upsert;
-    if (!upsertConfig.create || !isPlainObject(upsertConfig.create)) {
-      throw new ShapeError(
-        `upsert on "${model}.${fieldName}" requires "create" object`
-      );
-    }
-    if (!upsertConfig.update || !isPlainObject(upsertConfig.update)) {
-      throw new ShapeError(
-        `upsert on "${model}.${fieldName}" requires "update" object`
-      );
-    }
-    const createSchema = buildNestedDataSchema(
-      relatedModelName,
-      upsertConfig.create,
-      typeMap,
-      schemaBuilder
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `updateMany config on "${ctx.model}.${ctx.fieldName}" must be an object`
+  );
+  validateRelationOpKeys(cfg, "updateMany", ctx.model, ctx.fieldName, "updateMany");
+  const where = requireNestedObject(
+    cfg,
+    "where",
+    `updateMany on "${ctx.model}.${ctx.fieldName}" requires "where" object`
+  );
+  if (Object.keys(where).length === 0) {
+    throw new ShapeError(
+      `updateMany "where" on "${ctx.model}.${ctx.fieldName}" must define at least one filter field`
     );
-    const updateSchema = buildNestedDataSchema(
-      relatedModelName,
-      upsertConfig.update,
-      typeMap,
-      schemaBuilder
+  }
+  const data = requireNestedObject(
+    cfg,
+    "data",
+    `updateMany on "${ctx.model}.${ctx.fieldName}" requires "data" object`
+  );
+  if (Object.keys(data).length === 0) {
+    throw new ShapeError(
+      `updateMany "data" on "${ctx.model}.${ctx.fieldName}" must define at least one field`
     );
-    if (isList) {
-      if (!upsertConfig.where || !isPlainObject(upsertConfig.where)) {
-        throw new ShapeError(
-          `upsert on to-many "${model}.${fieldName}" requires "where" object`
-        );
-      }
-      const whereSchema = buildWhereFieldsSchema(
-        relatedModelName,
-        upsertConfig.where,
-        typeMap,
-        schemaBuilder
-      );
-      const upsertSchema = import_zod8.z.object({
-        where: whereSchema,
-        create: createSchema,
-        update: updateSchema
-      }).strict();
-      opSchemas["upsert"] = import_zod8.z.union([
-        upsertSchema,
-        import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(upsertSchema))
-      ]).optional();
-    } else {
-      if (upsertConfig.where) {
-        const whereSchema = buildWhereFieldsSchema(
-          relatedModelName,
-          upsertConfig.where,
-          typeMap,
-          schemaBuilder
-        );
-        const upsertSchema = import_zod8.z.object({
-          where: whereSchema,
-          create: createSchema,
-          update: updateSchema
-        }).strict();
-        opSchemas["upsert"] = upsertSchema.optional();
-      } else {
-        const upsertSchema = import_zod8.z.object({ create: createSchema, update: updateSchema }).strict();
-        opSchemas["upsert"] = upsertSchema.optional();
-      }
-    }
   }
-  if (config.updateMany !== void 0) {
-    if (!isList) {
-      throw new ShapeError(
-        `updateMany is only valid on to-many relations ("${model}.${fieldName}")`
-      );
-    }
-    if (!isPlainObject(config.updateMany)) {
-      throw new ShapeError(
-        `updateMany config on "${model}.${fieldName}" must be an object`
-      );
-    }
-    const umConfig = config.updateMany;
-    if (!umConfig.where || !isPlainObject(umConfig.where)) {
-      throw new ShapeError(
-        `updateMany on "${model}.${fieldName}" requires "where" object`
-      );
-    }
-    if (!umConfig.data || !isPlainObject(umConfig.data)) {
-      throw new ShapeError(
-        `updateMany on "${model}.${fieldName}" requires "data" object`
-      );
-    }
-    const whereSchema = buildWhereFieldsSchema(
-      relatedModelName,
-      umConfig.where,
-      typeMap,
-      schemaBuilder
+  const whereSchema = buildWhereFieldsSchema(
+    ctx.relatedModelName,
+    where,
+    ctx.typeMap,
+    ctx.schemaBuilder
+  );
+  const dataSchema = buildNestedData(ctx, data, "update");
+  const umSchema = import_zod10.z.object({ where: whereSchema, data: dataSchema }).strict();
+  return wrapRelationOp(true, umSchema);
+};
+var handleDeleteMany = (ctx) => {
+  if (!ctx.isList) {
+    throw new ShapeError(
+      `deleteMany is only valid on to-many relations ("${ctx.model}.${ctx.fieldName}")`
     );
-    const dataSchema = buildNestedDataSchema(
-      relatedModelName,
-      umConfig.data,
-      typeMap,
-      schemaBuilder
+  }
+  const cfg = requirePlainObjectConfig(
+    ctx.config,
+    `deleteMany config on "${ctx.model}.${ctx.fieldName}" must be an object of allowed filter fields`
+  );
+  if (Object.keys(cfg).length === 0) {
+    throw new ShapeError(
+      `deleteMany config on "${ctx.model}.${ctx.fieldName}" is empty. Unconstrained nested deletes are not allowed. Define at least one allowed filter field.`
     );
-    const umSchema = import_zod8.z.object({ where: whereSchema, data: dataSchema }).strict();
-    opSchemas["updateMany"] = import_zod8.z.union([umSchema, import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(umSchema))]).optional();
   }
-  if (config.deleteMany !== void 0) {
-    if (!isList) {
-      throw new ShapeError(
-        `deleteMany is only valid on to-many relations ("${model}.${fieldName}")`
-      );
-    }
-    if (!isPlainObject(config.deleteMany)) {
+  const filterSchema = buildWhereFieldsSchema(
+    ctx.relatedModelName,
+    cfg,
+    ctx.typeMap,
+    ctx.schemaBuilder
+  );
+  return wrapRelationOp(true, filterSchema);
+};
+var RELATION_OP_HANDLERS = {
+  connect: handleConnect,
+  connectOrCreate: handleConnectOrCreate,
+  create: handleCreate,
+  createMany: handleCreateMany,
+  disconnect: handleDisconnect,
+  delete: handleDelete,
+  set: handleSet,
+  update: handleUpdate,
+  upsert: handleUpsert,
+  updateMany: handleUpdateMany,
+  deleteMany: handleDeleteMany
+};
+var KNOWN_RELATION_WRITE_OPS = new Set(Object.keys(RELATION_OP_HANDLERS));
+function buildRelationWriteSchema(model, fieldName, relatedModelName, isList, config, typeMap, uniqueMap, enumMap, scalarBase, schemaBuilder) {
+  const relatedFields = typeMap[relatedModelName];
+  if (!relatedFields)
+    throw new ShapeError(
+      `Unknown related model "${relatedModelName}" for field "${model}.${fieldName}"`
+    );
+  for (const key of Object.keys(config)) {
+    if (!KNOWN_RELATION_WRITE_OPS.has(key)) {
       throw new ShapeError(
-        `deleteMany config on "${model}.${fieldName}" must be an object of allowed filter fields`
+        `Unknown relation write operation "${key}" on "${model}.${fieldName}". Allowed: ${[...KNOWN_RELATION_WRITE_OPS].join(", ")}`
       );
     }
-    const filterSchema = buildWhereFieldsSchema(
+  }
+  const opSchemas = {};
+  for (const [op, opConfig] of Object.entries(config)) {
+    if (opConfig === void 0)
+      continue;
+    const handler = RELATION_OP_HANDLERS[op];
+    opSchemas[op] = handler({
+      model,
+      fieldName,
       relatedModelName,
-      config.deleteMany,
+      isList,
+      config: opConfig,
       typeMap,
+      uniqueMap,
+      enumMap,
+      scalarBase,
       schemaBuilder
-    );
-    opSchemas["deleteMany"] = import_zod8.z.union([
-      filterSchema,
-      import_zod8.z.preprocess(coerceToArray, import_zod8.z.array(filterSchema)),
-      import_zod8.z.object({}).strict()
-    ]).optional();
+    });
   }
-  return import_zod8.z.object(opSchemas).strict();
+  return import_zod10.z.object(opSchemas).strict();
 }
-function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDefaults) {
+function buildDataSchema(model, dataConfig, mode, typeMap, uniqueMap, enumMap, scalarBase, schemaBuilder, zodDefaults) {
   const modelFields = typeMap[model];
   if (!modelFields)
     throw new ShapeError(`Unknown model: ${model}`);
@@ -4360,11 +4523,23 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
     const fieldMeta = modelFields[fieldName];
     if (!fieldMeta) {
       if (isUnsupportedMarker(value)) {
-        schemaMap[fieldName] = import_zod8.z.unknown().optional();
         continue;
       }
       throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
     }
+    if (fieldMeta.isUnsupported) {
+      if (isUnsupportedMarker(value)) {
+        continue;
+      }
+      if (value === true || typeof value === "function") {
+        throw new ShapeError(
+          `Field "${fieldName}" on model "${model}" has an Unsupported type and cannot be client-controlled. Use unsupported() to acknowledge it or a forced server value.`
+        );
+      }
+      const actualValue = isForcedValue(value) ? value.value : value;
+      forced[fieldName] = deepClone(actualValue);
+      continue;
+    }
     if (fieldMeta.isRelation) {
       if (!isPlainObject(value)) {
         throw new ShapeError(
@@ -4378,6 +4553,9 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
         fieldMeta.isList,
         value,
         typeMap,
+        uniqueMap,
+        enumMap,
+        scalarBase,
         schemaBuilder
       ).optional();
       continue;
@@ -4387,7 +4565,7 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
         `updatedAt field "${fieldName}" cannot be used in data shape`
       );
     if (typeof value === "function") {
-      let baseSchema = schemaBuilder.buildBaseFieldSchema(
+      const baseSchema = schemaBuilder.buildBaseFieldSchema(
         model,
         fieldName
       );
@@ -4405,46 +4583,22 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
           `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 handlesUndefined = schemaProducesValueForUndefined(
+        refined
+      );
+      schemaMap[fieldName] = applyCreateUpdateNullability(
+        fieldMeta,
+        refined,
+        { mode, handlesUndefined }
       );
+    } else if (value === true) {
+      const 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;
+      schemaMap[fieldName] = applyCreateUpdateNullability(
+        fieldMeta,
+        fieldSchema,
+        { mode, handlesUndefined: isZodDefaultField }
+      );
     } else {
       const actualValue = isForcedValue(value) ? value.value : value;
       let fieldSchema = schemaBuilder.buildFieldSchema(
@@ -4488,7 +4642,7 @@ function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDef
     }
   }
   return {
-    schema: import_zod8.z.object(schemaMap).strict(),
+    schema: import_zod10.z.object(schemaMap).strict(),
     forced
   };
 }
@@ -4525,106 +4679,120 @@ function isGuardShape(obj) {
   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 toPlainObject(value) {
-  if (value === null || typeof value !== "object")
-    return value;
-  if (Array.isArray(value))
-    return value.map(toPlainObject);
-  if (value instanceof Date)
-    return value;
-  if (value instanceof Uint8Array)
-    return value;
-  if (value instanceof RegExp)
-    return value;
-  if (typeof value.toFixed === "function" && typeof value.toNumber === "function")
-    return value;
-  const result = {};
-  for (const [k, v] of Object.entries(value)) {
-    result[k] = toPlainObject(v);
+function requireBody(body) {
+  if (body === void 0 || body === null)
+    return {};
+  if (!isPlainObject(body)) {
+    throw new ShapeError("Request body must be a plain object");
   }
-  return result;
+  return body;
 }
-function requireBody(body) {
-  const normalized = toPlainObject(body);
-  if (!isPlainObject(normalized))
-    throw new ShapeError("Request body must be an object");
-  return normalized;
+function assertNoCallerInBody(body) {
+  if ("caller" in body) {
+    throw new CallerError(
+      "Pass caller via the guard(input, caller) argument, not in the request body."
+    );
+  }
 }
-function resolveDynamicShape(fn, contextFn) {
-  const ctx = validateContext(contextFn());
+function resolveDynamicShape(shapeFn, ctx, context) {
+  if (ctx === void 0) {
+    throw new ShapeError(
+      `Dynamic ${context} requires a context. Provide contextFn on the extension.`
+    );
+  }
   let result;
   try {
-    result = fn(ctx);
+    result = shapeFn(ctx);
   } catch (err) {
     throw new ShapeError(
-      `Dynamic shape function threw: ${err.message}`,
+      `Dynamic ${context} function threw: ${err.message}`,
       { cause: err }
     );
   }
-  if (!isPlainObject(result)) {
-    throw new ShapeError("Dynamic shape function must return a plain object");
+  if (!isGuardShape(result)) {
+    throw new ShapeError(
+      `Dynamic ${context} function must return a valid guard shape 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)) {
+function resolveNamedShape(input, body, contextFn, explicitCaller) {
+  assertNoCallerInBody(body);
+  const caller = explicitCaller;
+  const keys = Object.keys(input);
+  for (const key of keys) {
     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`
+        `Caller key "${key}" collides with reserved guard shape key. Rename the caller path.`
       );
     }
   }
-  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 (typeof caller !== "string") {
-    if ("default" in namedMap) {
-      const shapeOrFn2 = namedMap["default"];
-      const wasDynamic2 = typeof shapeOrFn2 === "function";
-      const shape2 = wasDynamic2 ? resolveDynamicShape(shapeOrFn2, contextFn) : shapeOrFn2;
-      return { shape: shape2, body: parsed, matchedKey: "default", wasDynamic: wasDynamic2 };
+    if ("default" in input) {
+      return resolveShapeEntry(input.default, body, contextFn, "default");
     }
-    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, or add a "default" variant.`
+      `Missing caller. This guard uses named shape routing with keys: ${keys.map((k) => `"${k}"`).join(", ")}. Provide caller via guard(input, caller).`
     );
   }
-  const patterns = Object.keys(namedMap);
-  const matched = matchCallerPattern(patterns, caller);
-  if (!matched) {
-    if ("default" in namedMap) {
-      const shapeOrFn2 = namedMap["default"];
-      const wasDynamic2 = typeof shapeOrFn2 === "function";
-      const shape2 = wasDynamic2 ? resolveDynamicShape(shapeOrFn2, contextFn) : shapeOrFn2;
-      return { shape: shape2, body: parsed, matchedKey: "default", wasDynamic: wasDynamic2 };
-    }
-    throw new CallerError(
-      `Unknown caller: "${caller}". Allowed: ${patterns.map((k) => `"${k}"`).join(", ")}`
-    );
+  const matched = matchCallerPattern(keys, caller);
+  if (matched) {
+    return resolveShapeEntry(input[matched], body, contextFn, matched);
+  }
+  if ("default" in input) {
+    return resolveShapeEntry(input.default, body, contextFn, "default");
+  }
+  throw new CallerError(
+    `Unknown caller: "${caller}". Allowed: ${keys.map((k) => `"${k}"`).join(", ")}`
+  );
+}
+function resolveShapeEntry(entry, body, contextFn, matchedKey) {
+  if (typeof entry === "function") {
+    const ctx = validateContext(contextFn());
+    const shape = resolveDynamicShape(entry, ctx, `shape "${matchedKey}"`);
+    return {
+      shape,
+      body,
+      matchedKey,
+      wasDynamic: true
+    };
+  }
+  return {
+    shape: entry,
+    body,
+    matchedKey,
+    wasDynamic: false
+  };
+}
+function resolveShape(input, rawBody, contextFn, explicitCaller) {
+  const body = requireBody(rawBody);
+  if (typeof input === "function") {
+    const ctx = validateContext(contextFn());
+    const shape = resolveDynamicShape(input, ctx, "shape");
+    return {
+      shape,
+      body,
+      matchedKey: "_default",
+      wasDynamic: true
+    };
+  }
+  if (isGuardShape(input)) {
+    return {
+      shape: input,
+      body,
+      matchedKey: "_default",
+      wasDynamic: false
+    };
   }
-  const shapeOrFn = namedMap[matched];
-  const wasDynamic = typeof shapeOrFn === "function";
-  const shape = wasDynamic ? resolveDynamicShape(shapeOrFn, contextFn) : shapeOrFn;
-  return { shape, body: parsed, matchedKey: matched, wasDynamic };
+  if (!isPlainObject(input)) {
+    throw new ShapeError("Guard input must be a shape object or a named map of shapes");
+  }
+  return resolveNamedShape(
+    input,
+    body,
+    contextFn,
+    explicitCaller
+  );
 }
 
 // src/runtime/model-guard.ts
@@ -4647,129 +4815,20 @@ var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
   "updateManyAndReturn"
 ]);
 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);
-      if (value.include) {
-        nested.include = buildDefaultIncludeInput(value.include);
-      }
-      result[key] = Object.keys(nested).length > 0 ? nested : true;
-    }
-  }
-  return result;
-}
-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 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 buildDefaultProjectionBody(shape) {
-  if (shape.select) {
-    return { select: buildDefaultSelectInput(shape.select) };
-  }
-  if (shape.include) {
-    return { include: buildDefaultIncludeInput(shape.include) };
-  }
-  return {};
-}
-function applyClientProjectionOverrides(shapeDefault, clientProjection) {
-  const result = { ...shapeDefault };
-  for (const [key, clientValue] of Object.entries(clientProjection)) {
-    const defaultValue = result[key];
-    if (defaultValue === void 0) {
-      result[key] = clientValue;
-      continue;
-    }
-    if (clientValue === true) {
-      result[key] = true;
-      continue;
-    }
-    if (isPlainObject(clientValue)) {
-      if (!isPlainObject(defaultValue)) {
-        result[key] = clientValue;
-        continue;
-      }
-      const merged = { ...defaultValue };
-      const clientObj = clientValue;
-      for (const [argKey, argValue] of Object.entries(clientObj)) {
-        const defaultArgValue = merged[argKey];
-        if ((argKey === "select" || argKey === "include") && isPlainObject(argValue) && isPlainObject(defaultArgValue)) {
-          merged[argKey] = applyClientProjectionOverrides(
-            defaultArgValue,
-            argValue
-          );
-        } else {
-          merged[argKey] = argValue;
-        }
-      }
-      result[key] = merged;
-    }
-  }
-  return result;
-}
-function hasClientControlledValues(obj) {
-  for (const value of Object.values(obj)) {
-    if (isForcedValue(value))
-      continue;
-    if (value === true)
-      return true;
-    if (isPlainObject(value) && hasClientControlledValues(value))
+var MAX_PROJECTION_WALK_DEPTH = 10;
+function walkForClientContent(obj, predicate, depth) {
+  if (depth > MAX_PROJECTION_WALK_DEPTH)
+    return false;
+  for (const [key, value] of Object.entries(obj)) {
+    if (predicate(value, depth))
       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))
+            if (isPlainObject(w) && hasClientControlledValues(w, depth + 1))
               return true;
           }
         }
@@ -4778,54 +4837,41 @@ function checkIncludeForClientArgs(config) {
     }
     if (value === true)
       continue;
-    if (value.orderBy || value.cursor || value.take || value.skip)
+    const nested = value;
+    if (nested.orderBy || nested.cursor || nested.take || nested.skip)
       return true;
-    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where)) {
+    if (nested.where && isPlainObject(nested.where) && hasClientControlledValues(nested.where, depth + 1)) {
       return true;
     }
-    if (value.include && checkIncludeForClientArgs(value.include))
+    if (nested.include && walkForClientContent(nested.include, predicate, depth + 1))
       return true;
-    if (value.select && checkSelectForClientArgs(value.select))
+    if (nested.select && walkForClientContent(nested.select, predicate, depth + 1))
       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;
-          }
-        }
-      }
+function hasClientControlledValues(obj, depth = 0) {
+  if (depth > MAX_PROJECTION_WALK_DEPTH)
+    return false;
+  for (const value of Object.values(obj)) {
+    if (isForcedValue(value))
       continue;
-    }
     if (value === true)
-      continue;
-    if (value.orderBy || value.cursor || value.take || value.skip)
       return true;
-    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where)) {
+    if (isPlainObject(value) && hasClientControlledValues(value, depth + 1)) {
       return true;
     }
-    if (value.select && checkSelectForClientArgs(value.select))
-      return true;
-    if (value.include && checkIncludeForClientArgs(value.include))
-      return true;
   }
   return false;
 }
 function hasNestedClientControlledArgs(shape) {
+  const predicate = () => false;
   if (shape.include) {
-    if (checkIncludeForClientArgs(shape.include))
+    if (walkForClientContent(shape.include, predicate, 0))
       return true;
   }
   if (shape.select) {
-    if (checkSelectForClientArgs(shape.select))
+    if (walkForClientContent(shape.select, predicate, 0))
       return true;
   }
   return false;
@@ -4897,77 +4943,62 @@ function createModelGuardExtension(config) {
     const whereBuiltCache = /* @__PURE__ */ new Map();
     const projectionCache = /* @__PURE__ */ new Map();
     const uniqueWhereCache = /* @__PURE__ */ new Map();
+    function memoize(cache, key, wasDynamic, build) {
+      if (wasDynamic)
+        return build();
+      const cached = cache.get(key);
+      if (cached)
+        return cached;
+      const built = build();
+      cache.set(key, built);
+      return built;
+    }
     function getReadShape(method, queryShape, matchedKey, wasDynamic) {
-      if (!wasDynamic) {
-        const cacheKey = `${method}\0${matchedKey}`;
-        const cached = readShapeCache.get(cacheKey);
-        if (cached)
-          return cached;
-        const built = queryBuilder.buildShapeZodSchema(
+      return memoize(
+        readShapeCache,
+        `${method}\0${matchedKey}`,
+        wasDynamic,
+        () => queryBuilder.buildShapeZodSchema(
           modelName,
           method,
           queryShape
-        );
-        readShapeCache.set(cacheKey, built);
-        return built;
-      }
-      return queryBuilder.buildShapeZodSchema(
-        modelName,
-        method,
-        queryShape
+        )
       );
     }
     function getDataSchema(mode, dataConfig, matchedKey, wasDynamic) {
-      if (!wasDynamic && !hasDataRefines(dataConfig)) {
-        const cacheKey = `${mode}\0${matchedKey}`;
-        const cached = dataSchemaCache.get(cacheKey);
-        if (cached)
-          return cached;
-        const built = buildDataSchema(
+      const skipCache = wasDynamic || hasDataRefines(dataConfig);
+      return memoize(
+        dataSchemaCache,
+        `${mode}\0${matchedKey}`,
+        skipCache,
+        () => buildDataSchema(
           modelName,
           dataConfig,
           mode,
           typeMap,
+          uniqueMap,
+          enumMap,
+          scalarBase,
           schemaBuilder,
           zodDefaults
-        );
-        dataSchemaCache.set(cacheKey, built);
-        return built;
-      }
-      return buildDataSchema(
-        modelName,
-        dataConfig,
-        mode,
-        typeMap,
-        schemaBuilder,
-        zodDefaults
+        )
       );
     }
     function getWhereBuilt(whereConfig, matchedKey, wasDynamic) {
-      if (!wasDynamic) {
-        const cached = whereBuiltCache.get(matchedKey);
-        if (cached)
-          return cached;
-        const built = queryBuilder.buildWhereSchema(modelName, whereConfig);
-        whereBuiltCache.set(matchedKey, built);
-        return built;
-      }
-      return queryBuilder.buildWhereSchema(modelName, whereConfig);
+      return memoize(
+        whereBuiltCache,
+        matchedKey,
+        wasDynamic,
+        () => queryBuilder.buildWhereSchema(modelName, whereConfig)
+      );
     }
     function getUniqueWhereBuilt(whereConfig, matchedKey, wasDynamic) {
-      if (!wasDynamic) {
-        const cacheKey = `unique\0${matchedKey}`;
-        const cached = uniqueWhereCache.get(cacheKey);
-        if (cached)
-          return cached;
-        const built = queryBuilder.buildUniqueWhereSchema(
-          modelName,
-          whereConfig
-        );
-        uniqueWhereCache.set(cacheKey, built);
-        return built;
-      }
-      return queryBuilder.buildUniqueWhereSchema(modelName, whereConfig);
+      return memoize(
+        uniqueWhereCache,
+        `unique\0${matchedKey}`,
+        wasDynamic,
+        () => queryBuilder.buildUniqueWhereSchema(modelName, whereConfig)
+      );
     }
     function buildProjectionSchema(shape) {
       const schemaFields = {};
@@ -4994,7 +5025,7 @@ function createModelGuardExtension(config) {
         forcedSelectCountWhere = result.forcedCountWhere;
       }
       return {
-        zodSchema: import_zod9.z.object(schemaFields).strict(),
+        zodSchema: import_zod11.z.object(schemaFields).strict(),
         forcedIncludeTree,
         forcedSelectTree,
         forcedIncludeCountWhere,
@@ -5002,16 +5033,12 @@ function createModelGuardExtension(config) {
       };
     }
     function getProjection(shape, matchedKey, wasDynamic) {
-      if (!wasDynamic) {
-        const cacheKey = `projection\0${matchedKey}`;
-        const cached = projectionCache.get(cacheKey);
-        if (cached)
-          return cached;
-        const built = buildProjectionSchema(shape);
-        projectionCache.set(cacheKey, built);
-        return built;
-      }
-      return buildProjectionSchema(shape);
+      return memoize(
+        projectionCache,
+        `projection\0${matchedKey}`,
+        wasDynamic,
+        () => buildProjectionSchema(shape)
+      );
     }
     function resolveProjection(shape, parsed, method, matchedKey, wasDynamic) {
       const hasBodyProjection = "select" in parsed || "include" in parsed;
@@ -5205,24 +5232,11 @@ function createModelGuardExtension(config) {
       const hasShapeProjection = !!resolved.shape.select || !!resolved.shape.include;
       if (!hasShapeProjection)
         return resolved.body;
-      const defaultProjection = buildDefaultProjectionBody(resolved.shape);
       const hasBodyProjection = "select" in resolved.body || "include" in resolved.body;
-      if (!hasBodyProjection) {
-        return { ...resolved.body, ...defaultProjection };
-      }
-      const merged = { ...resolved.body };
-      if ("select" in resolved.body && "select" in defaultProjection && isPlainObject(resolved.body.select) && isPlainObject(defaultProjection.select)) {
-        merged.select = applyClientProjectionOverrides(
-          defaultProjection.select,
-          resolved.body.select
-        );
-      } else if ("include" in resolved.body && "include" in defaultProjection && isPlainObject(resolved.body.include) && isPlainObject(defaultProjection.include)) {
-        merged.include = applyClientProjectionOverrides(
-          defaultProjection.include,
-          resolved.body.include
-        );
-      }
-      return merged;
+      if (hasBodyProjection)
+        return resolved.body;
+      const defaultProjection = buildDefaultProjectionBody(resolved.shape);
+      return { ...resolved.body, ...defaultProjection };
     }
     function makeReadMethod(method) {
       return (body) => {
@@ -5255,29 +5269,21 @@ function createModelGuardExtension(config) {
     function makeCreateMethod(method) {
       const isBatch = BATCH_CREATE_METHODS.has(method);
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
-      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;
+      const allowedBodyKeys = getAllowedBodyKeys(method, supportsProjection);
+      const allowedShapeKeys = getAllowedShapeKeys(method, supportsProjection);
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
         if (!resolved.shape.data) {
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
         }
-        validateMutationShapeKeys(
+        validateAllowedKeys(
           resolved.shape,
           allowedShapeKeys,
-          method
+          method,
+          "shape"
         );
-        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        validateAllowedKeys(resolved.body, allowedBodyKeys, method, "body");
         const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
         validateCreateCompleteness(
           modelName,
@@ -5336,20 +5342,21 @@ function createModelGuardExtension(config) {
       const isUniqueWhere = method === "update";
       const isBulk = BULK_MUTATION_METHODS.has(method);
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
-      const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_UPDATE_PROJECTION : ALLOWED_BODY_KEYS_UPDATE;
-      const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_UPDATE_PROJECTION : VALID_SHAPE_KEYS_UPDATE;
+      const allowedBodyKeys = getAllowedBodyKeys(method, supportsProjection);
+      const allowedShapeKeys = getAllowedShapeKeys(method, supportsProjection);
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
         if (!resolved.shape.data) {
           throw new ShapeError(`Guard shape requires "data" for ${method}`);
         }
-        validateMutationShapeKeys(
+        validateAllowedKeys(
           resolved.shape,
           allowedShapeKeys,
-          method
+          method,
+          "shape"
         );
-        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        validateAllowedKeys(resolved.body, allowedBodyKeys, method, "body");
         if (isBulk && !resolved.shape.where) {
           throw new ShapeError(
             `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
@@ -5417,20 +5424,21 @@ function createModelGuardExtension(config) {
       const isUniqueWhere = method === "delete";
       const isBulk = BULK_MUTATION_METHODS.has(method);
       const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
-      const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_DELETE_PROJECTION : ALLOWED_BODY_KEYS_DELETE;
-      const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_DELETE_PROJECTION : VALID_SHAPE_KEYS_DELETE;
+      const allowedBodyKeys = getAllowedBodyKeys(method, supportsProjection);
+      const allowedShapeKeys = getAllowedShapeKeys(method, supportsProjection);
       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 ${method}`);
         }
-        validateMutationShapeKeys(
+        validateAllowedKeys(
           resolved.shape,
           allowedShapeKeys,
-          method
+          method,
+          "shape"
         );
-        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        validateAllowedKeys(resolved.body, allowedBodyKeys, method, "body");
         if (isBulk && !resolved.shape.where) {
           throw new ShapeError(
             `Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`
@@ -5483,6 +5491,8 @@ function createModelGuardExtension(config) {
       };
     }
     function makeUpsertMethod() {
+      const allowedBodyKeys = getAllowedBodyKeys("upsert", true);
+      const allowedShapeKeys = getAllowedShapeKeys("upsert", true);
       return (body) => {
         const caller = resolveCaller();
         const resolved = resolveShape(input, body, contextFn, caller);
@@ -5500,15 +5510,17 @@ function createModelGuardExtension(config) {
         if (!resolved.shape.where) {
           throw new ShapeError('Guard shape requires "where" for upsert');
         }
-        validateMutationShapeKeys(
+        validateAllowedKeys(
           resolved.shape,
-          VALID_SHAPE_KEYS_UPSERT,
-          "upsert"
+          allowedShapeKeys,
+          "upsert",
+          "shape"
         );
-        validateMutationBodyKeys(
+        validateAllowedKeys(
           resolved.body,
-          ALLOWED_BODY_KEYS_UPSERT,
-          "upsert"
+          allowedBodyKeys,
+          "upsert",
+          "body"
         );
         validateUniqueWhereShapeConfig(
           modelName,
@@ -5598,12 +5610,7 @@ function createModelGuardExtension(config) {
         try {
           return fn(body);
         } catch (err) {
-          if (err instanceof import_zod9.z.ZodError) {
-            throw new ShapeError(`Validation failed: ${formatZodError(err)}`, {
-              cause: err
-            });
-          }
-          throw err;
+          throw toShapeError(err);
         }
       };
     }
@@ -5636,6 +5643,15 @@ function createModelGuardExtension(config) {
 }
 
 // src/runtime/guard.ts
+function wrapParseFn(fn) {
+  return (...args) => {
+    try {
+      return fn(...args);
+    } catch (err) {
+      throw toShapeError(err);
+    }
+  };
+}
 function createGuard(config) {
   const scalarBase = createScalarBase(
     config.guardConfig.strictDecimal ?? false
@@ -5657,14 +5673,6 @@ function createGuard(config) {
     warn: (msg) => console.warn(msg)
   };
   const wrapZodErrors = config.wrapZodErrors ?? false;
-  function rethrowZod(err) {
-    if (err instanceof import_zod10.ZodError) {
-      throw new ShapeError(`Validation failed: ${formatZodError(err)}`, {
-        cause: err
-      });
-    }
-    throw err;
-  }
   return {
     input: (model, opts) => {
       const result = schemaBuilder.buildInputSchema(model, opts);
@@ -5672,13 +5680,7 @@ function createGuard(config) {
         return result;
       return {
         schema: result.schema,
-        parse(data) {
-          try {
-            return result.parse(data);
-          } catch (err) {
-            rethrowZod(err);
-          }
-        }
+        parse: wrapParseFn(result.parse)
       };
     },
     model: (model, opts) => schemaBuilder.buildModelSchema(model, opts),
@@ -5688,13 +5690,7 @@ function createGuard(config) {
         return qs;
       return {
         schemas: qs.schemas,
-        parse(body, opts) {
-          try {
-            return qs.parse(body, opts);
-          } catch (err) {
-            rethrowZod(err);
-          }
-        }
+        parse: wrapParseFn(qs.parse)
       };
     },
     extension: (contextFn) => {