prisma-guard 1.1.0

package/dist/runtime/index.js

@@ -0,0 +1,2677 @@
+// src/runtime/guard.ts
+import { ZodError } from "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";
+  }
+};
+
+// src/runtime/schema-builder.ts
+import { z as z3 } from "zod";
+
+// src/runtime/zod-type-map.ts
+import { z as z2 } from "zod";
+
+// src/shared/scalar-base.ts
+import { z } from "zod";
+function isJsonSafe(value) {
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    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 (Array.isArray(current)) {
+          for (let i = 0; i < current.length; i++) {
+            stack.push(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(values[i]);
+        }
+        continue;
+      }
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+var SCALAR_BASE = {
+  String: () => z.string(),
+  Int: () => z.number().int(),
+  Float: () => z.number(),
+  Decimal: () => z.union([
+    z.number(),
+    z.string().refine(
+      (s) => /^-?(\d+\.?\d*|\.\d+)([eE]-?\d+)?$/.test(s),
+      "Invalid decimal string"
+    )
+  ]),
+  BigInt: () => z.union([
+    z.bigint(),
+    z.number().int().refine(
+      (v) => v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER,
+      "Number exceeds safe integer range for BigInt conversion"
+    ).transform((v) => BigInt(v)),
+    z.string().regex(/^-?\d+$/).transform((v) => BigInt(v))
+  ]),
+  Boolean: () => z.boolean(),
+  DateTime: () => z.union([
+    z.date(),
+    z.string().datetime({ offset: true }),
+    z.string().datetime()
+  ]).pipe(z.coerce.date()),
+  Json: () => z.unknown().refine(isJsonSafe, "Value must be JSON-serializable (no undefined, functions, symbols, class instances, NaN, or Infinity)"),
+  Bytes: () => z.union([
+    z.string(),
+    z.custom((v) => v instanceof Uint8Array)
+  ])
+};
+
+// src/runtime/zod-type-map.ts
+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) {
+  let base;
+  if (fieldMeta.isEnum) {
+    const values = enumMap[fieldMeta.type];
+    if (!values || values.length === 0) {
+      throw new ShapeError(`Unknown enum: ${fieldMeta.type}`);
+    }
+    base = z2.enum(values);
+  } else {
+    const factory = SCALAR_BASE[fieldMeta.type];
+    if (!factory) {
+      throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
+    }
+    base = factory();
+  }
+  if (fieldMeta.isList) {
+    base = z2.array(base);
+  }
+  return base;
+}
+function createScalarListOperatorSchema(fieldMeta, operator, enumMap) {
+  if (!SCALAR_LIST_OPERATORS.has(operator)) {
+    throw new ShapeError(`Operator "${operator}" not supported for scalar list fields`);
+  }
+  if (operator === "isEmpty") {
+    return z2.boolean();
+  }
+  if (operator === "equals") {
+    const itemMeta2 = { ...fieldMeta, isList: false };
+    const itemBase2 = createBaseType(itemMeta2, enumMap);
+    return fieldMeta.isRequired ? z2.array(itemBase2) : z2.union([z2.array(itemBase2), z2.null()]);
+  }
+  const itemMeta = { ...fieldMeta, isList: false };
+  const itemBase = createBaseType(itemMeta, enumMap);
+  if (operator === "has") {
+    return !fieldMeta.isRequired ? z2.union([itemBase, z2.null()]) : itemBase;
+  }
+  return z2.array(itemBase);
+}
+function createOperatorSchema(fieldMeta, operator, enumMap) {
+  if (fieldMeta.isList) {
+    return createScalarListOperatorSchema(fieldMeta, operator, enumMap);
+  }
+  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 = z2.enum(values);
+    if (operator === "equals" || operator === "not") {
+      return !fieldMeta.isRequired ? z2.union([enumSchema, z2.null()]) : enumSchema;
+    }
+    if (!fieldMeta.isRequired) {
+      return z2.array(z2.union([enumSchema, z2.null()]));
+    }
+    return z2.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 = SCALAR_BASE[fieldMeta.type];
+  if (!factory) {
+    throw new ShapeError(`Unknown scalar type: ${fieldMeta.type}`);
+  }
+  const scalar = factory();
+  if (operator === "equals" || operator === "not") {
+    return !fieldMeta.isRequired ? z2.union([scalar, z2.null()]) : scalar;
+  }
+  if (operator === "in" || operator === "notIn") {
+    if (!fieldMeta.isRequired) {
+      return z2.array(z2.union([scalar, z2.null()]));
+    }
+    return z2.array(scalar);
+  }
+  return scalar;
+}
+
+// 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) {
+  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);
+    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);
+  }
+  function buildInputSchema(model, opts) {
+    if (opts.pick && opts.omit) {
+      throw new ShapeError('InputOpts cannot define both "pick" and "omit"');
+    }
+    const mode = opts.mode ?? "create";
+    const allowNull = opts.allowNull ?? false;
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    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;
+      if (opts.refine?.[name]) {
+        fieldSchema = opts.refine[name](buildBaseFieldSchema(model, name));
+      } else {
+        fieldSchema = buildFieldSchema(model, name);
+      }
+      if (mode === "create") {
+        if (!fieldMeta.isRequired) {
+          fieldSchema = allowNull ? fieldSchema.nullable().optional() : fieldSchema.optional();
+        } else if (fieldMeta.hasDefault) {
+          fieldSchema = fieldSchema.optional();
+        }
+      } else {
+        if (!fieldMeta.isRequired && allowNull) {
+          fieldSchema = fieldSchema.nullable().optional();
+        } else {
+          fieldSchema = fieldSchema.optional();
+        }
+      }
+      schemaMap[name] = fieldSchema;
+    }
+    let schema = z3.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);
+      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 = z3.array(relSchema);
+      } else if (!fieldMeta.isRequired) {
+        relSchema = relSchema.nullable();
+      }
+      schemaMap[relName] = relSchema;
+    }
+    if (opts._count) {
+      const relationNames = Object.keys(modelFields).filter((n) => modelFields[n].isRelation);
+      if (opts._count === true) {
+        const countFields = {};
+        for (const relName of relationNames) {
+          countFields[relName] = z3.number().int().min(0);
+        }
+        schemaMap["_count"] = z3.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`);
+          countFields[relName] = z3.number().int().min(0);
+        }
+        schemaMap["_count"] = z3.object(countFields);
+      }
+    }
+    let schema = z3.object(schemaMap);
+    if (opts.strict) {
+      schema = schema.strict();
+    }
+    return schema;
+  }
+  return { buildFieldSchema, buildBaseFieldSchema, buildInputSchema, buildModelSchema };
+}
+
+// src/runtime/query-builder.ts
+import { z as z4 } from "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",
+  ...SHAPE_CONFIG_KEYS
+]);
+
+// 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}`);
+  }
+}
+
+// src/runtime/query-builder.ts
+var METHOD_ALLOWED_ARGS = {
+  findMany: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
+  findFirst: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
+  findFirstOrThrow: /* @__PURE__ */ new Set([
+    "where",
+    "include",
+    "select",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "distinct"
+  ]),
+  findUnique: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  findUniqueOrThrow: /* @__PURE__ */ new Set(["where", "include", "select"]),
+  count: /* @__PURE__ */ new Set(["where", "select", "cursor", "orderBy", "skip", "take"]),
+  aggregate: /* @__PURE__ */ new Set([
+    "where",
+    "orderBy",
+    "cursor",
+    "take",
+    "skip",
+    "_count",
+    "_avg",
+    "_sum",
+    "_min",
+    "_max"
+  ]),
+  groupBy: /* @__PURE__ */ new Set([
+    "where",
+    "by",
+    "having",
+    "_count",
+    "_avg",
+    "_sum",
+    "_min",
+    "_max",
+    "orderBy",
+    "take",
+    "skip"
+  ])
+};
+var UNIQUE_WHERE_METHODS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow"
+]);
+var STRING_MODE_OPS = /* @__PURE__ */ new Set([
+  "contains",
+  "startsWith",
+  "endsWith",
+  "equals"
+]);
+var UNSUPPORTED_WHERE_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+var UNSUPPORTED_BY_TYPES = /* @__PURE__ */ new Set(["Json", "Bytes"]);
+var KNOWN_NESTED_INCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "where",
+  "include",
+  "select",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip"
+]);
+var KNOWN_NESTED_SELECT_KEYS = /* @__PURE__ */ new Set([
+  "select",
+  "where",
+  "orderBy",
+  "cursor",
+  "take",
+  "skip"
+]);
+var KNOWN_COUNT_SELECT_ENTRY_KEYS = /* @__PURE__ */ new Set(["where"]);
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function mergeForced(where, forced) {
+  if (!where)
+    return forced;
+  return { AND: [where, forced] };
+}
+function mergeUniqueForced(where, forced) {
+  if (!where)
+    return { ...forced };
+  return { ...where, AND: [forced] };
+}
+function applyBuiltShape(built, body, isUniqueMethod) {
+  const validated = built.zodSchema.parse(body);
+  if (Object.keys(built.forcedWhere).length > 0) {
+    const cloned = structuredClone(built.forcedWhere);
+    validated.where = isUniqueMethod ? mergeUniqueForced(
+      validated.where,
+      cloned
+    ) : mergeForced(
+      validated.where,
+      cloned
+    );
+  }
+  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 includeContainer = validated.include;
+    if (includeContainer) {
+      applyForcedCountWhere(includeContainer, built.forcedIncludeCountWhere);
+    }
+  }
+  if (Object.keys(built.forcedSelectCountWhere).length > 0) {
+    const selectContainer = validated.select;
+    if (selectContainer) {
+      applyForcedCountWhere(selectContainer, built.forcedSelectCountWhere);
+    }
+  }
+  return validated;
+}
+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)
+        expanded.where = structuredClone(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 countSelect = {};
+        for (const [countRel, countForced] of Object.entries(
+          forced._countWhere
+        )) {
+          countSelect[countRel] = { where: structuredClone(countForced) };
+        }
+        expanded._count = { select: countSelect };
+      }
+      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) {
+        relObj.where = mergeForced(
+          relObj.where,
+          structuredClone(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) {
+        applyForcedCountWhere(relObj, 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)
+      nested.where = structuredClone(forced.where);
+    if (forced.include)
+      nested.include = buildForcedOnlyContainer(forced.include);
+    if (forced.select)
+      nested.select = buildForcedOnlyContainer(forced.select);
+    if (forced._countWhere && Object.keys(forced._countWhere).length > 0) {
+      const countSelect = {};
+      for (const [countRel, countForced] of Object.entries(
+        forced._countWhere
+      )) {
+        countSelect[countRel] = { where: structuredClone(countForced) };
+      }
+      nested._count = { select: countSelect };
+    }
+    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: structuredClone(forced) };
+    } else if (isPlainObject(relVal)) {
+      const relObj = relVal;
+      relObj.where = mergeForced(
+        relObj.where,
+        structuredClone(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 validateUniqueEquality(model, where, method, uniqueMap) {
+  const constraints = uniqueMap[model];
+  if (!constraints || constraints.length === 0)
+    return;
+  const whereFields = new Set(Object.keys(where));
+  const valid = constraints.some((constraint) => {
+    if (!constraint.every((field) => whereFields.has(field)))
+      return false;
+    return constraint.every((field) => {
+      const ops = where[field];
+      if (!ops)
+        return false;
+      return Object.keys(ops).every((op) => op === "equals");
+    });
+  });
+  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}`
+    );
+  }
+}
+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 createQueryBuilder(typeMap, enumMap, uniqueMap = {}) {
+  function isShapeConfig(obj) {
+    if (!isPlainObject(obj))
+      return false;
+    const keys = Object.keys(obj);
+    return keys.length === 0 || keys.every((k) => SHAPE_CONFIG_KEYS.has(k));
+  }
+  function buildWhereSchema(model, whereConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    const forced = {};
+    for (const [fieldName, operators] of Object.entries(whereConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}"`
+        );
+      if (fieldMeta.isRelation)
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in where`
+        );
+      if (UNSUPPORTED_WHERE_TYPES.has(fieldMeta.type) && !fieldMeta.isList) {
+        throw new ShapeError(
+          `${fieldMeta.type} field "${fieldName}" cannot be used in where filters`
+        );
+      }
+      const opSchemas = {};
+      const fieldForced = {};
+      let hasClientOps = false;
+      let hasStringModeOp = false;
+      const clientOpKeys = [];
+      for (const [op, value] of Object.entries(operators)) {
+        if (value === true) {
+          opSchemas[op] = createOperatorSchema(
+            fieldMeta,
+            op,
+            enumMap
+          ).optional();
+          hasClientOps = true;
+          clientOpKeys.push(op);
+          if (fieldMeta.type === "String" && !fieldMeta.isList && STRING_MODE_OPS.has(op)) {
+            hasStringModeOp = true;
+          }
+        } else {
+          const opSchema = createOperatorSchema(fieldMeta, op, enumMap);
+          let parsed;
+          try {
+            parsed = opSchema.parse(value);
+          } catch (err) {
+            throw new ShapeError(
+              `Invalid forced value for "${model}.${fieldName}.${op}": ${err.message}`
+            );
+          }
+          fieldForced[op] = parsed;
+        }
+      }
+      if (!hasClientOps && Object.keys(fieldForced).length === 0) {
+        throw new ShapeError(
+          `Empty operator config for where field "${fieldName}" on model "${model}". Define at least one operator.`
+        );
+      }
+      if (hasStringModeOp) {
+        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
+      }
+      if (hasClientOps) {
+        const opObj = z4.object(opSchemas).strict();
+        fieldSchemas[fieldName] = opObj.refine(
+          (v) => clientOpKeys.some(
+            (k) => v[k] !== void 0
+          ),
+          {
+            message: `At least one operator required for where field "${fieldName}"`
+          }
+        ).optional();
+      }
+      if (Object.keys(fieldForced).length > 0) {
+        forced[fieldName] = fieldForced;
+      }
+    }
+    const schema = Object.keys(fieldSchemas).length > 0 ? z4.object(fieldSchemas).strict().optional() : null;
+    return { schema, forced };
+  }
+  function buildCountFieldSchema(model, config, context) {
+    if (config === true) {
+      return z4.literal(true).optional();
+    }
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(config)) {
+      if (fieldName !== "_all") {
+        const fieldMeta = modelFields[fieldName];
+        if (!fieldMeta)
+          throw new ShapeError(
+            `Unknown field "${fieldName}" on model "${model}" in ${context}`
+          );
+        if (fieldMeta.isRelation)
+          throw new ShapeError(
+            `Relation field "${fieldName}" cannot be used in ${context}`
+          );
+      }
+      fieldSchemas[fieldName] = z4.literal(true).optional();
+    }
+    return z4.object(fieldSchemas).strict().optional();
+  }
+  function buildIncludeCountSchema(model, config) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    if (config === true) {
+      return { schema: z4.literal(true).optional(), forcedCountWhere: {} };
+    }
+    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.`
+        );
+      }
+    }
+    const selectObj = config.select;
+    const countSelectFields = {};
+    const forcedCountWhere = {};
+    for (const [fieldName, fieldConfig] of Object.entries(selectObj)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in _count.select`
+        );
+      if (!fieldMeta.isRelation)
+        throw new ShapeError(
+          `Field "${fieldName}" is not a relation on model "${model}" in _count.select`
+        );
+      if (fieldConfig === true) {
+        countSelectFields[fieldName] = z4.literal(true).optional();
+      } else if (isPlainObject(fieldConfig)) {
+        validateNestedKeys(
+          Object.keys(fieldConfig),
+          KNOWN_COUNT_SELECT_ENTRY_KEYS,
+          `_count.select.${fieldName} on model "${model}"`
+        );
+        if (fieldConfig.where) {
+          const relatedType = fieldMeta.type;
+          const { schema: whereSchema, forced } = buildWhereSchema(
+            relatedType,
+            fieldConfig.where
+          );
+          const nestedSchemas = {};
+          if (whereSchema)
+            nestedSchemas["where"] = whereSchema;
+          const nestedObj = z4.object(nestedSchemas).strict();
+          countSelectFields[fieldName] = z4.union([z4.literal(true), nestedObj]).optional();
+          if (Object.keys(forced).length > 0) {
+            forcedCountWhere[fieldName] = forced;
+          }
+        } else {
+          countSelectFields[fieldName] = z4.literal(true).optional();
+        }
+      } else {
+        throw new ShapeError(
+          `Invalid config for _count.select.${fieldName} on model "${model}". Expected true or { where: { ... } }`
+        );
+      }
+    }
+    const selectSchema = z4.object(countSelectFields).strict();
+    return {
+      schema: z4.object({ select: selectSchema }).strict().optional(),
+      forcedCountWhere
+    };
+  }
+  function buildAggregateFieldSchema(model, opName, fieldConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown 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] = z4.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 (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] = z4.literal(true).optional();
+    }
+    return z4.object(fieldSchemas).strict().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 = z4.enum(byConfig);
+    return z4.union([enumSchema, z4.array(enumSchema).min(1)]);
+  }
+  function buildCursorSchema(model, cursorConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const cursorFields = new Set(Object.keys(cursorConfig));
+    const constraints = uniqueMap[model];
+    if (constraints && constraints.length > 0) {
+      const covered = constraints.some(
+        (constraint) => constraint.every((field) => cursorFields.has(field))
+      );
+      if (!covered) {
+        const constraintDesc = constraints.map((c) => `(${c.join(", ")})`).join(" | ");
+        throw new ShapeError(
+          `cursor on model "${model}" must cover 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);
+    }
+    return z4.object(fieldSchemas).strict().optional();
+  }
+  function buildDistinctSchema(model, distinctConfig) {
+    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 = z4.enum(distinctConfig);
+    return z4.union([enumSchema, z4.array(enumSchema).min(1)]).optional();
+  }
+  function buildIncludeSchema(model, includeConfig) {
+    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] = z4.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 } = buildWhereSchema(
+            fieldMeta.type,
+            config.where
+          );
+          if (whereSchema)
+            nestedSchemas["where"] = whereSchema;
+          if (Object.keys(forced).length > 0)
+            relForced.where = forced;
+        }
+        if (config.include) {
+          const nested = buildIncludeSchema(fieldMeta.type, config.include);
+          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;
+        }
+        if (config.select) {
+          const nested = buildSelectSchema(fieldMeta.type, config.select);
+          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;
+        }
+        if (config.orderBy) {
+          nestedSchemas["orderBy"] = buildOrderBySchema(
+            fieldMeta.type,
+            config.orderBy
+          );
+        }
+        if (config.cursor) {
+          nestedSchemas["cursor"] = buildCursorSchema(
+            fieldMeta.type,
+            config.cursor
+          );
+        }
+        if (config.take) {
+          nestedSchemas["take"] = buildTakeSchema(config.take);
+        }
+        if (config.skip) {
+          nestedSchemas["skip"] = z4.number().int().min(0).optional();
+        }
+        const nestedObj = z4.object(nestedSchemas).strict();
+        fieldSchemas[relName] = z4.union([z4.literal(true), nestedObj]).optional();
+        if (Object.keys(relForced).length > 0)
+          forcedTree[relName] = relForced;
+      }
+    }
+    return {
+      schema: z4.object(fieldSchemas).strict().optional(),
+      forcedTree,
+      forcedCountWhere: topLevelForcedCountWhere
+    };
+  }
+  function buildSelectSchema(model, selectConfig) {
+    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] = z4.literal(true).optional();
+      } else {
+        if (!fieldMeta.isRelation) {
+          throw new ShapeError(
+            `Nested select args only valid for relations, not scalar "${fieldName}"`
+          );
+        }
+        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);
+          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;
+        }
+        if (config.where) {
+          const { schema: whereSchema, forced } = buildWhereSchema(
+            fieldMeta.type,
+            config.where
+          );
+          if (whereSchema)
+            nestedSchemas["where"] = whereSchema;
+          if (Object.keys(forced).length > 0)
+            relForced.where = forced;
+        }
+        if (config.orderBy) {
+          nestedSchemas["orderBy"] = buildOrderBySchema(
+            fieldMeta.type,
+            config.orderBy
+          );
+        }
+        if (config.cursor) {
+          nestedSchemas["cursor"] = buildCursorSchema(
+            fieldMeta.type,
+            config.cursor
+          );
+        }
+        if (config.take) {
+          nestedSchemas["take"] = buildTakeSchema(config.take);
+        }
+        if (config.skip) {
+          nestedSchemas["skip"] = z4.number().int().min(0).optional();
+        }
+        const nestedObj = z4.object(nestedSchemas).strict();
+        fieldSchemas[fieldName] = z4.union([z4.literal(true), nestedObj]).optional();
+        if (Object.keys(relForced).length > 0)
+          forcedTree[fieldName] = relForced;
+      }
+    }
+    return {
+      schema: z4.object(fieldSchemas).strict().optional(),
+      forcedTree,
+      forcedCountWhere: topLevelForcedCountWhere
+    };
+  }
+  function buildOrderBySchema(model, orderByConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(orderByConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}"`
+        );
+      if (fieldMeta.isRelation)
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in orderBy`
+        );
+      if (fieldMeta.type === "Json")
+        throw new ShapeError(
+          `Json field "${fieldName}" cannot be used in orderBy`
+        );
+      if (fieldMeta.isList)
+        throw new ShapeError(
+          `List field "${fieldName}" cannot be used in orderBy`
+        );
+      fieldSchemas[fieldName] = z4.enum(["asc", "desc"]).optional();
+    }
+    const singleSchema = z4.object(fieldSchemas).strict();
+    return z4.union([singleSchema, z4.array(singleSchema)]).optional();
+  }
+  function buildTakeSchema(config) {
+    if (!Number.isFinite(config.max) || !Number.isInteger(config.max)) {
+      throw new ShapeError(
+        `take max must be a finite integer, got ${config.max}`
+      );
+    }
+    if (config.max < 1) {
+      throw new ShapeError(`take max must be at least 1, got ${config.max}`);
+    }
+    if (config.default !== void 0) {
+      if (!Number.isFinite(config.default) || !Number.isInteger(config.default)) {
+        throw new ShapeError(
+          `take default must be a finite integer, got ${config.default}`
+        );
+      }
+      if (config.default < 1) {
+        throw new ShapeError(
+          `take default must be at least 1, got ${config.default}`
+        );
+      }
+      if (config.default > config.max) {
+        throw new ShapeError("take default cannot exceed max");
+      }
+      return z4.number().int().min(1).max(config.max).default(config.default);
+    }
+    return z4.number().int().min(1).max(config.max).optional();
+  }
+  function buildHavingSchema(model, havingConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(havingConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in having`
+        );
+      if (fieldMeta.isRelation)
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in having`
+        );
+      if (fieldMeta.isList)
+        throw new ShapeError(
+          `List field "${fieldName}" cannot be used in having`
+        );
+      const ops = getSupportedOperators(fieldMeta);
+      if (ops.length === 0) {
+        throw new ShapeError(
+          `${fieldMeta.type} field "${fieldName}" cannot be used in having filters`
+        );
+      }
+      const opSchemas = {};
+      const opKeys = [];
+      for (const op of ops) {
+        opSchemas[op] = createOperatorSchema(fieldMeta, op, enumMap).optional();
+        opKeys.push(op);
+      }
+      if (fieldMeta.type === "String" && !fieldMeta.isList) {
+        opSchemas["mode"] = z4.enum(["default", "insensitive"]).optional();
+      }
+      fieldSchemas[fieldName] = z4.object(opSchemas).strict().refine(
+        (v) => opKeys.some((k) => v[k] !== void 0),
+        {
+          message: `At least one operator required for having field "${fieldName}"`
+        }
+      ).optional();
+    }
+    return z4.object(fieldSchemas).strict().optional();
+  }
+  function buildCountSelectSchema(model, selectConfig) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const fieldSchemas = {};
+    for (const fieldName of Object.keys(selectConfig)) {
+      if (fieldName === "_all") {
+        fieldSchemas["_all"] = z4.literal(true).optional();
+        continue;
+      }
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(
+          `Unknown field "${fieldName}" on model "${model}" in count select`
+        );
+      if (fieldMeta.isRelation)
+        throw new ShapeError(
+          `Relation field "${fieldName}" cannot be used in count select`
+        );
+      fieldSchemas[fieldName] = z4.literal(true).optional();
+    }
+    return z4.object(fieldSchemas).strict().optional();
+  }
+  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 (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);
+  }
+  function buildShapeZodSchema(model, method, shape) {
+    validateShapeArgs(method, shape);
+    validateUniqueWhere(model, method, shape);
+    const schemaFields = {};
+    let forcedWhere = {};
+    let forcedIncludeTree = {};
+    let forcedSelectTree = {};
+    let forcedIncludeCountWhere = {};
+    let forcedSelectCountWhere = {};
+    if (shape.where) {
+      const { schema, forced } = buildWhereSchema(model, shape.where);
+      if (schema)
+        schemaFields["where"] = schema;
+      forcedWhere = forced;
+    }
+    if (shape.include) {
+      const result = buildIncludeSchema(model, shape.include);
+      schemaFields["include"] = result.schema;
+      forcedIncludeTree = result.forcedTree;
+      forcedIncludeCountWhere = result.forcedCountWhere;
+    }
+    if (shape.select) {
+      if (method === "count") {
+        schemaFields["select"] = buildCountSelectSchema(model, shape.select);
+      } else {
+        const result = buildSelectSchema(model, shape.select);
+        schemaFields["select"] = result.schema;
+        forcedSelectTree = result.forcedTree;
+        forcedSelectCountWhere = result.forcedCountWhere;
+      }
+    }
+    if (shape.orderBy) {
+      schemaFields["orderBy"] = buildOrderBySchema(model, shape.orderBy);
+    }
+    if (shape.cursor) {
+      schemaFields["cursor"] = buildCursorSchema(model, shape.cursor);
+    }
+    if (shape.take) {
+      schemaFields["take"] = buildTakeSchema(shape.take);
+    }
+    if (shape.skip) {
+      schemaFields["skip"] = z4.number().int().min(0).optional();
+    }
+    if (shape.distinct) {
+      schemaFields["distinct"] = buildDistinctSchema(model, shape.distinct);
+    }
+    if (shape._count) {
+      schemaFields["_count"] = buildCountFieldSchema(
+        model,
+        shape._count,
+        "_count"
+      );
+    }
+    if (shape._avg) {
+      schemaFields["_avg"] = buildAggregateFieldSchema(
+        model,
+        "_avg",
+        shape._avg
+      );
+    }
+    if (shape._sum) {
+      schemaFields["_sum"] = buildAggregateFieldSchema(
+        model,
+        "_sum",
+        shape._sum
+      );
+    }
+    if (shape._min) {
+      schemaFields["_min"] = buildAggregateFieldSchema(
+        model,
+        "_min",
+        shape._min
+      );
+    }
+    if (shape._max) {
+      schemaFields["_max"] = buildAggregateFieldSchema(
+        model,
+        "_max",
+        shape._max
+      );
+    }
+    if (shape.by) {
+      schemaFields["by"] = buildBySchema(model, shape.by);
+    }
+    if (shape.having) {
+      schemaFields["having"] = buildHavingSchema(model, shape.having);
+    }
+    return {
+      zodSchema: z4.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 isSingleShape2 = typeof config === "function" || isShapeConfig(config);
+    const builtCache = /* @__PURE__ */ new Map();
+    if (isSingleShape2 && typeof config !== "function") {
+      const built = buildShapeZodSchema(model, method, config);
+      builtCache.set("_default", built);
+    }
+    if (!isSingleShape2) {
+      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") {
+          const built = buildShapeZodSchema(
+            model,
+            method,
+            shapeOrFn
+          );
+          builtCache.set(key, built);
+        }
+      }
+    }
+    const isUnique = UNIQUE_WHERE_METHODS.has(method);
+    return {
+      schemas: Object.fromEntries(
+        [...builtCache.entries()].map(([k, v]) => [k, v.zodSchema])
+      ),
+      parse(body, opts) {
+        let built;
+        if (isSingleShape2) {
+          if (typeof config === "function") {
+            requireContext(opts?.ctx, "shape function");
+            const resolvedShape = config(opts.ctx);
+            built = buildShapeZodSchema(model, method, resolvedShape);
+          } else {
+            built = builtCache.get("_default");
+          }
+        } else {
+          if (!isPlainObject(body)) {
+            throw new ShapeError("Request body must be an object");
+          }
+          const caller = body.caller;
+          if (typeof caller !== "string") {
+            throw new CallerError('Missing "caller" field in request body');
+          }
+          const matched = matchCaller(
+            config,
+            caller
+          );
+          if (!matched) {
+            const allowed = Object.keys(
+              config
+            );
+            throw new CallerError(
+              `Unknown caller: "${caller}". Allowed: ${allowed.map((k) => `"${k}"`).join(", ")}`
+            );
+          }
+          const shapeKey = matched.key;
+          const shapeOrFn = matched.shape;
+          if (typeof shapeOrFn === "function") {
+            requireContext(opts?.ctx, "shape function");
+            const resolvedShape = shapeOrFn(opts.ctx);
+            built = buildShapeZodSchema(model, method, resolvedShape);
+          } else {
+            built = builtCache.get(shapeKey);
+          }
+          const { caller: _, ...rest } = body;
+          body = rest;
+        }
+        return applyBuiltShape(built, body, isUnique);
+      }
+    };
+  }
+  return {
+    buildQuerySchema,
+    buildShapeZodSchema,
+    buildWhereSchema,
+    buildIncludeSchema,
+    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]])
+        );
+        if (operation === "upsert") {
+          throw new PolicyError(
+            `Scoped model "${model}" cannot use upsert via extension. Handle upsert explicitly in route logic.`
+          );
+        }
+        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);
+        }
+        const nextArgs = { ...args };
+        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
+import { z as z5 } from "zod";
+var ALLOWED_BODY_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
+var ALLOWED_BODY_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
+var ALLOWED_BODY_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
+var ALLOWED_BODY_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
+var ALLOWED_BODY_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
+var ALLOWED_BODY_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
+var VALID_SHAPE_KEYS_CREATE = /* @__PURE__ */ new Set(["data"]);
+var VALID_SHAPE_KEYS_CREATE_PROJECTION = /* @__PURE__ */ new Set(["data", "select", "include"]);
+var VALID_SHAPE_KEYS_UPDATE = /* @__PURE__ */ new Set(["data", "where"]);
+var VALID_SHAPE_KEYS_UPDATE_PROJECTION = /* @__PURE__ */ new Set(["data", "where", "select", "include"]);
+var VALID_SHAPE_KEYS_DELETE = /* @__PURE__ */ new Set(["where"]);
+var VALID_SHAPE_KEYS_DELETE_PROJECTION = /* @__PURE__ */ new Set(["where", "select", "include"]);
+var UNIQUE_MUTATION_METHODS = /* @__PURE__ */ new Set(["update", "delete"]);
+var UNIQUE_READ_METHODS = /* @__PURE__ */ new Set(["findUnique", "findUniqueOrThrow"]);
+var BULK_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "updateMany",
+  "updateManyAndReturn",
+  "deleteMany"
+]);
+var PROJECTION_MUTATION_METHODS = /* @__PURE__ */ new Set([
+  "create",
+  "update",
+  "delete",
+  "createManyAndReturn",
+  "updateManyAndReturn"
+]);
+function isGuardShape(obj) {
+  if (!isPlainObject(obj))
+    return false;
+  const keys = Object.keys(obj);
+  return keys.length === 0 || keys.every((k) => GUARD_SHAPE_KEYS.has(k));
+}
+function isSingleShape(input) {
+  return typeof input === "function" || isGuardShape(input);
+}
+function validateMutationBodyKeys(body, allowed, method) {
+  for (const key of Object.keys(body)) {
+    if (!allowed.has(key)) {
+      throw new ShapeError(
+        `Unexpected key "${key}" in ${method} body. Allowed keys: ${[...allowed].join(", ")}`
+      );
+    }
+  }
+}
+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 formatZodError(err) {
+  return err.issues.map((i) => {
+    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+    return `${p}${i.message}`;
+  }).join("; ");
+}
+function createModelGuardExtension(config) {
+  const { typeMap, enumMap, zodChains, uniqueMap, scopeMap, contextFn } = config;
+  const wrapZodErrors = config.wrapZodErrors ?? false;
+  const schemaBuilder = createSchemaBuilder(typeMap, zodChains, enumMap);
+  const queryBuilder = createQueryBuilder(typeMap, enumMap, uniqueMap);
+  const modelScopeFks = /* @__PURE__ */ new Map();
+  for (const [model, entries] of Object.entries(scopeMap)) {
+    const fks = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      fks.add(entry.fk);
+    }
+    modelScopeFks.set(model, fks);
+  }
+  function validateCreateCompleteness(modelName, dataConfig) {
+    const modelFields = typeMap[modelName];
+    if (!modelFields)
+      return;
+    const fks = modelScopeFks.get(modelName) ?? /* @__PURE__ */ new Set();
+    for (const [fieldName, meta] of Object.entries(modelFields)) {
+      if (meta.isRelation)
+        continue;
+      if (meta.isUpdatedAt)
+        continue;
+      if (meta.hasDefault)
+        continue;
+      if (!meta.isRequired)
+        continue;
+      if (fieldName in dataConfig)
+        continue;
+      if (fks.has(fieldName))
+        continue;
+      throw new ShapeError(
+        `Required field "${fieldName}" on model "${modelName}" is missing from create data shape, has no default, and is not a scope FK`
+      );
+    }
+  }
+  function buildDataSchema(model, dataConfig, mode) {
+    const modelFields = typeMap[model];
+    if (!modelFields)
+      throw new ShapeError(`Unknown model: ${model}`);
+    const schemaMap = {};
+    const forced = {};
+    for (const [fieldName, value] of Object.entries(dataConfig)) {
+      const fieldMeta = modelFields[fieldName];
+      if (!fieldMeta)
+        throw new ShapeError(`Unknown field "${fieldName}" on model "${model}"`);
+      if (fieldMeta.isRelation)
+        throw new ShapeError(`Relation field "${fieldName}" cannot be used in data shape`);
+      if (fieldMeta.isUpdatedAt)
+        throw new ShapeError(`updatedAt field "${fieldName}" cannot be used in data shape`);
+      if (typeof value === "function") {
+        let baseSchema = schemaBuilder.buildBaseFieldSchema(model, fieldName);
+        let fieldSchema;
+        try {
+          fieldSchema = value(baseSchema);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid inline refine for "${model}.${fieldName}": ${err.message}`,
+            { cause: err }
+          );
+        }
+        if (mode === "create") {
+          if (!fieldMeta.isRequired || fieldMeta.hasDefault) {
+            fieldSchema = fieldSchema.optional();
+          }
+        } else {
+          if (!fieldMeta.isRequired) {
+            fieldSchema = fieldSchema.nullable().optional();
+          } else {
+            fieldSchema = fieldSchema.optional();
+          }
+        }
+        schemaMap[fieldName] = fieldSchema;
+      } else if (value === true) {
+        let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+        if (mode === "create") {
+          if (!fieldMeta.isRequired || fieldMeta.hasDefault) {
+            fieldSchema = fieldSchema.optional();
+          }
+        } else {
+          if (!fieldMeta.isRequired) {
+            fieldSchema = fieldSchema.nullable().optional();
+          } else {
+            fieldSchema = fieldSchema.optional();
+          }
+        }
+        schemaMap[fieldName] = fieldSchema;
+      } else {
+        let fieldSchema = schemaBuilder.buildFieldSchema(model, fieldName);
+        if (!fieldMeta.isRequired) {
+          fieldSchema = fieldSchema.nullable();
+        }
+        let parsed;
+        try {
+          parsed = fieldSchema.parse(value);
+        } catch (err) {
+          throw new ShapeError(
+            `Invalid forced data value for "${model}.${fieldName}": ${err.message}`
+          );
+        }
+        forced[fieldName] = parsed;
+      }
+    }
+    return {
+      schema: z5.object(schemaMap).strict(),
+      forced
+    };
+  }
+  function resolveShape(input, body) {
+    if (isSingleShape(input)) {
+      const wasDynamic2 = typeof input === "function";
+      const shape2 = wasDynamic2 ? input(contextFn()) : input;
+      const parsed2 = body === void 0 || body === null ? {} : requireBody(body);
+      if ("caller" in parsed2) {
+        throw new CallerError(
+          'Named shape routing is not configured on this guard. Remove "caller" from the request body or use a named shape map.'
+        );
+      }
+      return { shape: shape2, body: parsed2, matchedKey: "_default", wasDynamic: wasDynamic2 };
+    }
+    const namedMap = input;
+    for (const key of Object.keys(namedMap)) {
+      if (GUARD_SHAPE_KEYS.has(key)) {
+        throw new ShapeError(
+          `Caller key "${key}" collides with reserved shape config key. Rename the caller path.`
+        );
+      }
+      const val = namedMap[key];
+      if (typeof val !== "function" && !isGuardShape(val)) {
+        throw new ShapeError(
+          `Named shape value for "${key}" must be a guard shape object or function`
+        );
+      }
+    }
+    const parsed = requireBody(body);
+    const caller = parsed.caller;
+    if (typeof caller !== "string") {
+      throw new CallerError('Missing "caller" field in request body');
+    }
+    const patterns = Object.keys(namedMap);
+    const matched = matchCallerPattern(patterns, caller);
+    if (!matched) {
+      throw new CallerError(
+        `Unknown caller: "${caller}". Allowed: ${patterns.map((k) => `"${k}"`).join(", ")}`
+      );
+    }
+    const shapeOrFn = namedMap[matched];
+    const wasDynamic = typeof shapeOrFn === "function";
+    const shape = wasDynamic ? shapeOrFn(contextFn()) : shapeOrFn;
+    const { caller: _, ...rest } = parsed;
+    return { shape, body: rest, matchedKey: matched, wasDynamic };
+  }
+  function requireBody(body) {
+    if (!isPlainObject(body))
+      throw new ShapeError("Request body must be an object");
+    return body;
+  }
+  function validateAndMergeData(bodyData, cached, method) {
+    if (bodyData === void 0 || bodyData === null) {
+      throw new ShapeError(`${method} requires "data" in request body`);
+    }
+    const validated = cached.schema.parse(bodyData);
+    return { ...validated, ...cached.forced };
+  }
+  function maybeValidateUniqueWhere(modelName, shape, method) {
+    if (!UNIQUE_MUTATION_METHODS.has(method))
+      return;
+    if (!shape.where)
+      return;
+    validateUniqueEquality(modelName, shape.where, method, uniqueMap);
+  }
+  function hasDataRefines(dataConfig) {
+    for (const value of Object.values(dataConfig)) {
+      if (typeof value === "function")
+        return true;
+    }
+    return false;
+  }
+  function createGuardedMethods(modelName, modelDelegate, input) {
+    function callDelegate(method, args) {
+      if (typeof modelDelegate[method] !== "function") {
+        throw new ShapeError(`Method "${method}" is not available on this model`);
+      }
+      return modelDelegate[method](args);
+    }
+    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);
+        dataSchemaCache.set(cacheKey, built);
+        return built;
+      }
+      return buildDataSchema(modelName, dataConfig, mode);
+    }
+    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: z5.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 {};
+      const projection = getProjection(shape, matchedKey, wasDynamic);
+      const projectionBody = {};
+      if ("select" in parsed)
+        projectionBody.select = parsed.select;
+      if ("include" in parsed)
+        projectionBody.include = parsed.include;
+      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);
+      }
+      if (Object.keys(built.forced).length > 0) {
+        return preserveUnique ? mergeUniqueForced(validatedWhere, built.forced) : mergeForced(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 { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
+        if (shape.data) {
+          throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
+        }
+        const { data: _, ...queryShape } = shape;
+        const built = getReadShape(method, queryShape, matchedKey, wasDynamic);
+        const isUnique = UNIQUE_READ_METHODS.has(method);
+        const args = applyBuiltShape(built, parsed, isUnique);
+        if (isUnique && args.where) {
+          validateResolvedUniqueWhere(
+            modelName,
+            args.where,
+            method,
+            uniqueMap
+          );
+        }
+        return callDelegate(method, args);
+      };
+    }
+    function makeCreateMethod(method) {
+      const supportsProjection = PROJECTION_MUTATION_METHODS.has(method);
+      const allowedBodyKeys = supportsProjection ? ALLOWED_BODY_KEYS_CREATE_PROJECTION : ALLOWED_BODY_KEYS_CREATE;
+      const allowedShapeKeys = supportsProjection ? VALID_SHAPE_KEYS_CREATE_PROJECTION : VALID_SHAPE_KEYS_CREATE;
+      return (body) => {
+        const { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
+        if (!shape.data)
+          throw new ShapeError(`Guard shape requires "data" for ${method}`);
+        validateMutationShapeKeys(shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
+        validateCreateCompleteness(modelName, shape.data);
+        const dataSchema = getDataSchema("create", shape.data, matchedKey, wasDynamic);
+        let args;
+        if (method === "create") {
+          const data = validateAndMergeData(parsed.data, dataSchema, method);
+          args = { data };
+        } else {
+          if (!Array.isArray(parsed.data))
+            throw new ShapeError(`${method} expects data to be an array`);
+          if (parsed.data.length === 0)
+            throw new ShapeError(`${method} received empty data array`);
+          const data = parsed.data.map(
+            (item) => validateAndMergeData(item, dataSchema, method)
+          );
+          args = { data };
+        }
+        if (supportsProjection) {
+          const projectionArgs = resolveProjection(shape, parsed, method, matchedKey, 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 { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
+        if (!shape.data)
+          throw new ShapeError(`Guard shape requires "data" for ${method}`);
+        validateMutationShapeKeys(shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
+        if (isBulk && !shape.where) {
+          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+        }
+        maybeValidateUniqueWhere(modelName, shape, method);
+        const dataSchema = getDataSchema("update", shape.data, matchedKey, wasDynamic);
+        const data = validateAndMergeData(parsed.data, dataSchema, method);
+        const where = isUniqueWhere ? requireWhere(shape, parsed.where, method, true, matchedKey, wasDynamic) : buildWhereFromShape(shape, parsed.where, false, matchedKey, wasDynamic);
+        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(shape, parsed, method, matchedKey, 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 { shape, body: parsed, matchedKey, wasDynamic } = resolveShape(input, body);
+        if (shape.data)
+          throw new ShapeError(`Guard shape "data" is not valid for ${method}`);
+        validateMutationShapeKeys(shape, allowedShapeKeys, method);
+        validateMutationBodyKeys(parsed, allowedBodyKeys, method);
+        if (isBulk && !shape.where) {
+          throw new ShapeError(`Guard shape requires "where" for ${method} to prevent unconstrained bulk mutations`);
+        }
+        maybeValidateUniqueWhere(modelName, shape, method);
+        const where = isUniqueWhere ? requireWhere(shape, parsed.where, method, true, matchedKey, wasDynamic) : buildWhereFromShape(shape, parsed.where, false, matchedKey, wasDynamic);
+        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(shape, parsed, method, matchedKey, wasDynamic);
+          Object.assign(args, projectionArgs);
+        }
+        return callDelegate(method, 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"),
+      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 z5.ZodError) {
+            throw new ShapeError(
+              `Validation failed: ${formatZodError(err)}`,
+              { cause: err }
+            );
+          }
+          throw err;
+        }
+      };
+    }
+    return wrapped;
+  }
+  return {
+    $allModels: {
+      guard(input) {
+        const modelName = this.$name;
+        const delegateKey = modelName[0].toLowerCase() + modelName.slice(1);
+        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);
+        if (!wrapZodErrors)
+          return methods;
+        return wrapMethods(methods);
+      }
+    }
+  };
+}
+
+// src/runtime/guard.ts
+function formatZodError2(err) {
+  return err.issues.map((i) => {
+    const p = i.path.length > 0 ? `${i.path.join(".")}: ` : "";
+    return `${p}${i.message}`;
+  }).join("; ");
+}
+function createGuard(config) {
+  const schemaBuilder = createSchemaBuilder(
+    config.typeMap,
+    config.zodChains,
+    config.enumMap
+  );
+  const queryBuilder = createQueryBuilder(
+    config.typeMap,
+    config.enumMap,
+    config.uniqueMap ?? {}
+  );
+  const log = config.logger ?? { warn: (msg) => console.warn(msg) };
+  const wrapZodErrors = config.wrapZodErrors ?? false;
+  function rethrowZod(err) {
+    if (err instanceof ZodError) {
+      throw new ShapeError(`Validation failed: ${formatZodError2(err)}`, { cause: err });
+    }
+    throw 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 scopeCtxFn = () => {
+        const ctx = contextFn();
+        const scopeCtx = {};
+        for (const key of Object.keys(ctx)) {
+          const val = ctx[key];
+          if (typeof val === "string" || typeof val === "number" || typeof val === "bigint") {
+            scopeCtx[key] = val;
+          } else if (val !== null && val !== void 0) {
+            log.warn(
+              `prisma-guard: Context key "${key}" has non-primitive value (${typeof val}). Only string, number, and bigint values are used for scope context.`
+            );
+          }
+        }
+        return scopeCtx;
+      };
+      const scopeExt = createScopeExtension(
+        config.scopeMap,
+        scopeCtxFn,
+        config.guardConfig,
+        config.logger
+      );
+      const modelGuardExt = createModelGuardExtension({
+        typeMap: config.typeMap,
+        enumMap: config.enumMap,
+        zodChains: config.zodChains,
+        uniqueMap: config.uniqueMap ?? {},
+        scopeMap: config.scopeMap,
+        contextFn,
+        wrapZodErrors
+      });
+      return {
+        name: "prisma-guard",
+        model: modelGuardExt,
+        query: scopeExt.query
+      };
+    }
+  };
+}
+export {
+  CallerError,
+  PolicyError,
+  ShapeError,
+  createGuard
+};
+//# sourceMappingURL=index.js.map