prisma-guard 1.2.1 → 1.3.1

package/dist/runtime/index.cjs

@@ -0,0 +1,3444 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  CallerError: () => CallerError,
+  PolicyError: () => PolicyError,
+  ShapeError: () => ShapeError,
+  createGuard: () => createGuard,
+  force: () => force
+});
+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;
+  code = "POLICY_DENIED";
+  constructor(message = "Access denied", options) {
+    super(message, options);
+    this.name = "PolicyError";
+  }
+};
+var ShapeError = class extends Error {
+  status = 400;
+  code = "SHAPE_INVALID";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ShapeError";
+  }
+};
+var CallerError = class extends Error {
+  status = 400;
+  code = "CALLER_UNKNOWN";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CallerError";
+  }
+};
+function formatZodError(err) {
+  return err.issues.map((i) => {
+    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+    return `${p}${i.message}`;
+  }).join("; ");
+}
+
+// src/shared/scalar-base.ts
+var import_zod = require("zod");
+function isJsonSafe(value) {
+  const stack = [{ tag: "visit", value }];
+  const ancestors = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const entry = stack.pop();
+    if (entry.tag === "exit") {
+      ancestors.delete(entry.ref);
+      continue;
+    }
+    const current = entry.value;
+    if (current === void 0)
+      return false;
+    if (current === null)
+      continue;
+    switch (typeof current) {
+      case "string":
+      case "boolean":
+        continue;
+      case "number":
+        if (!Number.isFinite(current))
+          return false;
+        continue;
+      case "object": {
+        if (ancestors.has(current))
+          return false;
+        ancestors.add(current);
+        stack.push({ tag: "exit", ref: current });
+        if (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            stack.push({ tag: "visit", value: current[i] });
+          }
+          continue;
+        }
+        const proto = Object.getPrototypeOf(current);
+        if (proto !== Object.prototype && proto !== null)
+          return false;
+        const values = Object.values(current);
+        for (let i = 0; i < values.length; i++) {
+          stack.push({ tag: "visit", value: values[i] });
+        }
+        continue;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+var DECIMAL_REGEX = /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/;
+var decimalStringSchema = import_zod.z.string().refine(
+  (s) => DECIMAL_REGEX.test(s),
+  "Invalid decimal string"
+);
+var decimalObjectSchema = import_zod.z.custom(
+  (v) => v !== null && typeof v === "object" && typeof v.toFixed === "function" && typeof v.toNumber === "function",
+  "Expected Decimal-compatible object"
+);
+function createDecimalFactory(strict) {
+  if (strict) {
+    return () => import_zod.z.union([decimalStringSchema, decimalObjectSchema]);
+  }
+  return () => import_zod.z.union([import_zod.z.number(), decimalStringSchema, decimalObjectSchema]);
+}
+function createScalarBase(strictDecimal) {
+  return {
+    String: () => import_zod.z.string(),
+    Int: () => import_zod.z.number().int(),
+    Float: () => import_zod.z.number(),
+    Decimal: createDecimalFactory(strictDecimal),
+    BigInt: () => import_zod.z.union([
+      import_zod.z.bigint(),
+      import_zod.z.number().int().refine(
+        (v) => v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER,
+        "Number exceeds safe integer range for BigInt conversion"
+      ).transform((v) => BigInt(v)),
+      import_zod.z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
+    ]),
+    Boolean: () => import_zod.z.boolean(),
+    DateTime: () => import_zod.z.union([
+      import_zod.z.date(),
+      import_zod.z.string().datetime({ offset: true })
+    ]).pipe(import_zod.z.coerce.date()),
+    Json: () => import_zod.z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, Infinity, or circular references)"),
+    Bytes: () => import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.custom((v) => v instanceof Uint8Array)
+    ])
+  };
+}
+var SCALAR_BASE = createScalarBase(false);
+
+// src/runtime/schema-builder.ts
+var import_zod3 = require("zod");
+
+// src/runtime/zod-type-map.ts
+var import_zod2 = require("zod");
+var SCALAR_OPERATORS = {
+  String: /* @__PURE__ */ new Set(["equals", "not", "contains", "startsWith", "endsWith", "in", "notIn"]),
+  Int: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
+  Float: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
+  Decimal: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
+  BigInt: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
+  Boolean: /* @__PURE__ */ new Set(["equals", "not"]),
+  DateTime: /* @__PURE__ */ new Set(["equals", "not", "gt", "gte", "lt", "lte", "in", "notIn"]),
+  Bytes: /* @__PURE__ */ new Set([])
+};
+var SCALAR_LIST_OPERATORS = /* @__PURE__ */ new Set(["has", "hasEvery", "hasSome", "isEmpty", "equals"]);
+var ENUM_OPERATORS = /* @__PURE__ */ new Set(["equals", "not", "in", "notIn"]);
+var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
+var COMPARABLE_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt", "String", "DateTime"]);
+function getSupportedOperators(fieldMeta) {
+  if (fieldMeta.isList)
+    return [...SCALAR_LIST_OPERATORS];
+  if (fieldMeta.isEnum)
+    return [...ENUM_OPERATORS];
+  const ops = SCALAR_OPERATORS[fieldMeta.type];
+  if (!ops)
+    return [];
+  return [...ops];
+}
+function createBaseType(fieldMeta, enumMap, scalarBase) {
+  let base;
+  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);
+  } else {
+    const factory = scalarBase[fieldMeta.type];
+    if (!factory) {
+      throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
+    }
+    base = factory();
+  }
+  if (fieldMeta.isList) {
+    base = import_zod2.z.array(base);
+  }
+  return base;
+}
+function createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
+  if (!SCALAR_LIST_OPERATORS.has(operator)) {
+    throw new ShapeError(`Operator "${operator}" not supported for scalar list fields`);
+  }
+  if (operator === "isEmpty") {
+    return import_zod2.z.boolean();
+  }
+  if (operator === "equals") {
+    const itemMeta2 = { ...fieldMeta, isList: false };
+    const itemBase2 = createBaseType(itemMeta2, enumMap, scalarBase);
+    return fieldMeta.isRequired ? import_zod2.z.array(itemBase2) : import_zod2.z.union([import_zod2.z.array(itemBase2), import_zod2.z.null()]);
+  }
+  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 import_zod2.z.array(itemBase);
+}
+function createOperatorSchema(fieldMeta, operator, enumMap, scalarBase) {
+  if (fieldMeta.isList) {
+    return createScalarListOperatorSchema(fieldMeta, operator, enumMap, scalarBase);
+  }
+  if (fieldMeta.isEnum) {
+    const values = enumMap[fieldMeta.type];
+    if (!values || values.length === 0) {
+      throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
+    }
+    if (!ENUM_OPERATORS.has(operator)) {
+      throw new ShapeError(`Operator "${operator}" not supported for enum fields`);
+    }
+    const enumSchema = import_zod2.z.enum(values);
+    if (operator === "equals" || operator === "not") {
+      return !fieldMeta.isRequired ? import_zod2.z.union([enumSchema, import_zod2.z.null()]) : enumSchema;
+    }
+    if (!fieldMeta.isRequired) {
+      return import_zod2.z.array(import_zod2.z.union([enumSchema, import_zod2.z.null()]));
+    }
+    return import_zod2.z.array(enumSchema);
+  }
+  const supportedOps = SCALAR_OPERATORS[fieldMeta.type];
+  if (!supportedOps) {
+    throw new ShapeError(`Unknown scalar type for operator: ${fieldMeta.type}`);
+  }
+  if (supportedOps.size === 0) {
+    throw new ShapeError(`Type "${fieldMeta.type}" does not support filter operators`);
+  }
+  if (!supportedOps.has(operator)) {
+    throw new ShapeError(`Operator "${operator}" not supported for type "${fieldMeta.type}"`);
+  }
+  const factory = scalarBase[fieldMeta.type];
+  if (!factory) {
+    throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
+  }
+  const scalar = factory();
+  if (operator === "equals" || operator === "not") {
+    return !fieldMeta.isRequired ? import_zod2.z.union([scalar, import_zod2.z.null()]) : scalar;
+  }
+  if (operator === "in" || operator === "notIn") {
+    if (!fieldMeta.isRequired) {
+      return import_zod2.z.array(import_zod2.z.union([scalar, import_zod2.z.null()]));
+    }
+    return import_zod2.z.array(scalar);
+  }
+  return scalar;
+}
+
+// src/shared/utils.ts
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function schemaProducesValueForUndefined(schema) {
+  const result = schema.safeParse(void 0);
+  return result.success && result.data !== void 0;
+}
+function isZodSchema(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.parse === "function" && typeof v.optional === "function";
+}
+
+// src/runtime/schema-builder.ts
+var DEFAULT_MAX_CACHE = 500;
+var DEFAULT_MAX_DEPTH = 5;
+function lruGet(cache, key) {
+  const value = cache.get(key);
+  if (value !== void 0) {
+    cache.delete(key);
+    cache.set(key, value);
+  }
+  return value;
+}
+function lruSet(cache, key, value, maxSize) {
+  if (cache.has(key))
+    cache.delete(key);
+  cache.set(key, value);
+  if (cache.size > maxSize) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0)
+      cache.delete(oldest);
+  }
+}
+function createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults) {
+  const chainCache = /* @__PURE__ */ new Map();
+  function buildFieldSchema(model, field) {
+    const cacheKey = `${model}.${field}`;
+    const cached = lruGet(chainCache, cacheKey);
+    if (cached)
+      return cached;
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldMeta = modelFields[field];
+    if (!fieldMeta)
+      throw new ShapeError(`Unknown field "${field}" on model "${model}"`);
+    const base = createBaseType(fieldMeta, enumMap, scalarBase);
+    let result = base;
+    const chainFn = zodChains[model]?.[field];
+    if (chainFn) {
+      try {
+        result = chainFn(base);
+      } catch (err) {
+        throw new ShapeError(
+          `Invalid @zod directive on ${model}.${field} (${fieldMeta.type}): ${err.message}`,
+          { cause: err }
+        );
+      }
+    }
+    lruSet(chainCache, cacheKey, result, DEFAULT_MAX_CACHE);
+    return result;
+  }
+  function buildBaseFieldSchema(model, field) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldMeta = modelFields[field];
+    if (!fieldMeta)
+      throw new ShapeError(`Unknown field "${field}" on model "${model}"`);
+    return createBaseType(fieldMeta, enumMap, scalarBase);
+  }
+  function buildInputSchema(model, opts) {
+    if (opts.pick && opts.omit) {
+      throw new ShapeError('InputOpts cannot define both "pick" and "omit"');
+    }
+    const mode = opts.mode ?? "create";
+    const allowNull = opts.allowNull ?? true;
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const zodDefaultFields = zodDefaults[model];
+    const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
+    let fieldNames = Object.keys(modelFields).filter((name) => {
+      const meta = modelFields[name];
+      return !meta.isRelation && !meta.isUpdatedAt;
+    });
+    if (opts.pick) {
+      for (const name of opts.pick) {
+        if (!modelFields[name])
+          throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
+        if (modelFields[name].isRelation)
+          throw new ShapeError(`Field "${name}" cannot be used in input schema (relation field)`);
+        if (modelFields[name].isUpdatedAt)
+          throw new ShapeError(`Field "${name}" cannot be used in input schema (updatedAt field)`);
+      }
+      fieldNames = fieldNames.filter((n) => opts.pick.includes(n));
+    } else if (opts.omit) {
+      for (const name of opts.omit) {
+        if (!modelFields[name])
+          throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
+      }
+      fieldNames = fieldNames.filter((n) => !opts.omit.includes(n));
+    }
+    const schemaMap = {};
+    for (const name of fieldNames) {
+      const fieldMeta = modelFields[name];
+      let fieldSchema;
+      let handlesUndefined;
+      if (opts.refine?.[name]) {
+        let refined;
+        try {
+          refined = opts.refine[name](buildBaseFieldSchema(model, name));
+        } catch (err) {
+          throw new ShapeError(
+            `Refine function for "${model}.${name}" threw: ${err.message}`,
+            { cause: err }
+          );
+        }
+        if (!isZodSchema(refined)) {
+          throw new ShapeError(
+            `Refine function for "${model}.${name}" must return a Zod schema`
+          );
+        }
+        fieldSchema = refined;
+        handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
+      } else {
+        fieldSchema = buildFieldSchema(model, name);
+        handlesUndefined = zodDefaultSet !== void 0 && zodDefaultSet.has(name);
+      }
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          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;
+    }
+    let schema = import_zod3.z.object(schemaMap).strict();
+    if (opts.partial) {
+      schema = schema.partial();
+    }
+    return {
+      schema,
+      parse(data) {
+        return schema.parse(data);
+      }
+    };
+  }
+  function buildModelSchema(model, opts, depth = 0, maxDepth) {
+    if (opts.pick && opts.omit) {
+      throw new ShapeError('ModelOpts cannot define both "pick" and "omit"');
+    }
+    const effectiveMaxDepth = maxDepth ?? opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+    if (depth > effectiveMaxDepth) {
+      throw new ShapeError(`Maximum include depth (${effectiveMaxDepth}) exceeded`);
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const includeKeys = new Set(Object.keys(opts.include ?? {}));
+    if (opts.pick) {
+      for (const name of opts.pick) {
+        if (!modelFields[name])
+          throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
+        if (modelFields[name].isRelation && !includeKeys.has(name)) {
+          throw new ShapeError(`Field "${name}" is a relation on model "${model}". Use include: { ${name}: ... } instead of pick.`);
+        }
+      }
+    }
+    if (opts.omit) {
+      for (const name of opts.omit) {
+        if (!modelFields[name])
+          throw new ShapeError(`Unknown field "${name}" on model "${model}"`);
+      }
+    }
+    let scalarNames = Object.keys(modelFields).filter((name) => {
+      const meta = modelFields[name];
+      return !meta.isRelation;
+    });
+    if (opts.pick) {
+      scalarNames = scalarNames.filter((n) => opts.pick.includes(n));
+    } else if (opts.omit) {
+      scalarNames = scalarNames.filter((n) => !opts.omit.includes(n));
+    }
+    const schemaMap = {};
+    for (const name of scalarNames) {
+      const fieldMeta = modelFields[name];
+      let fieldSchema = createBaseType(fieldMeta, enumMap, scalarBase);
+      if (!fieldMeta.isRequired) {
+        fieldSchema = fieldSchema.nullable();
+      }
+      schemaMap[name] = fieldSchema;
+    }
+    for (const [relName, relOpts] of Object.entries(opts.include ?? {})) {
+      const fieldMeta = modelFields[relName];
+      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}"`);
+      const relatedModel = fieldMeta.type;
+      if (!typeMap[relatedModel]) {
+        throw new ShapeError(`Related model "${relatedModel}" not found in type map`);
+      }
+      let relSchema = buildModelSchema(
+        relatedModel,
+        relOpts,
+        depth + 1,
+        effectiveMaxDepth
+      );
+      if (fieldMeta.isList) {
+        relSchema = import_zod3.z.array(relSchema);
+      } else if (!fieldMeta.isRequired) {
+        relSchema = relSchema.nullable();
+      }
+      schemaMap[relName] = relSchema;
+    }
+    if (opts._count) {
+      const listRelationNames = Object.keys(modelFields).filter(
+        (n) => modelFields[n].isRelation && modelFields[n].isList
+      );
+      if (opts._count === true) {
+        const countFields = {};
+        for (const relName of listRelationNames) {
+          countFields[relName] = import_zod3.z.number().int().min(0);
+        }
+        schemaMap["_count"] = import_zod3.z.object(countFields);
+      } else {
+        const countFields = {};
+        for (const relName of Object.keys(opts._count)) {
+          if (!modelFields[relName])
+            throw new ShapeError(`Unknown field "${relName}" on model "${model}" in _count`);
+          if (!modelFields[relName].isRelation)
+            throw new ShapeError(`Field "${relName}" is not a relation on model "${model}" in _count`);
+          if (!modelFields[relName].isList)
+            throw new ShapeError(`Field "${relName}" is a to-one relation on model "${model}" in _count. Only to-many relations support _count.`);
+          countFields[relName] = import_zod3.z.number().int().min(0);
+        }
+        schemaMap["_count"] = import_zod3.z.object(countFields);
+      }
+    }
+    let schema = import_zod3.z.object(schemaMap);
+    if (opts.strict) {
+      schema = schema.strict();
+    }
+    return schema;
+  }
+  return { buildFieldSchema, buildBaseFieldSchema, buildInputSchema, buildModelSchema };
+}
+
+// src/runtime/query-builder.ts
+var import_zod7 = require("zod");
+
+// src/shared/constants.ts
+var SHAPE_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "where",
+  "include",
+  "select",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip",
+  "distinct",
+  "having",
+  "_count",
+  "_avg",
+  "_sum",
+  "_min",
+  "_max",
+  "by"
+]);
+var GUARD_SHAPE_KEYS = /* @__PURE__ */ new Set([
+  "data",
+  "create",
+  "update",
+  ...SHAPE_CONFIG_KEYS
+]);
+var COMBINATOR_KEYS = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+var TO_MANY_RELATION_OPS = /* @__PURE__ */ new Set(["some", "every", "none"]);
+var TO_ONE_RELATION_OPS = /* @__PURE__ */ new Set(["is", "isNot"]);
+var ALL_RELATION_OPS = /* @__PURE__ */ new Set([...TO_MANY_RELATION_OPS, ...TO_ONE_RELATION_OPS]);
+function toDelegateKey(modelName) {
+  return modelName[0].toLowerCase() + modelName.slice(1);
+}
+var FORCED_MARKER = Symbol.for("prisma-guard.forced");
+function isForcedValue(v) {
+  return v !== null && typeof v === "object" && v[FORCED_MARKER] === true;
+}
+function force(value) {
+  const wrapper = { value };
+  wrapper[FORCED_MARKER] = true;
+  return wrapper;
+}
+
+// src/shared/match-caller.ts
+function matchCallerPattern(patterns, caller) {
+  if (patterns.includes(caller))
+    return caller;
+  const matches = [];
+  for (const pattern of patterns) {
+    if (!pattern.includes(":"))
+      continue;
+    const patternParts = pattern.split("/");
+    const callerParts = caller.split("/");
+    if (patternParts.length !== callerParts.length)
+      continue;
+    let ok = true;
+    for (let i = 0; i < patternParts.length; i++) {
+      if (patternParts[i].startsWith(":"))
+        continue;
+      if (patternParts[i] !== callerParts[i]) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok)
+      matches.push(pattern);
+  }
+  if (matches.length === 0)
+    return null;
+  if (matches.length > 1) {
+    throw new CallerError(
+      `Ambiguous caller "${caller}" matches multiple patterns: ${matches.map((p) => `"${p}"`).join(", ")}`
+    );
+  }
+  return matches[0];
+}
+
+// src/runtime/policy.ts
+function requireContext(ctx, label) {
+  if (ctx === void 0 || ctx === null) {
+    throw new PolicyError(`Context required for ${label}`);
+  }
+}
+function validateContext(ctx) {
+  if (ctx === null || ctx === void 0) {
+    throw new PolicyError(
+      `guard.extension() context function must return a plain object, got ${String(ctx)}`
+    );
+  }
+  if (!isPlainObject(ctx)) {
+    throw new PolicyError(
+      `guard.extension() context function must return a plain object, got ${Array.isArray(ctx) ? "array" : typeof ctx}`
+    );
+  }
+  return ctx;
+}
+
+// src/runtime/query-builder-where.ts
+var import_zod4 = require("zod");
+
+// src/shared/deep-clone.ts
+function deepClone(value) {
+  if (value === null || value === void 0)
+    return value;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+      return value;
+    case "object": {
+      if (value instanceof Date)
+        return new Date(value.getTime());
+      if (value instanceof Uint8Array)
+        return value.slice();
+      if (Array.isArray(value))
+        return value.map(deepClone);
+      const proto = Object.getPrototypeOf(value);
+      if (proto !== Object.prototype && proto !== null)
+        return value;
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = deepClone(v);
+      }
+      return result;
+    }
+    default:
+      return value;
+  }
+}
+
+// src/runtime/query-builder-forced.ts
+var EMPTY_WHERE_FORCED = { conditions: {}, relations: {} };
+function hasWhereForced(f) {
+  return Object.keys(f.conditions).length > 0 || Object.keys(f.relations).length > 0;
+}
+function mergeWhereForced(where, forced) {
+  if (!hasWhereForced(forced))
+    return where ?? {};
+  let result = where ? deepClone(where) : {};
+  for (const [relName, opMap] of Object.entries(forced.relations)) {
+    if (!result[relName] || typeof result[relName] !== "object") {
+      result[relName] = {};
+    }
+    const relObj = result[relName];
+    for (const [op, nestedForced] of Object.entries(opMap)) {
+      relObj[op] = mergeWhereForced(
+        relObj[op],
+        nestedForced
+      );
+    }
+  }
+  if (Object.keys(forced.conditions).length > 0) {
+    const scalarClone = deepClone(forced.conditions);
+    if (Object.keys(result).length === 0) {
+      result = scalarClone;
+    } else {
+      result = { AND: [result, scalarClone] };
+    }
+  }
+  return result;
+}
+function mergeUniqueWhereForced(where, forced) {
+  if (!hasWhereForced(forced))
+    return where ?? {};
+  let result = where ? { ...where } : {};
+  for (const [relName, opMap] of Object.entries(forced.relations)) {
+    if (!result[relName] || typeof result[relName] !== "object") {
+      result[relName] = {};
+    }
+    const relObj = result[relName];
+    for (const [op, nestedForced] of Object.entries(opMap)) {
+      relObj[op] = mergeWhereForced(
+        relObj[op],
+        nestedForced
+      );
+    }
+  }
+  if (Object.keys(forced.conditions).length > 0) {
+    const conditions = [deepClone(forced.conditions)];
+    const existing = result.AND;
+    if (existing) {
+      if (Array.isArray(existing)) {
+        conditions.unshift(...existing);
+      } else {
+        conditions.unshift(existing);
+      }
+    }
+    result.AND = conditions;
+  }
+  return result;
+}
+function applyBuiltShape(built, body, isUniqueMethod) {
+  const validated = built.zodSchema.parse(body);
+  if (hasWhereForced(built.forcedWhere)) {
+    validated.where = isUniqueMethod ? mergeUniqueWhereForced(
+      validated.where,
+      built.forcedWhere
+    ) : mergeWhereForced(
+      validated.where,
+      built.forcedWhere
+    );
+  }
+  if (Object.keys(built.forcedIncludeTree).length > 0) {
+    applyForcedTree(validated, "include", built.forcedIncludeTree);
+  }
+  if (Object.keys(built.forcedSelectTree).length > 0) {
+    applyForcedTree(validated, "select", built.forcedSelectTree);
+  }
+  if (Object.keys(built.forcedIncludeCountWhere).length > 0) {
+    const ic = validated.include;
+    if (ic)
+      applyForcedCountWhere(ic, built.forcedIncludeCountWhere);
+  }
+  if (Object.keys(built.forcedSelectCountWhere).length > 0) {
+    const sc = validated.select;
+    if (sc)
+      applyForcedCountWhere(sc, built.forcedSelectCountWhere);
+  }
+  return validated;
+}
+function buildCountForPlacement(countWhere) {
+  const countSelect = {};
+  for (const [countRel, countForced] of Object.entries(countWhere)) {
+    countSelect[countRel] = { where: mergeWhereForced(void 0, countForced) };
+  }
+  return { _count: { select: countSelect } };
+}
+function applyForcedTree(validated, key, tree) {
+  const container = validated[key];
+  if (!container)
+    return;
+  for (const [relName, forced] of Object.entries(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.`
+        );
+      }
+    }
+  }
+}
+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));
+    }
+    result[relName] = Object.keys(nested).length > 0 ? nested : true;
+  }
+  return result;
+}
+function applyForcedCountWhere(container, forcedCountWhere) {
+  const countVal = container._count;
+  if (!countVal || countVal === true || !isPlainObject(countVal))
+    return;
+  const countObj = countVal;
+  const selectVal = countObj.select;
+  if (!selectVal || !isPlainObject(selectVal))
+    return;
+  const selectObj = selectVal;
+  for (const [relName, forced] of Object.entries(forcedCountWhere)) {
+    const relVal = selectObj[relName];
+    if (relVal === void 0)
+      continue;
+    if (relVal === true) {
+      selectObj[relName] = { where: mergeWhereForced(void 0, forced) };
+    } else if (isPlainObject(relVal)) {
+      const relObj = relVal;
+      relObj.where = mergeWhereForced(
+        relObj.where,
+        forced
+      );
+    }
+  }
+}
+function collectWhereFieldKeys(where) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "AND") {
+      const items = Array.isArray(value) ? value : [value];
+      for (const item of items) {
+        if (isPlainObject(item)) {
+          for (const k of collectWhereFieldKeys(item))
+            keys.add(k);
+        }
+      }
+    } else if (key !== "OR" && key !== "NOT") {
+      keys.add(key);
+    }
+  }
+  return keys;
+}
+function validateResolvedUniqueWhere(model, where, method, uniqueMap) {
+  const constraints = uniqueMap[model];
+  if (!constraints || constraints.length === 0)
+    return;
+  const fieldKeys = collectWhereFieldKeys(where);
+  const covered = constraints.some(
+    (constraint) => constraint.every((field) => fieldKeys.has(field))
+  );
+  if (!covered) {
+    const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
+    throw new ShapeError(
+      `${method} on model "${model}" requires resolved where to cover a unique constraint: ${constraintDesc}`
+    );
+  }
+}
+function collectEqualityFields(where, model, typeMap) {
+  const combinators = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+  const fields = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "AND") {
+      if (isPlainObject(value)) {
+        for (const f of collectEqualityFields(value, model, typeMap)) {
+          fields.add(f);
+        }
+      }
+      continue;
+    }
+    if (combinators.has(key))
+      continue;
+    if (typeMap && model && typeMap[model]?.[key]?.isRelation)
+      continue;
+    if (!value || !isPlainObject(value))
+      continue;
+    if (Object.keys(value).every((op) => op === "equals")) {
+      fields.add(key);
+    }
+  }
+  return fields;
+}
+function validateUniqueEquality(model, where, method, uniqueMap, typeMap) {
+  const constraints = uniqueMap[model];
+  if (!constraints || constraints.length === 0)
+    return;
+  const equalityFields = collectEqualityFields(where, model, typeMap);
+  const valid = constraints.some(
+    (constraint) => constraint.every((field) => equalityFields.has(field))
+  );
+  if (!valid) {
+    const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
+    throw new ShapeError(
+      `${method} on model "${model}" requires where to cover a unique constraint with equality operators only: ${constraintDesc}`
+    );
+  }
+}
+
+// src/runtime/query-builder-where.ts
+var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+var STRING_MODE_OPS = /* @__PURE__ */ new Set(["contains", "startsWith", "endsWith", "equals"]);
+var MAX_WHERE_DEPTH = 10;
+function safeStringify(v) {
+  if (typeof v === "bigint")
+    return `${v}n`;
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+function forcedValuesEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "bigint")
+    return a === b;
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b))
+      return false;
+    if (a.length !== b.length)
+      return false;
+    return a.every((v, i) => forcedValuesEqual(v, b[i]));
+  }
+  if (!isPlainObject(a) || !isPlainObject(b))
+    return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length)
+    return false;
+  return aKeys.every((k) => k in b && forcedValuesEqual(a[k], b[k]));
+}
+function mergeScalarConditions(target, source) {
+  for (const [field, ops] of Object.entries(source)) {
+    const existing = target[field];
+    if (existing === void 0) {
+      target[field] = ops;
+      continue;
+    }
+    if (field === "NOT") {
+      const existingArr = Array.isArray(existing) ? existing : [existing];
+      const sourceArr = Array.isArray(ops) ? ops : [ops];
+      target[field] = [...existingArr, ...sourceArr];
+      continue;
+    }
+    if (isPlainObject(existing) && isPlainObject(ops)) {
+      for (const [op, val] of Object.entries(ops)) {
+        if (op in existing) {
+          const existingVal = existing[op];
+          if (!forcedValuesEqual(existingVal, val)) {
+            throw new ShapeError(
+              `Conflicting forced where values for "${field}.${op}": shape defines both ${safeStringify(existingVal)} and ${safeStringify(val)}`
+            );
+          }
+        }
+      }
+      Object.assign(existing, ops);
+      continue;
+    }
+    if (!forcedValuesEqual(existing, ops)) {
+      throw new ShapeError(
+        `Conflicting forced where values for "${field}"`
+      );
+    }
+  }
+}
+function mergeRelationForcedMaps(target, source) {
+  for (const [relName, ops] of Object.entries(source)) {
+    if (!target[relName]) {
+      target[relName] = ops;
+      continue;
+    }
+    for (const [op, forced] of Object.entries(ops)) {
+      if (!target[relName][op]) {
+        target[relName][op] = forced;
+      } else {
+        mergeScalarConditions(target[relName][op].conditions, forced.conditions);
+        mergeRelationForcedMaps(target[relName][op].relations, forced.relations);
+      }
+    }
+  }
+}
+function createWhereBuilder(typeMap, enumMap, scalarBase) {
+  function buildWhereSchema(model, whereConfig, depth) {
+    const currentDepth = depth ?? 0;
+    if (currentDepth > MAX_WHERE_DEPTH) {
+      throw new ShapeError(
+        `Where schema for model "${model}" exceeds maximum nesting depth (${MAX_WHERE_DEPTH}). Check for circular relation references in the shape.`
+      );
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    const scalarConditions = {};
+    const relationForced = {};
+    for (const [key, value] of Object.entries(whereConfig)) {
+      if (COMBINATOR_KEYS.has(key)) {
+        processCombinator(
+          key,
+          value,
+          model,
+          fieldSchemas,
+          scalarConditions,
+          relationForced,
+          currentDepth
+        );
+        continue;
+      }
+      const fieldMeta = modelFields[key];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${key}" on model "${model}"`);
+      if (fieldMeta.isRelation) {
+        processRelationFilter(
+          key,
+          value,
+          fieldMeta,
+          model,
+          fieldSchemas,
+          relationForced,
+          currentDepth
+        );
+        continue;
+      }
+      if (UNSUPPORTED_WHERE_TYPES.has(fieldMeta.type) && !fieldMeta.isList) {
+        throw new ShapeError(
+          `${fieldMeta.type} field "${key}" cannot be used in where filters`
+        );
+      }
+      processScalarField(key, value, model, fieldMeta, fieldSchemas, scalarConditions);
+    }
+    const schema = Object.keys(fieldSchemas).length > 0 ? import_zod4.z.object(fieldSchemas).strict().optional() : null;
+    return {
+      schema,
+      forced: {
+        conditions: scalarConditions,
+        relations: relationForced
+      }
+    };
+  }
+  function processCombinator(key, value, model, fieldSchemas, parentConditions, parentRelations, depth) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`"${key}" in where shape must be an object defining allowed fields`);
+    }
+    const result = buildWhereSchema(model, value, depth + 1);
+    if (!result.schema && !hasWhereForced(result.forced)) {
+      throw new ShapeError(
+        `Empty "${key}" combinator in where shape for model "${model}". Define at least one field.`
+      );
+    }
+    if (result.schema) {
+      let elementSchema = result.schema;
+      if (!hasWhereForced(result.forced)) {
+        elementSchema = result.schema.refine(
+          (v) => v !== void 0 && v !== null && Object.keys(v).some((k) => v[k] !== void 0),
+          { message: `"${key}" member must specify at least one condition` }
+        );
+      }
+      if (key === "NOT") {
+        fieldSchemas[key] = import_zod4.z.union([elementSchema, import_zod4.z.array(elementSchema).min(1)]).optional();
+      } else {
+        fieldSchemas[key] = import_zod4.z.array(elementSchema).min(1).optional();
+      }
+    }
+    if (hasWhereForced(result.forced)) {
+      if (key === "AND" || key === "OR") {
+        mergeScalarConditions(parentConditions, result.forced.conditions);
+        mergeRelationForcedMaps(parentRelations, result.forced.relations);
+      } else {
+        const notWhere = mergeWhereForced(void 0, result.forced);
+        if (Object.keys(notWhere).length > 0) {
+          const existing = parentConditions[key];
+          if (existing) {
+            parentConditions[key] = Array.isArray(existing) ? [...existing, notWhere] : [existing, notWhere];
+          } else {
+            parentConditions[key] = notWhere;
+          }
+        }
+      }
+    }
+  }
+  function processRelationFilter(key, value, fieldMeta, model, fieldSchemas, parentRelations, depth) {
+    if (!isPlainObject(value)) {
+      throw new ShapeError(`Relation filter for "${key}" must be an object with operators (some, every, none, is, isNot)`);
+    }
+    const allowedOps = fieldMeta.isList ? TO_MANY_RELATION_OPS : TO_ONE_RELATION_OPS;
+    if (Object.keys(value).length === 0) {
+      throw new ShapeError(
+        `Empty relation filter for "${key}" on model "${model}". Define at least one operator: ${[...allowedOps].join(", ")}`
+      );
+    }
+    const opSchemas = {};
+    const opForced = {};
+    let hasClientOps = false;
+    for (const [op, opValue] of Object.entries(value)) {
+      if (!allowedOps.has(op)) {
+        const allowed = [...allowedOps].join(", ");
+        throw new ShapeError(
+          `Operator "${op}" not supported for ${fieldMeta.isList ? "to-many" : "to-one"} relation "${key}". Allowed: ${allowed}`
+        );
+      }
+      if (!isPlainObject(opValue)) {
+        throw new ShapeError(
+          `Relation filter operator "${op}" on "${key}" must be an object defining nested where fields`
+        );
+      }
+      const nested = buildWhereSchema(fieldMeta.type, opValue, depth + 1);
+      if (!nested.schema && !hasWhereForced(nested.forced)) {
+        throw new ShapeError(
+          `Empty nested where for relation "${key}.${op}" on model "${model}". Define at least one field.`
+        );
+      }
+      if (nested.schema) {
+        if (!hasWhereForced(nested.forced)) {
+          opSchemas[op] = nested.schema.refine(
+            (v) => v === void 0 || Object.keys(v).length > 0,
+            { message: `Relation filter "${key}.${op}" requires at least one condition` }
+          );
+        } else {
+          opSchemas[op] = nested.schema;
+        }
+        hasClientOps = true;
+      }
+      if (hasWhereForced(nested.forced)) {
+        opForced[op] = nested.forced;
+      }
+    }
+    if (!hasClientOps && Object.keys(opForced).length === 0) {
+      throw new ShapeError(
+        `Relation filter for "${key}" on model "${model}" produced no conditions. Define at least one nested field in the operator shape.`
+      );
+    }
+    if (hasClientOps) {
+      const clientOpKeys = Object.keys(opSchemas);
+      const opObjSchema = import_zod4.z.object(opSchemas).strict();
+      if (Object.keys(opForced).length === 0) {
+        fieldSchemas[key] = opObjSchema.refine(
+          (v) => clientOpKeys.some((k) => v[k] !== void 0),
+          { message: `At least one relation operator required for "${key}"` }
+        ).optional();
+      } else {
+        fieldSchemas[key] = opObjSchema.optional();
+      }
+    }
+    if (Object.keys(opForced).length > 0) {
+      parentRelations[key] = opForced;
+    }
+  }
+  function processScalarField(fieldName, operators, model, fieldMeta, fieldSchemas, scalarConditions) {
+    if (!isPlainObject(operators)) {
+      throw new ShapeError(
+        `Where config for scalar field "${fieldName}" on model "${model}" must be an object of operators`
+      );
+    }
+    const opSchemas = {};
+    const fieldForced = {};
+    let hasClientOps = false;
+    let hasStringModeOp = false;
+    const clientOpKeys = [];
+    for (const [op, opValue] of Object.entries(operators)) {
+      if (opValue === true) {
+        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap, scalarBase).optional();
+        hasClientOps = true;
+        clientOpKeys.push(op);
+        if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+          hasStringModeOp = true;
+        }
+      } else {
+        const actualOpValue = isForcedValue(opValue) ? opValue.value : opValue;
+        const opSchema = createOperatorSchema(fieldMeta, op, enumMap, scalarBase);
+        let parsed;
+        try {
+          parsed = opSchema.parse(actualOpValue);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid forced value for "${model}.${fieldName}.${op}": ${err.message}`
+          );
+        }
+        fieldForced[op] = parsed;
+      }
+    }
+    if (!hasClientOps && Object.keys(fieldForced).length === 0) {
+      throw new ShapeError(
+        `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
+      );
+    }
+    if (hasStringModeOp) {
+      opSchemas["mode"] = import_zod4.z.enum(["default", "insensitive"]).optional();
+    }
+    if (hasClientOps) {
+      const opObj = import_zod4.z.object(opSchemas).strict();
+      fieldSchemas[fieldName] = opObj.refine(
+        (v) => clientOpKeys.some((k) => v[k] !== void 0),
+        { message: `At least one operator required for where field "${fieldName}"` }
+      ).optional();
+    }
+    if (Object.keys(fieldForced).length > 0) {
+      scalarConditions[fieldName] = fieldForced;
+    }
+  }
+  return { buildWhereSchema };
+}
+
+// src/runtime/query-builder-args.ts
+var import_zod5 = 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 createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
+  function buildOrderBySchema(model, orderByConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(orderByConfig, `orderBy on model "${model}"`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(orderByConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in orderBy`);
+      if (fieldMeta.type === "Json")
+        throw new ShapeError(`Json field "${fieldName}" cannot be used in orderBy`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in orderBy`);
+      fieldSchemas[fieldName] = import_zod5.z.enum(["asc", "desc"]).optional();
+    }
+    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" }
+    );
+    return import_zod5.z.union([singleSchema, import_zod5.z.array(singleSchema).min(1)]).optional();
+  }
+  function buildTakeSchema(config) {
+    if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
+      throw new ShapeError(`take max must be a finite integer, got ${config.max}`);
+    }
+    if (config.max < 1) {
+      throw new ShapeError(`take max must be at least 1, got ${config.max}`);
+    }
+    if (config.default !== void 0) {
+      if (!Number.isFinite(config.default) || !Number.isInteger(config.default)) {
+        throw new ShapeError(`take default must be a finite integer, got ${config.default}`);
+      }
+      if (config.default < 1) {
+        throw new ShapeError(`take default must be at least 1, got ${config.default}`);
+      }
+      if (config.default > config.max) {
+        throw new ShapeError("take default cannot exceed max");
+      }
+      return import_zod5.z.number().int().min(1).max(config.max).default(config.default);
+    }
+    return import_zod5.z.number().int().min(1).max(config.max).optional();
+  }
+  function buildCursorSchema(model, cursorConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(cursorConfig, `cursor on model "${model}"`);
+    const cursorFields = new Set(Object.keys(cursorConfig));
+    const constraints = uniqueMap[model];
+    if (constraints && constraints.length > 0) {
+      const covered = constraints.some(
+        (constraint) => constraint.length === cursorFields.size && constraint.every((field) => cursorFields.has(field))
+      );
+      if (!covered) {
+        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
+        throw new ShapeError(
+          `cursor on model "${model}" must exactly match a unique constraint: ${constraintDesc}`
+        );
+      }
+    }
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(cursorConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in cursor`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in cursor`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in cursor`);
+      fieldSchemas[fieldName] = createBaseType(fieldMeta, enumMap, scalarBase);
+    }
+    return import_zod5.z.object(fieldSchemas).strict().optional();
+  }
+  function buildDistinctSchema(model, distinctConfig) {
+    if (distinctConfig.length === 0) {
+      throw new ShapeError("distinct must contain at least one field");
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    for (const fieldName of distinctConfig) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in distinct`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in distinct`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in distinct`);
+    }
+    const enumSchema = import_zod5.z.enum(distinctConfig);
+    return import_zod5.z.union([enumSchema, import_zod5.z.array(enumSchema).min(1)]).optional();
+  }
+  function buildBySchema(model, byConfig) {
+    if (byConfig.length === 0) {
+      throw new ShapeError('groupBy "by" must contain at least one field');
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    for (const fieldName of byConfig) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in by`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in by`);
+      if (UNSUPPORTED_BY_TYPES.has(fieldMeta.type)) {
+        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in by`);
+      }
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in by`);
+    }
+    const enumSchema = import_zod5.z.enum(byConfig);
+    return import_zod5.z.union([enumSchema, import_zod5.z.array(enumSchema).min(1)]);
+  }
+  function buildHavingSchema(model, havingConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(havingConfig, `having on model "${model}"`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(havingConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in having`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in having`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in having`);
+      const ops = getSupportedOperators(fieldMeta);
+      if (ops.length === 0) {
+        throw new ShapeError(`${fieldMeta.type} field "${fieldName}" cannot be used in having filters`);
+      }
+      const opSchemas = {};
+      const opKeys = [];
+      for (const op of ops) {
+        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap, scalarBase).optional();
+        opKeys.push(op);
+      }
+      if (fieldMeta.type === "String" && !fieldMeta.isList) {
+        opSchemas["mode"] = import_zod5.z.enum(["default", "insensitive"]).optional();
+      }
+      fieldSchemas[fieldName] = import_zod5.z.object(opSchemas).strict().refine(
+        (v) => opKeys.some((k) => v[k] !== void 0),
+        { message: `At least one operator required for having field "${fieldName}"` }
+      ).optional();
+    }
+    const havingFieldKeys = Object.keys(fieldSchemas);
+    return import_zod5.z.object(fieldSchemas).strict().refine(
+      (v) => havingFieldKeys.some((k) => v[k] !== void 0),
+      { message: "having must specify at least one field" }
+    ).optional();
+  }
+  function buildAggregateFieldSchema(model, opName, fieldConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    requireConfigTrue(fieldConfig, `${opName} on model "${model}"`);
+    const isNumericOnly = opName === "_avg" || opName === "_sum";
+    const isComparableOnly = opName === "_min" || opName === "_max";
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(fieldConfig)) {
+      if (fieldName === "_all" && opName === "_count") {
+        fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
+        continue;
+      }
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${opName}`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${opName}`);
+      if (fieldMeta.isList)
+        throw new ShapeError(`List field "${fieldName}" cannot be used in ${opName}`);
+      if (isNumericOnly && !NUMERIC_TYPES.has(fieldMeta.type)) {
+        throw new ShapeError(
+          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only numeric types (Int, Float, Decimal, BigInt) are supported.`
+        );
+      }
+      if (isComparableOnly && !COMPARABLE_TYPES.has(fieldMeta.type)) {
+        throw new ShapeError(
+          `Field "${fieldName}" (${fieldMeta.type}) cannot be used in ${opName}. Only comparable types (Int, Float, Decimal, BigInt, String, DateTime) are supported.`
+        );
+      }
+      fieldSchemas[fieldName] = import_zod5.z.literal(true).optional();
+    }
+    const aggFieldKeys = Object.keys(fieldSchemas);
+    return import_zod5.z.object(fieldSchemas).strict().refine(
+      (v) => aggFieldKeys.some((k) => v[k] !== void 0),
+      { message: `${opName} must specify at least one field` }
+    ).optional();
+  }
+  function buildCountFieldSchema(model, config, context) {
+    if (config === true) {
+      return import_zod5.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") {
+        const fieldMeta = modelFields[fieldName];
+        if (!fieldMeta)
+          throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in ${context}`);
+        if (fieldMeta.isRelation)
+          throw new ShapeError(`Relation field "${fieldName}" cannot be used in ${context}`);
+      }
+      fieldSchemas[fieldName] = 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;
+      }
+      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,
+    buildTakeSchema,
+    buildCursorSchema,
+    buildDistinctSchema,
+    buildBySchema,
+    buildHavingSchema,
+    buildAggregateFieldSchema,
+    buildCountFieldSchema,
+    buildCountSelectSchema
+  };
+}
+
+// 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",
+  "where",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip"
+]);
+var KNOWN_COUNT_SELECT_ENTRY_KEYS = /* @__PURE__ */ new Set(["where"]);
+var MAX_PROJECTION_DEPTH = 10;
+function validateNestedKeys(keys, allowed, context) {
+  for (const key of keys) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unknown key "${key}" in ${context}. Allowed: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+function createProjectionBuilder(typeMap, enumMap, deps) {
+  function buildIncludeCountSchema(model, config) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    if (config === true) {
+      return { schema: import_zod6.z.literal(true).optional(), forcedCountWhere: {} };
+    }
+    if (!isPlainObject(config) || !("select" in config)) {
+      throw new ShapeError(
+        `Invalid _count config on model "${model}". Expected true or { select: { ... } }`
+      );
+    }
+    for (const key of Object.keys(config)) {
+      if (key !== "select") {
+        throw new ShapeError(
+          `Unknown key "${key}" in _count config on model "${model}". Only "select" is allowed.`
+        );
+      }
+    }
+    if (!isPlainObject(config.select)) {
+      throw new ShapeError(
+        `Invalid _count.select on model "${model}". Expected a plain object with relation field keys.`
+      );
+    }
+    const selectObj = config.select;
+    if (Object.keys(selectObj).length === 0) {
+      throw new ShapeError(
+        `Empty _count.select on model "${model}". Define at least one relation field.`
+      );
+    }
+    const countSelectFields = {};
+    const forcedCountWhere = {};
+    for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}" in _count.select`);
+      if (!fieldMeta.isRelation)
+        throw new ShapeError(`Field "${fieldName}" is not a relation on model "${model}" in _count.select`);
+      if (!fieldMeta.isList)
+        throw new ShapeError(`Field "${fieldName}" is a to-one relation on model "${model}" in _count.select. Only to-many relations support _count.`);
+      if (fieldConfig === true) {
+        countSelectFields[fieldName] = 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 {
+        throw new ShapeError(
+          `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
+        );
+      }
+    }
+    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" }
+    );
+    return {
+      schema: import_zod6.z.object({ select: selectSchema }).strict().optional(),
+      forcedCountWhere
+    };
+  }
+  function buildIncludeSchema(model, includeConfig, depth) {
+    const currentDepth = depth ?? 0;
+    if (currentDepth > MAX_PROJECTION_DEPTH) {
+      throw new ShapeError(
+        `Include schema for model "${model}" exceeds maximum nesting depth (${MAX_PROJECTION_DEPTH}). Check for circular relation references in the shape.`
+      );
+    }
+    if (Object.keys(includeConfig).length === 0) {
+      throw new ShapeError(
+        `Empty include config on model "${model}". Define at least one relation.`
+      );
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    const forcedTree = {};
+    let topLevelForcedCountWhere = {};
+    for (const [relName, config] of Object.entries(includeConfig)) {
+      if (relName === "_count") {
+        const countResult = buildIncludeCountSchema(model, config);
+        fieldSchemas["_count"] = countResult.schema;
+        topLevelForcedCountWhere = countResult.forcedCountWhere;
+        continue;
+      }
+      const fieldMeta = modelFields[relName];
+      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}"`);
+      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;
+        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 (!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" is 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.where) {
+          const { schema: whereSchema, forced } = deps.buildWhereSchema(
+            fieldMeta.type,
+            config.where
+          );
+          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();
+    return {
+      schema,
+      forcedTree,
+      forcedCountWhere: topLevelForcedCountWhere
+    };
+  }
+  return { buildIncludeSchema, buildSelectSchema, buildIncludeCountSchema };
+}
+
+// src/runtime/query-builder.ts
+var METHOD_ALLOWED_ARGS = {
+  findMany: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findFirst: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findFirstOrThrow: /* @__PURE__ */ new Set(["where", "include", "select", "orderBy", "cursor", "take", "skip", "distinct"]),
+  findUnique: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  findUniqueOrThrow: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  count: /* @__PURE__ */ new Set(["where", "select", "cursor", "orderBy", "skip", "take"]),
+  aggregate: /* @__PURE__ */ new Set(["where", "orderBy", "cursor", "take", "skip", "_count", "_avg", "_sum", "_min", "_max"]),
+  groupBy: /* @__PURE__ */ new Set(["where", "by", "having", "_count", "_avg", "_sum", "_min", "_max", "orderBy", "take", "skip"])
+};
+var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+function createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase) {
+  const whereBuilder = createWhereBuilder(typeMap, enumMap, scalarBase);
+  const argsBuilder = createArgsBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  const projectionBuilder = createProjectionBuilder(typeMap, enumMap, {
+    buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildOrderBySchema: argsBuilder.buildOrderBySchema,
+    buildCursorSchema: argsBuilder.buildCursorSchema,
+    buildTakeSchema: argsBuilder.buildTakeSchema
+  });
+  function isShapeConfig(obj) {
+    if (!isPlainObject(obj))
+      return false;
+    const keys = Object.keys(obj);
+    return keys.length === 0 || keys.every((k) => SHAPE_CONFIG_KEYS.has(k));
+  }
+  function validateShapeArgs(method, shape) {
+    const allowed = METHOD_ALLOWED_ARGS[method];
+    for (const key of Object.keys(shape)) {
+      if (!SHAPE_CONFIG_KEYS.has(key))
+        throw new ShapeError(`Unknown shape config key "${key}"`);
+      if (!allowed.has(key))
+        throw new ShapeError(`Arg "${key}" not allowed for method "${method}"`);
+    }
+    if (UNIQUE_WHERE_METHODS.has(method) && !shape.where) {
+      throw new ShapeError(`${method} shape must define "where"`);
+    }
+    if (shape.include && shape.select) {
+      throw new ShapeError('Shape config cannot define both "include" and "select".');
+    }
+    if (method === "groupBy" && !shape.by)
+      throw new ShapeError('groupBy shape must define "by"');
+    if (method === "groupBy" && (shape.include || shape.select)) {
+      throw new ShapeError('groupBy does not support "include" or "select"');
+    }
+    if (method === "aggregate" && (shape.include || shape.select)) {
+      throw new ShapeError('aggregate does not support "include" or "select"');
+    }
+    if (method === "count" && shape.include)
+      throw new ShapeError('count does not support "include"');
+    if (method === "groupBy" && shape.orderBy) {
+      const bySet = new Set(shape.by);
+      for (const fieldName of Object.keys(shape.orderBy)) {
+        if (!bySet.has(fieldName)) {
+          throw new ShapeError(`orderBy field "${fieldName}" must be included in "by" for groupBy`);
+        }
+      }
+    }
+    if (method === "groupBy" && shape.having) {
+      const bySet = new Set(shape.by);
+      for (const fieldName of Object.keys(shape.having)) {
+        if (!bySet.has(fieldName)) {
+          throw new ShapeError(`having field "${fieldName}" must be included in "by" for groupBy`);
+        }
+      }
+    }
+  }
+  function validateUniqueWhere(model, method, shape) {
+    if (!UNIQUE_WHERE_METHODS.has(method))
+      return;
+    if (!shape.where)
+      return;
+    validateUniqueEquality(model, shape.where, method, uniqueMap, typeMap);
+  }
+  function resolveAndValidateShape(shapeOrFn, ctx) {
+    if (typeof shapeOrFn === "function") {
+      requireContext(ctx, "shape function");
+      const result = shapeOrFn(ctx);
+      if (!isPlainObject(result)) {
+        throw new ShapeError("Dynamic shape function must return a plain object");
+      }
+      return result;
+    }
+    return shapeOrFn;
+  }
+  function buildShapeZodSchema(model, method, shape) {
+    validateShapeArgs(method, shape);
+    validateUniqueWhere(model, method, shape);
+    const schemaFields = {};
+    let forcedWhere = EMPTY_WHERE_FORCED;
+    let forcedIncludeTree = {};
+    let forcedSelectTree = {};
+    let forcedIncludeCountWhere = {};
+    let forcedSelectCountWhere = {};
+    if (shape.where) {
+      const { schema, forced } = whereBuilder.buildWhereSchema(model, shape.where);
+      if (schema)
+        schemaFields["where"] = schema;
+      forcedWhere = forced;
+    }
+    if (shape.include) {
+      const result = projectionBuilder.buildIncludeSchema(model, shape.include);
+      schemaFields["include"] = result.schema;
+      forcedIncludeTree = result.forcedTree;
+      forcedIncludeCountWhere = result.forcedCountWhere;
+    }
+    if (shape.select) {
+      if (method === "count") {
+        schemaFields["select"] = argsBuilder.buildCountSelectSchema(model, shape.select);
+      } else {
+        const result = projectionBuilder.buildSelectSchema(model, shape.select);
+        schemaFields["select"] = result.schema;
+        forcedSelectTree = result.forcedTree;
+        forcedSelectCountWhere = result.forcedCountWhere;
+      }
+    }
+    if (shape.orderBy)
+      schemaFields["orderBy"] = argsBuilder.buildOrderBySchema(model, shape.orderBy);
+    if (shape.cursor)
+      schemaFields["cursor"] = argsBuilder.buildCursorSchema(model, shape.cursor);
+    if (shape.take)
+      schemaFields["take"] = argsBuilder.buildTakeSchema(shape.take);
+    if (shape.skip !== void 0) {
+      if (shape.skip !== true) {
+        throw new ShapeError('Shape config "skip" must be true');
+      }
+      schemaFields["skip"] = import_zod7.z.number().int().min(0).optional();
+    }
+    if (shape.distinct)
+      schemaFields["distinct"] = argsBuilder.buildDistinctSchema(model, shape.distinct);
+    if (shape._count)
+      schemaFields["_count"] = argsBuilder.buildCountFieldSchema(model, shape._count, "_count");
+    if (shape._avg)
+      schemaFields["_avg"] = argsBuilder.buildAggregateFieldSchema(model, "_avg", shape._avg);
+    if (shape._sum)
+      schemaFields["_sum"] = argsBuilder.buildAggregateFieldSchema(model, "_sum", shape._sum);
+    if (shape._min)
+      schemaFields["_min"] = argsBuilder.buildAggregateFieldSchema(model, "_min", shape._min);
+    if (shape._max)
+      schemaFields["_max"] = argsBuilder.buildAggregateFieldSchema(model, "_max", shape._max);
+    if (shape.by)
+      schemaFields["by"] = argsBuilder.buildBySchema(model, shape.by);
+    if (shape.having)
+      schemaFields["having"] = argsBuilder.buildHavingSchema(model, shape.having);
+    return {
+      zodSchema: import_zod7.z.object(schemaFields).strict(),
+      forcedWhere,
+      forcedIncludeTree,
+      forcedSelectTree,
+      forcedIncludeCountWhere,
+      forcedSelectCountWhere
+    };
+  }
+  function matchCaller(shapes, caller) {
+    const matched = matchCallerPattern(Object.keys(shapes), caller);
+    if (!matched)
+      return null;
+    return { key: matched, shape: shapes[matched] };
+  }
+  function buildQuerySchema(model, method, config) {
+    const isSingle = typeof config === "function" || isShapeConfig(config);
+    const builtCache = /* @__PURE__ */ new Map();
+    if (isSingle && typeof config !== "function") {
+      builtCache.set("_default", buildShapeZodSchema(model, method, config));
+    }
+    if (!isSingle) {
+      for (const key of Object.keys(config)) {
+        if (SHAPE_CONFIG_KEYS.has(key)) {
+          throw new ShapeError(`Caller key "${key}" collides with reserved shape config key. Rename the caller path.`);
+        }
+      }
+      for (const [key, shapeOrFn] of Object.entries(config)) {
+        if (typeof shapeOrFn !== "function") {
+          builtCache.set(key, buildShapeZodSchema(model, method, shapeOrFn));
+        }
+      }
+    }
+    const isUnique = UNIQUE_WHERE_METHODS.has(method);
+    return {
+      schemas: Object.fromEntries(
+        [...builtCache.entries()].map(([k, v]) => [k, v.zodSchema])
+      ),
+      parse(body, opts) {
+        const normalizedBody = body === void 0 || body === null ? {} : body;
+        let built;
+        if (isSingle) {
+          if (typeof config === "function") {
+            const resolved = resolveAndValidateShape(config, opts?.ctx);
+            built = buildShapeZodSchema(model, method, resolved);
+          } else {
+            built = builtCache.get("_default");
+          }
+        } else {
+          if (!isPlainObject(normalizedBody))
+            throw new ShapeError("Request body must be an object");
+          if ("caller" in normalizedBody) {
+            throw new CallerError(
+              "Pass caller via opts.caller, not in the request body."
+            );
+          }
+          const caller = opts?.caller;
+          if (typeof caller !== "string") {
+            const allowed = Object.keys(config);
+            throw new CallerError(
+              `Missing caller. This query uses named shape routing with keys: ${allowed.map((k) => `"${k}"`).join(", ")}. Provide caller via opts.caller.`
+            );
+          }
+          const matched = matchCaller(config, caller);
+          if (!matched) {
+            const allowed = Object.keys(config);
+            throw new CallerError(
+              `Unknown caller: "${caller}". Allowed: ${allowed.map((k) => `"${k}"`).join(", ")}`
+            );
+          }
+          if (typeof matched.shape === "function") {
+            const resolved = resolveAndValidateShape(matched.shape, opts?.ctx);
+            built = buildShapeZodSchema(model, method, resolved);
+          } else {
+            built = builtCache.get(matched.key);
+          }
+        }
+        return applyBuiltShape(built, normalizedBody, isUnique);
+      }
+    };
+  }
+  return {
+    buildQuerySchema,
+    buildShapeZodSchema,
+    buildWhereSchema: whereBuilder.buildWhereSchema,
+    buildIncludeSchema: projectionBuilder.buildIncludeSchema,
+    buildSelectSchema: projectionBuilder.buildSelectSchema
+  };
+}
+
+// src/runtime/scope-extension.ts
+var READ_OPS = /* @__PURE__ */ new Set([
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "count"
+]);
+var AGGREGATE_OPS = /* @__PURE__ */ new Set([
+  "aggregate",
+  "groupBy"
+]);
+var FIND_UNIQUE_OPS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow"
+]);
+var CREATE_OPS = /* @__PURE__ */ new Set([
+  "create",
+  "createMany",
+  "createManyAndReturn"
+]);
+var UNIQUE_MUTATION_OPS = /* @__PURE__ */ new Set([
+  "update",
+  "delete"
+]);
+var MULTI_MUTATION_OPS = /* @__PURE__ */ new Set([
+  "updateMany",
+  "updateManyAndReturn",
+  "deleteMany"
+]);
+function buildAndConditions(existingWhere, conditions) {
+  if (existingWhere)
+    return { AND: [existingWhere, ...conditions] };
+  if (conditions.length === 1)
+    return conditions[0];
+  return { AND: conditions };
+}
+function buildScopedUniqueWhere(existingWhere, conditions) {
+  if (!existingWhere) {
+    return conditions.length === 1 ? conditions[0] : { AND: conditions };
+  }
+  const { AND: existingAnd, ...topLevel } = existingWhere;
+  const allConditions = [];
+  if (existingAnd !== void 0) {
+    if (Array.isArray(existingAnd)) {
+      allConditions.push(...existingAnd);
+    } else {
+      allConditions.push(existingAnd);
+    }
+  }
+  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) {
+  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.`
+    );
+  }
+  return eq;
+}
+function buildFkSelect(fks) {
+  const select = {};
+  for (const fk of fks)
+    select[fk] = true;
+  return select;
+}
+function pickMissingFksFromResult(result, fks) {
+  const missing = [];
+  for (const fk of fks) {
+    if (!(fk in result))
+      missing.push(fk);
+  }
+  return missing;
+}
+function validateScopeValue(root, value) {
+  if (typeof value === "string" && value.length === 0) {
+    throw new PolicyError(
+      `Empty string scope value for root "${root}". This is almost certainly a bug in the context function.`
+    );
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new PolicyError(
+      `Invalid numeric scope value for root "${root}": ${value}. This is almost certainly a bug in the context function.`
+    );
+  }
+}
+function enforceDataScope(data, scopes, overrides, log, model, operation, onScopeRelationWrite, mode) {
+  for (const scope of scopes) {
+    if (scope.fk in data) {
+      log.warn(
+        `prisma-guard: Scope FK "${scope.fk}" in ${operation} data for model "${model}" was overridden by scope context.`
+      );
+    }
+    if (scope.relationName in data) {
+      if (onScopeRelationWrite === "error") {
+        throw new ShapeError(
+          `Scope relation "${scope.relationName}" cannot be set directly in ${operation} data for model "${model}". The scope extension manages this relation automatically.`
+        );
+      }
+      if (onScopeRelationWrite === "warn") {
+        log.warn(
+          `prisma-guard: Scope relation "${scope.relationName}" in ${operation} data for model "${model}" was removed by scope context.`
+        );
+      }
+      delete data[scope.relationName];
+    }
+  }
+  if (mode === "create") {
+    Object.assign(data, overrides);
+  } else {
+    for (const scope of scopes) {
+      delete data[scope.fk];
+    }
+  }
+}
+var VALID_FIND_UNIQUE_MODES = /* @__PURE__ */ new Set(["verify", "reject"]);
+var VALID_ON_SCOPE_RELATION_WRITES = /* @__PURE__ */ new Set(["error", "warn", "strip"]);
+function createScopeExtension(scopeMap, contextFn, guardConfig, logger) {
+  const log = logger ?? { warn: (msg) => console.warn(msg) };
+  const findUniqueMode = guardConfig.findUniqueMode ?? "reject";
+  const onScopeRelationWrite = guardConfig.onScopeRelationWrite ?? "error";
+  if (!VALID_FIND_UNIQUE_MODES.has(findUniqueMode)) {
+    throw new ShapeError(
+      `prisma-guard: Invalid findUniqueMode "${findUniqueMode}". Allowed: ${[...VALID_FIND_UNIQUE_MODES].join(", ")}`
+    );
+  }
+  if (!VALID_ON_SCOPE_RELATION_WRITES.has(onScopeRelationWrite)) {
+    throw new ShapeError(
+      `prisma-guard: Invalid onScopeRelationWrite "${onScopeRelationWrite}". Allowed: ${[...VALID_ON_SCOPE_RELATION_WRITES].join(", ")}`
+    );
+  }
+  return {
+    name: "prisma-guard-scope",
+    query: {
+      $allOperations({ model, operation, args, query }) {
+        if (!model || !scopeMap[model])
+          return query(args);
+        const ctx = contextFn();
+        const scopes = scopeMap[model];
+        const presentScopes = scopes.filter((s) => ctx[s.root] != null);
+        for (const s of presentScopes) {
+          validateScopeValue(s.root, ctx[s.root]);
+        }
+        const presentConditions = presentScopes.map((s) => ({ [s.fk]: ctx[s.root] }));
+        const missingRoots = scopes.filter((s) => ctx[s.root] == null).map((s) => s.root);
+        const isMutation = CREATE_OPS.has(operation) || UNIQUE_MUTATION_OPS.has(operation) || MULTI_MUTATION_OPS.has(operation) || operation === "upsert";
+        if (missingRoots.length > 0) {
+          if (isMutation || guardConfig.onMissingScopeContext === "error") {
+            throw new PolicyError(
+              `Missing scope context for model "${model}": roots ${missingRoots.map((r) => `"${r}"`).join(", ")} not provided. All scope roots must be present.`
+            );
+          }
+          if (guardConfig.onMissingScopeContext === "warn") {
+            log.warn(
+              `prisma-guard: Missing scope context for model "${model}": roots ${missingRoots.map((r) => `"${r}"`).join(", ")} not provided. Read proceeding with partial scope.`
+            );
+          }
+          if (presentConditions.length === 0) {
+            return query(args);
+          }
+        }
+        const conditions = presentConditions;
+        const overrides = Object.fromEntries(
+          presentScopes.map((s) => [s.fk, ctx[s.root]])
+        );
+        const nextArgs = { ...args };
+        if (operation === "upsert") {
+          nextArgs.where = buildScopedUniqueWhere(args.where, conditions);
+          if (args.create !== void 0 && args.create !== null) {
+            if (typeof args.create !== "object" || Array.isArray(args.create)) {
+              throw new ShapeError(`upsert expects create to be an object`);
+            }
+            nextArgs.create = { ...args.create };
+            enforceDataScope(nextArgs.create, scopes, overrides, log, model, operation, onScopeRelationWrite, "create");
+          }
+          if (args.update !== void 0 && args.update !== null) {
+            if (typeof args.update !== "object" || Array.isArray(args.update)) {
+              throw new ShapeError(`upsert expects update to be an object`);
+            }
+            nextArgs.update = { ...args.update };
+            enforceDataScope(nextArgs.update, scopes, overrides, log, model, operation, onScopeRelationWrite, "mutate");
+          }
+          return query(nextArgs);
+        }
+        if (FIND_UNIQUE_OPS.has(operation)) {
+          if (findUniqueMode === "reject") {
+            throw new PolicyError(
+              `Scoped model "${model}" does not allow ${operation} via scope extension (findUniqueMode is "reject"). Use findFirst with explicit where conditions instead.`
+            );
+          }
+          return handleFindUnique(args, query, conditions, scopes, operation, log);
+        }
+        if (READ_OPS.has(operation)) {
+          nextArgs.where = buildAndConditions(args.where, conditions);
+          return query(nextArgs);
+        }
+        if (AGGREGATE_OPS.has(operation)) {
+          nextArgs.where = buildAndConditions(args.where, conditions);
+          if (operation === "groupBy" && !nextArgs.by) {
+            throw new ShapeError(
+              `prisma-guard: groupBy on scoped model "${model}" requires "by" argument.`
+            );
+          }
+          return query(nextArgs);
+        }
+        if (CREATE_OPS.has(operation)) {
+          if (args.data === void 0 || args.data === null) {
+            throw new ShapeError(`${operation} expects data`);
+          }
+          if (operation === "createMany" || operation === "createManyAndReturn") {
+            if (!Array.isArray(args.data)) {
+              throw new ShapeError(`${operation} expects data to be an array`);
+            }
+            if (args.data.length === 0) {
+              throw new ShapeError(`${operation} received empty data array`);
+            }
+            nextArgs.data = args.data.map((d) => {
+              const item = { ...d };
+              enforceDataScope(item, scopes, overrides, log, model, operation, onScopeRelationWrite, "create");
+              return item;
+            });
+          } else {
+            if (typeof args.data !== "object" || Array.isArray(args.data)) {
+              throw new ShapeError(`${operation} expects data to be an object`);
+            }
+            nextArgs.data = { ...args.data };
+            enforceDataScope(nextArgs.data, scopes, overrides, log, model, operation, onScopeRelationWrite, "create");
+          }
+          return query(nextArgs);
+        }
+        if (UNIQUE_MUTATION_OPS.has(operation)) {
+          nextArgs.where = buildScopedUniqueWhere(args.where, conditions);
+          if (args.data !== void 0 && args.data !== null) {
+            if (typeof args.data !== "object" || Array.isArray(args.data)) {
+              throw new ShapeError(`${operation} expects data to be an object`);
+            }
+            nextArgs.data = { ...args.data };
+            enforceDataScope(nextArgs.data, scopes, overrides, log, model, operation, onScopeRelationWrite, "mutate");
+          }
+          return query(nextArgs);
+        }
+        if (MULTI_MUTATION_OPS.has(operation)) {
+          nextArgs.where = buildAndConditions(args.where, conditions);
+          if (args.data !== void 0 && args.data !== null) {
+            if (typeof args.data !== "object" || Array.isArray(args.data)) {
+              throw new ShapeError(`${operation} expects data to be an object`);
+            }
+            nextArgs.data = { ...args.data };
+            enforceDataScope(nextArgs.data, scopes, overrides, log, model, operation, onScopeRelationWrite, "mutate");
+          }
+          return query(nextArgs);
+        }
+        throw new ShapeError(
+          `Unknown operation "${operation}" on scoped model "${model}". Update prisma-guard to handle this operation.`
+        );
+      }
+    }
+  };
+}
+async function handleFindUnique(args, query, conditions, scopes, operation, log) {
+  const nextArgs = { ...args };
+  const injectedFks = [];
+  const originalSelect = args?.select;
+  const fks = scopes.map((s) => s.fk);
+  if (originalSelect) {
+    nextArgs.select = { ...originalSelect };
+    for (const fk of fks) {
+      if (!originalSelect[fk]) {
+        nextArgs.select[fk] = true;
+        injectedFks.push(fk);
+      }
+    }
+  }
+  const result = await query(nextArgs);
+  if (result === null)
+    return result;
+  if (typeof result !== "object" || result === null) {
+    throw new ShapeError("findUnique result must be an object or null");
+  }
+  const resultObj = result;
+  let verifyObj = resultObj;
+  const missingFks = pickMissingFksFromResult(resultObj, fks);
+  if (missingFks.length > 0) {
+    const where = args?.where;
+    if (!where || typeof where !== "object" || Array.isArray(where)) {
+      throw new PolicyError(
+        `prisma-guard: Cannot verify scope \u2014 missing FK fields (${missingFks.join(", ")}) and findUnique args.where is not a valid object.`
+      );
+    }
+    let verifyResult;
+    try {
+      verifyResult = await query({ where, select: buildFkSelect(fks) });
+    } catch (err) {
+      throw new PolicyError(
+        `prisma-guard: Scope verification query failed for findUnique: ${err?.message ?? String(err)}`
+      );
+    }
+    if (verifyResult === null) {
+      throw new PolicyError("prisma-guard: Scope verification query returned null for an existing findUnique result");
+    }
+    if (typeof verifyResult !== "object" || verifyResult === null) {
+      throw new PolicyError("prisma-guard: Scope verification result must be an object");
+    }
+    verifyObj = verifyResult;
+  }
+  for (const condition of conditions) {
+    const [fk, value] = Object.entries(condition)[0];
+    if (!(fk in verifyObj)) {
+      throw new PolicyError(
+        `prisma-guard: Cannot verify scope on "${fk}" \u2014 field not present in verification result. Ensure FK fields are selectable.`
+      );
+    }
+    if (!looseEqual(verifyObj[fk], value, log, fk)) {
+      if (operation === "findUniqueOrThrow") {
+        throw new PolicyError("Record not accessible in current scope");
+      }
+      return null;
+    }
+  }
+  if (injectedFks.length > 0) {
+    const cleaned = { ...resultObj };
+    for (const fk of injectedFks) {
+      delete cleaned[fk];
+    }
+    return cleaned;
+  }
+  return result;
+}
+
+// src/runtime/model-guard.ts
+var import_zod9 = require("zod");
+
+// 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"]);
+function validateMutationBodyKeys(body, allowed, method) {
+  for (const key of Object.keys(body)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+function validateMutationShapeKeys(shape, allowed, method) {
+  for (const key of Object.keys(shape)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Shape key "${key}" not valid for ${method}. Allowed: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+function validateCreateCompleteness(modelName, dataConfig, typeMap, scopeFks, zodDefaults) {
+  const modelFields = typeMap[modelName];
+  if (!modelFields)
+    return;
+  const zodDefaultFields = zodDefaults[modelName];
+  const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
+  for (const [fieldName, meta] of Object.entries(modelFields)) {
+    if (meta.isRelation)
+      continue;
+    if (meta.isUpdatedAt)
+      continue;
+    if (meta.hasDefault)
+      continue;
+    if (!meta.isRequired)
+      continue;
+    if (fieldName in dataConfig)
+      continue;
+    if (scopeFks.has(fieldName))
+      continue;
+    if (zodDefaultSet && zodDefaultSet.has(fieldName))
+      continue;
+    throw new ShapeError(
+      `Required field "${fieldName}" on model "${modelName}" is missing from create data shape, has no default, and is not a scope FK`
+    );
+  }
+}
+function buildDataSchema(model, dataConfig, mode, typeMap, schemaBuilder, zodDefaults) {
+  const modelFields = typeMap[model];
+  if (!modelFields)
+    throw new ShapeError(`Unknown model: ${model}`);
+  const zodDefaultFields = zodDefaults[model];
+  const zodDefaultSet = zodDefaultFields ? new Set(zodDefaultFields) : void 0;
+  const schemaMap = {};
+  const forced = {};
+  for (const [fieldName, value] of Object.entries(dataConfig)) {
+    const fieldMeta = modelFields[fieldName];
+    if (!fieldMeta)
+      throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+    if (fieldMeta.isRelation)
+      throw new ShapeError(`Relation field "${fieldName}" cannot be used in data shape`);
+    if (fieldMeta.isUpdatedAt)
+      throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in data shape`);
+    if (typeof value === "function") {
+      let baseSchema = schemaBuilder.buildBaseFieldSchema(model, fieldName);
+      let refined;
+      try {
+        refined = value(baseSchema);
+      } catch (err) {
+        throw new ShapeError(
+          `Invalid inline refine for "${model}.${fieldName}": ${err.message}`,
+          { cause: err }
+        );
+      }
+      if (!isZodSchema(refined)) {
+        throw new ShapeError(`Inline refine for "${model}.${fieldName}" must return a Zod schema`);
+      }
+      let fieldSchema = refined;
+      const handlesUndefined = schemaProducesValueForUndefined(fieldSchema);
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = handlesUndefined ? fieldSchema.nullable() : fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          if (!handlesUndefined) {
+            fieldSchema = fieldSchema.optional();
+          }
+        }
+      } else {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else {
+          fieldSchema = fieldSchema.optional();
+        }
+      }
+      schemaMap[fieldName] = fieldSchema;
+    } else if (value === true) {
+      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      const isZodDefaultField = zodDefaultSet !== void 0 && zodDefaultSet.has(fieldName);
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = isZodDefaultField ? fieldSchema.nullable() : fieldSchema.nullable().optional();
+        } else if (fieldMeta.hasDefault) {
+          if (!isZodDefaultField) {
+            fieldSchema = fieldSchema.optional();
+          }
+        }
+      } else {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else {
+          fieldSchema = fieldSchema.optional();
+        }
+      }
+      schemaMap[fieldName] = fieldSchema;
+    } else {
+      const actualValue = isForcedValue(value) ? value.value : value;
+      let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      if (!fieldMeta.isRequired) {
+        fieldSchema = fieldSchema.nullable();
+      }
+      let parsed;
+      try {
+        parsed = fieldSchema.parse(actualValue);
+      } catch (err) {
+        throw new ShapeError(
+          `Invalid forced data value for "${model}.${fieldName}": ${err.message}`
+        );
+      }
+      forced[fieldName] = parsed;
+    }
+  }
+  if (mode === "create" && zodDefaultFields) {
+    for (const fieldName of zodDefaultFields) {
+      if (fieldName in dataConfig)
+        continue;
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        continue;
+      if (fieldMeta.isRelation)
+        continue;
+      if (fieldMeta.isUpdatedAt)
+        continue;
+      const fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+      const result = fieldSchema.safeParse(void 0);
+      if (result.success && result.data !== void 0) {
+        forced[fieldName] = result.data;
+      } else {
+        throw new ShapeError(
+          `Field "${fieldName}" on model "${model}" has @zod default/catch but its schema does not produce a value for undefined input`
+        );
+      }
+    }
+  }
+  return {
+    schema: import_zod8.z.object(schemaMap).strict(),
+    forced
+  };
+}
+function validateAndMergeData(bodyData, cached, method) {
+  if (bodyData === void 0 || bodyData === null) {
+    throw new ShapeError(`${method} requires "data" in request body`);
+  }
+  const validated = cached.schema.parse(bodyData);
+  return { ...validated, ...deepClone(cached.forced) };
+}
+function hasDataRefines(dataConfig) {
+  for (const value of Object.values(dataConfig)) {
+    if (typeof value === "function")
+      return true;
+  }
+  return false;
+}
+
+// src/runtime/model-guard-resolve.ts
+function isGuardShape(obj) {
+  if (!isPlainObject(obj))
+    return false;
+  const keys = Object.keys(obj);
+  return keys.length === 0 || keys.every((k) => GUARD_SHAPE_KEYS.has(k));
+}
+function isSingleShape(input) {
+  return typeof input === "function" || isGuardShape(input);
+}
+function requireBody(body) {
+  if (!isPlainObject(body))
+    throw new ShapeError("Request body must be an object");
+  return body;
+}
+function resolveDynamicShape(fn, contextFn) {
+  const ctx = validateContext(contextFn());
+  let result;
+  try {
+    result = fn(ctx);
+  } catch (err) {
+    throw new ShapeError(
+      `Dynamic shape function threw: ${err.message}`,
+      { cause: err }
+    );
+  }
+  if (!isPlainObject(result)) {
+    throw new ShapeError("Dynamic shape function must return a plain object");
+  }
+  return result;
+}
+function resolveShape(input, body, contextFn, caller) {
+  if (isSingleShape(input)) {
+    const wasDynamic2 = typeof input === "function";
+    const shape2 = wasDynamic2 ? resolveDynamicShape(input, contextFn) : input;
+    const parsed2 = body === void 0 || body === null ? {} : requireBody(body);
+    return { shape: shape2, body: parsed2, matchedKey: "_default", wasDynamic: wasDynamic2 };
+  }
+  const namedMap = input;
+  for (const key of Object.keys(namedMap)) {
+    if (GUARD_SHAPE_KEYS.has(key)) {
+      throw new ShapeError(
+        `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
+      );
+    }
+    const val = namedMap[key];
+    if (typeof val !== "function" && !isGuardShape(val)) {
+      throw new ShapeError(
+        `Named shape value for "${key}" must be a guard shape object or function`
+      );
+    }
+  }
+  const 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") {
+    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.`
+    );
+  }
+  const patterns = Object.keys(namedMap);
+  const matched = matchCallerPattern(patterns, caller);
+  if (!matched) {
+    throw new CallerError(
+      `Unknown caller: "${caller}". Allowed: ${patterns.map((k) => `"${k}"`).join(", ")}`
+    );
+  }
+  const shapeOrFn = namedMap[matched];
+  const wasDynamic = typeof shapeOrFn === "function";
+  const shape = wasDynamic ? resolveDynamicShape(shapeOrFn, contextFn) : shapeOrFn;
+  return { shape, body: parsed, matchedKey: matched, wasDynamic };
+}
+
+// src/runtime/model-guard.ts
+var UNIQUE_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete", "upsert"]);
+var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "updateMany",
+  "updateManyAndReturn",
+  "deleteMany"
+]);
+var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "upsert",
+  "delete",
+  "createManyAndReturn",
+  "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);
+      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 hasClientControlledValues(obj) {
+  for (const value of Object.values(obj)) {
+    if (isForcedValue(value))
+      continue;
+    if (value === true)
+      return true;
+    if (isPlainObject(value) && hasClientControlledValues(value))
+      return true;
+  }
+  return false;
+}
+function checkIncludeForClientArgs(config) {
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      if (value !== true && isPlainObject(value) && isPlainObject(value.select)) {
+        const selectObj = value.select;
+        for (const entryVal of Object.values(selectObj)) {
+          if (isPlainObject(entryVal) && entryVal.where) {
+            const w = entryVal.where;
+            if (isPlainObject(w) && hasClientControlledValues(w))
+              return true;
+          }
+        }
+      }
+      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))
+      return true;
+    if (value.include && checkIncludeForClientArgs(value.include))
+      return true;
+    if (value.select && checkSelectForClientArgs(value.select))
+      return true;
+  }
+  return false;
+}
+function checkSelectForClientArgs(config) {
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "_count") {
+      if (value !== true && isPlainObject(value) && isPlainObject(value.select)) {
+        const selectObj = value.select;
+        for (const entryVal of Object.values(selectObj)) {
+          if (isPlainObject(entryVal) && entryVal.where) {
+            const w = entryVal.where;
+            if (isPlainObject(w) && hasClientControlledValues(w))
+              return true;
+          }
+        }
+      }
+      continue;
+    }
+    if (value === true)
+      continue;
+    if (value.orderBy || value.cursor || value.take || value.skip)
+      return true;
+    if (value.where && isPlainObject(value.where) && hasClientControlledValues(value.where))
+      return true;
+    if (value.select && checkSelectForClientArgs(value.select))
+      return true;
+  }
+  return false;
+}
+function hasNestedClientControlledArgs(shape) {
+  if (shape.include) {
+    if (checkIncludeForClientArgs(shape.include))
+      return true;
+  }
+  if (shape.select) {
+    if (checkSelectForClientArgs(shape.select))
+      return true;
+  }
+  return false;
+}
+function createModelGuardExtension(config) {
+  const { typeMap, enumMap, zodChains, zodDefaults, uniqueMap, scopeMap, guardConfig, contextFn } = config;
+  const wrapZodErrors = config.wrapZodErrors ?? false;
+  const enforceProjection = guardConfig.enforceProjection ?? false;
+  const scalarBase = createScalarBase(guardConfig.strictDecimal ?? false);
+  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap, scalarBase, zodDefaults);
+  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap, scalarBase);
+  const modelScopeFks = /* @__PURE__ */ new Map();
+  for (const [model, entries] of Object.entries(scopeMap)) {
+    const fks = /* @__PURE__ */ new Set();
+    for (const entry of entries)
+      fks.add(entry.fk);
+    modelScopeFks.set(model, fks);
+  }
+  function maybeValidateUniqueWhere(modelName, shape, method) {
+    if (!UNIQUE_MUTATION_METHODS.has(method))
+      return;
+    if (!shape.where)
+      return;
+    validateUniqueEquality(modelName, shape.where, method, uniqueMap, typeMap);
+  }
+  function createGuardedMethods(modelName, modelDelegate, input, explicitCaller) {
+    function callDelegate(method, args) {
+      if (typeof modelDelegate[method] !== "function") {
+        throw new ShapeError(`Method "${method}" is not available on this model`);
+      }
+      return modelDelegate[method](args);
+    }
+    function resolveCaller() {
+      if (explicitCaller !== void 0)
+        return explicitCaller;
+      const ctx = validateContext(contextFn());
+      const c = ctx.caller;
+      if (typeof c === "string")
+        return c;
+      return void 0;
+    }
+    const readShapeCache = /* @__PURE__ */ new Map();
+    const dataSchemaCache = /* @__PURE__ */ new Map();
+    const whereBuiltCache = /* @__PURE__ */ new Map();
+    const projectionCache = /* @__PURE__ */ new Map();
+    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(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(modelName, dataConfig, mode, typeMap, 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);
+    }
+    function buildProjectionSchema(shape) {
+      if (shape.select && shape.include) {
+        throw new ShapeError('Shape cannot define both "select" and "include"');
+      }
+      const schemaFields = {};
+      let forcedIncludeTree = {};
+      let forcedSelectTree = {};
+      let forcedIncludeCountWhere = {};
+      let forcedSelectCountWhere = {};
+      if (shape.include) {
+        const result = queryBuilder.buildIncludeSchema(
+          modelName,
+          shape.include
+        );
+        schemaFields["include"] = result.schema;
+        forcedIncludeTree = result.forcedTree;
+        forcedIncludeCountWhere = result.forcedCountWhere;
+      }
+      if (shape.select) {
+        const result = queryBuilder.buildSelectSchema(
+          modelName,
+          shape.select
+        );
+        schemaFields["select"] = result.schema;
+        forcedSelectTree = result.forcedTree;
+        forcedSelectCountWhere = result.forcedCountWhere;
+      }
+      return {
+        zodSchema: import_zod9.z.object(schemaFields).strict(),
+        forcedIncludeTree,
+        forcedSelectTree,
+        forcedIncludeCountWhere,
+        forcedSelectCountWhere
+      };
+    }
+    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);
+    }
+    function resolveProjection(shape, parsed, method, matchedKey, wasDynamic) {
+      const hasBodyProjection = "select" in parsed || "include" in parsed;
+      const hasShapeProjection = !!shape.select || !!shape.include;
+      if (hasBodyProjection && !hasShapeProjection) {
+        throw new ShapeError(
+          `Guard shape does not define "select" or "include" for ${method} return projection`
+        );
+      }
+      if (!hasShapeProjection)
+        return {};
+      if (!hasBodyProjection && !enforceProjection)
+        return {};
+      if (!hasBodyProjection && enforceProjection) {
+        if (hasNestedClientControlledArgs(shape)) {
+          throw new ShapeError(
+            `Guard shape defines nested client-controlled projection args (orderBy/take/cursor/skip/where) but the client did not provide select/include in the ${method} body. With enforceProjection enabled, either always provide projection in the body or remove client-controlled nested args from the shape.`
+          );
+        }
+      }
+      const projection = getProjection(shape, matchedKey, wasDynamic);
+      let projectionBody;
+      if (hasBodyProjection) {
+        projectionBody = {};
+        if ("select" in parsed)
+          projectionBody.select = parsed.select;
+        if ("include" in parsed)
+          projectionBody.include = parsed.include;
+      } else {
+        projectionBody = buildDefaultProjectionBody(shape);
+      }
+      const validated = projection.zodSchema.parse(projectionBody);
+      if (Object.keys(projection.forcedIncludeTree).length > 0) {
+        applyForcedTree(validated, "include", projection.forcedIncludeTree);
+      }
+      if (Object.keys(projection.forcedSelectTree).length > 0) {
+        applyForcedTree(validated, "select", projection.forcedSelectTree);
+      }
+      if (Object.keys(projection.forcedIncludeCountWhere).length > 0) {
+        const ic = validated.include;
+        if (ic)
+          applyForcedCountWhere(ic, projection.forcedIncludeCountWhere);
+      }
+      if (Object.keys(projection.forcedSelectCountWhere).length > 0) {
+        const sc = validated.select;
+        if (sc)
+          applyForcedCountWhere(sc, projection.forcedSelectCountWhere);
+      }
+      return validated;
+    }
+    function buildWhereFromShape(shape, bodyWhere, preserveUnique, matchedKey, wasDynamic) {
+      if (!shape.where) {
+        if (bodyWhere !== void 0) {
+          throw new ShapeError('Guard shape does not allow "where"');
+        }
+        return {};
+      }
+      const built = getWhereBuilt(shape.where, matchedKey, wasDynamic);
+      let validatedWhere;
+      if (built.schema) {
+        validatedWhere = built.schema.parse(bodyWhere);
+      } else if (bodyWhere !== void 0) {
+        if (bodyWhere === null || !isPlainObject(bodyWhere) || Object.keys(bodyWhere).length > 0) {
+          throw new ShapeError(
+            "Guard shape where contains only forced conditions. Client where input is not accepted."
+          );
+        }
+      }
+      if (hasWhereForced(built.forced)) {
+        return preserveUnique ? mergeUniqueWhereForced(validatedWhere, built.forced) : mergeWhereForced(validatedWhere, built.forced);
+      }
+      return validatedWhere ?? {};
+    }
+    function requireWhere(shape, bodyWhere, method, preserveUnique, matchedKey, wasDynamic) {
+      const where = buildWhereFromShape(shape, bodyWhere, preserveUnique, matchedKey, wasDynamic);
+      if (Object.keys(where).length === 0) {
+        throw new ShapeError(`${method} requires a where condition`);
+      }
+      return where;
+    }
+    function makeReadMethod(method) {
+      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}`);
+        }
+        const { data: _, ...queryShape } = resolved.shape;
+        const built = getReadShape(method, queryShape, resolved.matchedKey, resolved.wasDynamic);
+        const isUnique = UNIQUE_READ_METHODS.has(method);
+        const args = applyBuiltShape(built, resolved.body, isUnique);
+        if (isUnique && args.where) {
+          validateResolvedUniqueWhere(
+            modelName,
+            args.where,
+            method,
+            uniqueMap
+          );
+        }
+        return callDelegate(method, args);
+      };
+    }
+    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;
+      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(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
+        validateCreateCompleteness(modelName, resolved.shape.data, typeMap, fks, zodDefaults);
+        const dataSchema = getDataSchema("create", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
+        let args;
+        if (method === "create") {
+          const data = validateAndMergeData(resolved.body.data, dataSchema, method);
+          args = { data };
+        } else {
+          if (!Array.isArray(resolved.body.data))
+            throw new ShapeError(`${method} expects data to be an array`);
+          if (resolved.body.data.length === 0)
+            throw new ShapeError(`${method} received empty data array`);
+          const data = resolved.body.data.map(
+            (item) => validateAndMergeData(item, dataSchema, method)
+          );
+          args = { data };
+        }
+        if (isBatch && resolved.body.skipDuplicates !== void 0) {
+          if (typeof resolved.body.skipDuplicates !== "boolean") {
+            throw new ShapeError(`${method} skipDuplicates must be a boolean`);
+          }
+          args.skipDuplicates = resolved.body.skipDuplicates;
+        }
+        if (supportsProjection) {
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          Object.assign(args, projectionArgs);
+        }
+        return callDelegate(method, args);
+      };
+    }
+    function makeUpdateMethod(method) {
+      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;
+      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(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        if (isBulk && !resolved.shape.where) {
+          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+        }
+        maybeValidateUniqueWhere(modelName, resolved.shape, method);
+        const dataSchema = getDataSchema("update", resolved.shape.data, resolved.matchedKey, resolved.wasDynamic);
+        const data = validateAndMergeData(resolved.body.data, dataSchema, method);
+        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
+        if (isBulk && Object.keys(where).length === 0) {
+          throw new ShapeError(`${method} requires at least one where condition`);
+        }
+        if (isUniqueWhere) {
+          validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
+        }
+        const args = { data, where };
+        if (supportsProjection) {
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          Object.assign(args, projectionArgs);
+        }
+        return callDelegate(method, args);
+      };
+    }
+    function makeDeleteMethod(method) {
+      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;
+      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(resolved.shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(resolved.body, allowedBodyKeys, method);
+        if (isBulk && !resolved.shape.where) {
+          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+        }
+        maybeValidateUniqueWhere(modelName, resolved.shape, method);
+        const where = isUniqueWhere ? requireWhere(resolved.shape, resolved.body.where, method, true, resolved.matchedKey, resolved.wasDynamic) : buildWhereFromShape(resolved.shape, resolved.body.where, false, resolved.matchedKey, resolved.wasDynamic);
+        if (isBulk && Object.keys(where).length === 0) {
+          throw new ShapeError(`${method} requires at least one where condition`);
+        }
+        if (isUniqueWhere) {
+          validateResolvedUniqueWhere(modelName, where, method, uniqueMap);
+        }
+        const args = { where };
+        if (supportsProjection) {
+          const projectionArgs = resolveProjection(resolved.shape, resolved.body, method, resolved.matchedKey, resolved.wasDynamic);
+          Object.assign(args, projectionArgs);
+        }
+        return callDelegate(method, args);
+      };
+    }
+    function makeUpsertMethod() {
+      return (body) => {
+        const caller = resolveCaller();
+        const resolved = resolveShape(input, body, contextFn, caller);
+        if (resolved.shape.data) {
+          throw new ShapeError('Guard shape "data" is not valid for upsert. Use "create" and "update" instead.');
+        }
+        if (!resolved.shape.create) {
+          throw new ShapeError('Guard shape requires "create" for upsert');
+        }
+        if (!resolved.shape.update) {
+          throw new ShapeError('Guard shape requires "update" for upsert');
+        }
+        if (!resolved.shape.where) {
+          throw new ShapeError('Guard shape requires "where" for upsert');
+        }
+        validateMutationShapeKeys(
+          resolved.shape,
+          VALID_SHAPE_KEYS_UPSERT,
+          "upsert"
+        );
+        validateMutationBodyKeys(resolved.body, ALLOWED_BODY_KEYS_UPSERT, "upsert");
+        maybeValidateUniqueWhere(modelName, resolved.shape, "upsert");
+        const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
+        validateCreateCompleteness(modelName, resolved.shape.create, typeMap, fks, zodDefaults);
+        const createDataSchema = getDataSchema(
+          "create",
+          resolved.shape.create,
+          `upsert:create\0${resolved.matchedKey}`,
+          resolved.wasDynamic
+        );
+        const createData = validateAndMergeData(resolved.body.create, createDataSchema, "upsert (create)");
+        const updateDataSchema = getDataSchema(
+          "update",
+          resolved.shape.update,
+          `upsert:update\0${resolved.matchedKey}`,
+          resolved.wasDynamic
+        );
+        const updateData = validateAndMergeData(resolved.body.update, updateDataSchema, "upsert (update)");
+        const where = requireWhere(
+          resolved.shape,
+          resolved.body.where,
+          "upsert",
+          true,
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
+        validateResolvedUniqueWhere(modelName, where, "upsert", uniqueMap);
+        const args = {
+          where,
+          create: createData,
+          update: updateData
+        };
+        const projectionArgs = resolveProjection(
+          resolved.shape,
+          resolved.body,
+          "upsert",
+          resolved.matchedKey,
+          resolved.wasDynamic
+        );
+        Object.assign(args, projectionArgs);
+        return callDelegate("upsert", args);
+      };
+    }
+    return {
+      findMany: makeReadMethod("findMany"),
+      findFirst: makeReadMethod("findFirst"),
+      findFirstOrThrow: makeReadMethod("findFirstOrThrow"),
+      findUnique: makeReadMethod("findUnique"),
+      findUniqueOrThrow: makeReadMethod("findUniqueOrThrow"),
+      count: makeReadMethod("count"),
+      aggregate: makeReadMethod("aggregate"),
+      groupBy: makeReadMethod("groupBy"),
+      create: makeCreateMethod("create"),
+      createMany: makeCreateMethod("createMany"),
+      createManyAndReturn: makeCreateMethod("createManyAndReturn"),
+      update: makeUpdateMethod("update"),
+      updateMany: makeUpdateMethod("updateMany"),
+      updateManyAndReturn: makeUpdateMethod("updateManyAndReturn"),
+      upsert: makeUpsertMethod(),
+      delete: makeDeleteMethod("delete"),
+      deleteMany: makeDeleteMethod("deleteMany")
+    };
+  }
+  function wrapMethods(methods) {
+    const wrapped = {};
+    for (const [key, fn] of Object.entries(methods)) {
+      wrapped[key] = (body) => {
+        try {
+          return fn(body);
+        } catch (err) {
+          if (err instanceof import_zod9.z.ZodError) {
+            throw new ShapeError(
+              `Validation failed: ${formatZodError(err)}`,
+              { cause: err }
+            );
+          }
+          throw err;
+        }
+      };
+    }
+    return wrapped;
+  }
+  return {
+    $allModels: {
+      guard(input, caller) {
+        const modelName = this.$name;
+        const delegateKey = toDelegateKey(modelName);
+        const modelDelegate = this.$parent[delegateKey];
+        if (!modelDelegate) {
+          throw new ShapeError(
+            `Could not resolve Prisma delegate for model "${modelName}" (key: "${delegateKey}")`
+          );
+        }
+        const methods = createGuardedMethods(modelName, modelDelegate, input, caller);
+        if (!wrapZodErrors)
+          return methods;
+        return wrapMethods(methods);
+      }
+    }
+  };
+}
+
+// src/runtime/guard.ts
+function createGuard(config) {
+  const scalarBase = createScalarBase(config.guardConfig.strictDecimal ?? false);
+  const schemaBuilder = createSchemaBuilder(
+    config.typeMap,
+    config.zodChains,
+    config.enumMap,
+    scalarBase,
+    config.zodDefaults ?? {}
+  );
+  const queryBuilder = createQueryBuilder(
+    config.typeMap,
+    config.enumMap,
+    config.uniqueMap ?? {},
+    scalarBase
+  );
+  const log = config.logger ?? { 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);
+      if (!wrapZodErrors)
+        return result;
+      return {
+        schema: result.schema,
+        parse(data) {
+          try {
+            return result.parse(data);
+          } catch (err) {
+            rethrowZod(err);
+          }
+        }
+      };
+    },
+    model: (model, opts) => schemaBuilder.buildModelSchema(model, opts),
+    query: (model, method, config_) => {
+      const qs = queryBuilder.buildQuerySchema(model, method, config_);
+      if (!wrapZodErrors)
+        return qs;
+      return {
+        schemas: qs.schemas,
+        parse(body, opts) {
+          try {
+            return qs.parse(body, opts);
+          } catch (err) {
+            rethrowZod(err);
+          }
+        }
+      };
+    },
+    extension: (contextFn) => {
+      const scopeRoots = /* @__PURE__ */ new Set();
+      for (const entries of Object.values(config.scopeMap)) {
+        for (const entry of entries) {
+          scopeRoots.add(entry.root);
+        }
+      }
+      const scopeCtxFn = () => {
+        const ctx = validateContext(contextFn());
+        const scopeCtx = {};
+        for (const key of Object.keys(ctx)) {
+          if (!scopeRoots.has(key))
+            continue;
+          const val = ctx[key];
+          if (typeof val === "string" || typeof val === "number" || typeof val === "bigint") {
+            scopeCtx[key] = val;
+          } else if (val !== null && val !== void 0) {
+            throw new PolicyError(
+              `prisma-guard: Scope root "${key}" has non-primitive value (${typeof val}). Only string, number, and bigint values are accepted for scope context.`
+            );
+          }
+        }
+        return scopeCtx;
+      };
+      const scopeExt = createScopeExtension(
+        config.scopeMap,
+        scopeCtxFn,
+        config.guardConfig,
+        config.logger
+      );
+      const modelGuardExt = createModelGuardExtension({
+        typeMap: config.typeMap,
+        enumMap: config.enumMap,
+        zodChains: config.zodChains,
+        zodDefaults: config.zodDefaults ?? {},
+        uniqueMap: config.uniqueMap ?? {},
+        scopeMap: config.scopeMap,
+        guardConfig: config.guardConfig,
+        contextFn,
+        wrapZodErrors
+      });
+      return {
+        name: "prisma-guard",
+        model: modelGuardExt,
+        query: scopeExt.query
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallerError,
+  PolicyError,
+  ShapeError,
+  createGuard,
+  force
+});
+//# sourceMappingURL=index.cjs.map