@brutal-ai/server 0.1.0 → 0.2.0

package/worker/index.js

@@ -23940,13 +23940,13 @@ function initializeContext(params) {
   };
 }
 __name(initializeContext, "initializeContext");
-function handleUnrepresentable(schema, ctx, json2, params, message) {
+function handleUnrepresentable(schema, ctx, json3, params, message) {
   const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message }) : ctx.unrepresentable;
   if (result === "any")
     return false;
   if (result === void 0 || result === "throw")
     throw new Error(message);
-  Object.assign(json2, result);
+  Object.assign(json3, result);
   return true;
 }
 __name(handleUnrepresentable, "handleUnrepresentable");
@@ -24189,12 +24189,12 @@ function foldObjects(members2) {
   return folded;
 }
 __name(foldObjects, "foldObjects");
-function foldIntersection(json2) {
-  const allOf = json2.allOf;
+function foldIntersection(json3) {
+  const allOf = json3.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
   for (const key of FOLDABLE_KEYS)
-    if (key in json2)
+    if (key in json3)
       return;
   const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
   let folded = null;
@@ -24213,8 +24213,8 @@ function foldIntersection(json2) {
   }
   if (!folded)
     return;
-  delete json2.allOf;
-  assignProps(json2, folded);
+  delete json3.allOf;
+  assignProps(json3, folded);
 }
 __name(foldIntersection, "foldIntersection");
 function finalize(ctx, schema) {
@@ -24297,20 +24297,20 @@ function finalize(ctx, schema) {
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
-        for (const json2 of [seen.schema, seen.def]) {
-          const allOf = json2?.allOf;
+        for (const json3 of [seen.schema, seen.def]) {
+          const allOf = json3?.allOf;
           if (!Array.isArray(allOf))
             continue;
           const existing = carriers.get(allOf);
           if (existing)
-            existing.push(json2);
+            existing.push(json3);
           else
-            carriers.set(allOf, [json2]);
+            carriers.set(allOf, [json3]);
         }
       }
       for (const allOf of ctx.intersections) {
-        for (const json2 of carriers.get(allOf) ?? [])
-          foldIntersection(json2);
+        for (const json3 of carriers.get(allOf) ?? [])
+          foldIntersection(json3);
       }
     }
   }
@@ -24548,29 +24548,29 @@ var exactPatterns = /* @__PURE__ */ new Map([
 ]);
 var exactPattern = /* @__PURE__ */ __name((p) => exactPatterns.get(p) ?? p, "exactPattern");
 var stringProcessor = /* @__PURE__ */ __name((schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format) {
-    json2.format = formatMap[format] ?? format;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format] ?? format;
+    if (json3.format === "")
+      delete json3.format;
     if (format === "time" || laxFormat) {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const patternList = [...patterns].map(exactPattern);
     if (patternList.length === 1)
-      json2.pattern = patternList[0].source;
+      json3.pattern = patternList[0].source;
     else if (patternList.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...patternList.map((regex) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex.source
@@ -24580,31 +24580,31 @@ var stringProcessor = /* @__PURE__ */ __name((schema, ctx, _json, _params) => {
   }
 }, "stringProcessor");
 var numberProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
-  json2.type = isInt ? "integer" : "number";
+  json3.type = isInt ? "integer" : "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (multipleOf) {
     const divisors = /* @__PURE__ */ new Set();
@@ -24612,75 +24612,75 @@ var numberProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema, ctx, json3, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
-      json2.multipleOf = first;
+      json3.multipleOf = first;
     if (rest.length)
-      json2.allOf = [...json2.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
+      json3.allOf = [...json3.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
 }, "numberProcessor");
-var booleanProcessor = /* @__PURE__ */ __name((_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = /* @__PURE__ */ __name((_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 }, "booleanProcessor");
-var bigintProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt cannot be represented in JSON Schema");
 }, "bigintProcessor");
-var symbolProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
+var symbolProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Symbols cannot be represented in JSON Schema");
 }, "symbolProcessor");
-var nullProcessor = /* @__PURE__ */ __name((_schema, ctx, json2, _params) => {
+var nullProcessor = /* @__PURE__ */ __name((_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 }, "nullProcessor");
-var undefinedProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Undefined cannot be represented in JSON Schema");
 }, "undefinedProcessor");
-var voidProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Void cannot be represented in JSON Schema");
+var voidProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Void cannot be represented in JSON Schema");
 }, "voidProcessor");
-var neverProcessor = /* @__PURE__ */ __name((_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = /* @__PURE__ */ __name((_schema, _ctx, json3, _params) => {
+  json3.not = {};
 }, "neverProcessor");
 var anyProcessor = /* @__PURE__ */ __name((_schema, _ctx, _json, _params) => {
 }, "anyProcessor");
 var unknownProcessor = /* @__PURE__ */ __name((_schema, _ctx, _json, _params) => {
 }, "unknownProcessor");
-var dateProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Date cannot be represented in JSON Schema");
 }, "dateProcessor");
-var enumProcessor = /* @__PURE__ */ __name((schema, _ctx, json2, _params) => {
+var enumProcessor = /* @__PURE__ */ __name((schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   if (values.every((v) => typeof v === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 }, "enumProcessor");
-var literalProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var literalProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   if (def.values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -24690,37 +24690,37 @@ var literalProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v) => v === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 }, "literalProcessor");
-var nanProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "NaN cannot be represented in JSON Schema");
 }, "nanProcessor");
-var templateLiteralProcessor = /* @__PURE__ */ __name((schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = /* @__PURE__ */ __name((schema, _ctx, json3, _params) => {
+  const _json = json3;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 }, "templateLiteralProcessor");
-var fileProcessor = /* @__PURE__ */ __name((schema, _ctx, json2, _params) => {
-  const _json = json2;
+var fileProcessor = /* @__PURE__ */ __name((schema, _ctx, json3, _params) => {
+  const _json = json3;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
@@ -24738,34 +24738,34 @@ var fileProcessor = /* @__PURE__ */ __name((schema, _ctx, json2, _params) => {
   else
     _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
 }, "fileProcessor");
-var successProcessor = /* @__PURE__ */ __name((_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = /* @__PURE__ */ __name((_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 }, "successProcessor");
-var customProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Custom types cannot be represented in JSON Schema");
 }, "customProcessor");
-var functionProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Function types cannot be represented in JSON Schema");
+var functionProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Function types cannot be represented in JSON Schema");
 }, "functionProcessor");
-var transformProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
+var transformProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Transforms cannot be represented in JSON Schema");
 }, "transformProcessor");
-var mapProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Map cannot be represented in JSON Schema");
+var mapProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Map cannot be represented in JSON Schema");
 }, "mapProcessor");
-var setProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Set cannot be represented in JSON Schema");
+var setProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Set cannot be represented in JSON Schema");
 }, "setProcessor");
 var arrayProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = processSchema(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = processSchema(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -24782,17 +24782,17 @@ function inputOptin(schema) {
 }
 __name(inputOptin, "inputOptin");
 var objectProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json3, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   for (const key in shape) {
-    assignProp(json2.properties, key, processSchema(shape[key], ctx, {
+    assignProp(json3.properties, key, processSchema(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     }));
@@ -24805,21 +24805,21 @@ var objectProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
     }
   }
   if (requiredKeys.length > 0) {
-    json2.required = requiredKeys;
+    json3.required = requiredKeys;
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = processSchema(def.catchall, ctx, {
+    json3.additionalProperties = processSchema(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 }, "objectProcessor");
-var unionProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var unionProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => processSchema(x, ctx, {
@@ -24827,12 +24827,12 @@ var unionProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 }, "unionProcessor");
-var intersectionProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var intersectionProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
@@ -24847,13 +24847,13 @@ var intersectionProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params)
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
   ctx.intersections.push(allOf);
 }, "intersectionProcessor");
 var tupleProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
@@ -24875,70 +24875,70 @@ var tupleProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const maxItems = def.items.length;
   const isClosed = !def.rest;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (isClosed) {
-      json2.items = false;
+      json3.items = false;
     } else if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (isClosed) {
-      json2.additionalItems = false;
+      json3.additionalItems = false;
     } else if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   }
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 }, "tupleProcessor");
-function stringifyKeyNames(bySchema, json2, visited) {
-  if (json2.$ref) {
-    if (visited.has(json2))
-      return json2;
-    visited.add(json2);
-    const def = bySchema.get(json2)?.def;
+function stringifyKeyNames(bySchema, json3, visited) {
+  if (json3.$ref) {
+    if (visited.has(json3))
+      return json3;
+    visited.add(json3);
+    const def = bySchema.get(json3)?.def;
     if (!def)
-      return json2;
+      return json3;
     const inlined = stringifyKeyNames(bySchema, def, visited);
-    return inlined === def ? json2 : inlined;
+    return inlined === def ? json3 : inlined;
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    const branches = json2[keyword];
+    const branches = json3[keyword];
     if (!Array.isArray(branches))
       continue;
     const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
     if (mapped.some((branch, i) => branch !== branches[i]))
-      json2 = { ...json2, [keyword]: mapped };
+      json3 = { ...json3, [keyword]: mapped };
   }
-  const types = Array.isArray(json2.type) ? json2.type : [json2.type];
+  const types = Array.isArray(json3.type) ? json3.type : [json3.type];
   const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
-  const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
+  const values = json3.enum ?? (json3.const !== void 0 ? [json3.const] : void 0);
   if (!numericType && !values?.some((v) => typeof v === "number"))
-    return json2;
-  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json2;
+    return json3;
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format, id, ...rest } = json3;
   if (rest.enum)
     rest.enum = rest.enum.map((v) => typeof v === "number" ? String(v) : v);
   else if (typeof rest.const === "number")
@@ -24980,9 +24980,9 @@ function rewriteKeyNames(ctx) {
 }
 __name(rewriteKeyNames, "rewriteKeyNames");
 var recordProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
@@ -24990,13 +24990,13 @@ var recordProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json2.patternProperties, exactPattern(pattern).source, valueSchema);
+      assignProp(json3.patternProperties, exactPattern(pattern).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = processSchema(def.keyType, ctx, {
+      json3.propertyNames = processSchema(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
@@ -25008,7 +25008,7 @@ var recordProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
       }
       pending.push(schema);
     }
-    json2.additionalProperties = processSchema(def.valueType, ctx, {
+    json3.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -25018,19 +25018,19 @@ var recordProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   if (keyValues && !def.partial && !omittableOnInput) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json2.required = validKeyValues.map(String);
+      json3.required = validKeyValues.map(String);
     }
   }
 }, "recordProcessor");
-var nullableProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var nullableProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 }, "nullableProcessor");
 var nonoptionalProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
@@ -25040,7 +25040,7 @@ var nonoptionalProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) =
   seen.ref = def.innerType;
 }, "nonoptionalProcessor");
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
-function serializeDefaultValue(value, schema, ctx, json2, params) {
+function serializeDefaultValue(value, schema, ctx, json3, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
@@ -25050,31 +25050,31 @@ function serializeDefaultValue(value, schema, ctx, json2, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
 __name(serializeDefaultValue, "serializeDefaultValue");
-var defaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var defaultProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2.default = value;
+    json3.default = value;
 }, "defaultProcessor");
-var prefaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var prefaultProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io !== "input")
     return;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2._prefault = value;
+    json3._prefault = value;
 }, "prefaultProcessor");
-var catchProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var catchProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -25083,10 +25083,10 @@ var catchProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema, ctx, json3, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 }, "catchProcessor");
 var pipeProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -25096,12 +25096,12 @@ var pipeProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 }, "pipeProcessor");
-var readonlyProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
+var readonlyProcessor = /* @__PURE__ */ __name((schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 }, "readonlyProcessor");
 var promiseProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -25750,7 +25750,7 @@ var _ZodString = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     format: /* @__PURE__ */ __name((inst) => aggregateChecks(inst).format ?? null, "format"),
@@ -26141,7 +26141,7 @@ var ZodNumber = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
     inst.isFinite = true;
   },
   /* @__PURE__ */ util_exports.derived({
@@ -26237,7 +26237,7 @@ __name(uint32, "uint32");
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -26248,7 +26248,7 @@ var ZodBigInt = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     minValue: /* @__PURE__ */ __name((inst) => aggregateChecks(inst).minimum ?? null, "minValue"),
@@ -26309,7 +26309,7 @@ __name(uint64, "uint64");
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -26318,7 +26318,7 @@ __name(symbol, "symbol");
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -26327,7 +26327,7 @@ __name(_undefined3, "_undefined");
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -26336,7 +26336,7 @@ __name(_null3, "_null");
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -26345,7 +26345,7 @@ __name(any, "any");
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -26354,7 +26354,7 @@ __name(unknown, "unknown");
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -26363,7 +26363,7 @@ __name(never, "never");
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -26374,7 +26374,7 @@ var ZodDate = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodDate.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
     inst.min = (value, params) => inst.check(_gte(value, params));
     inst.max = (value, params) => inst.check(_lte(value, params));
   },
@@ -26397,7 +26397,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
 }, {
   min(n, params) {
@@ -26429,7 +26429,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 }, {
   keyof() {
@@ -26505,7 +26505,7 @@ __name(looseObject, "looseObject");
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -26519,7 +26519,7 @@ __name(union, "union");
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -26547,7 +26547,7 @@ __name(discriminatedUnion, "discriminatedUnion");
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -26561,7 +26561,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
 }, {
   rest(rest) {
     return this.clone({
@@ -26595,7 +26595,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -26640,7 +26640,7 @@ var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -26661,7 +26661,7 @@ var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -26678,7 +26678,7 @@ __name(set, "set");
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = [...inst._zod.values];
   const keys = new Set(Object.keys(def.entries));
@@ -26733,7 +26733,7 @@ __name(nativeEnum, "nativeEnum");
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -26755,7 +26755,7 @@ __name(literal, "literal");
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -26768,7 +26768,7 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -26808,7 +26808,7 @@ __name(transform, "transform");
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -26821,7 +26821,7 @@ __name(optional, "optional");
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -26834,7 +26834,7 @@ __name(exactOptional, "exactOptional");
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -26851,7 +26851,7 @@ __name(nullish2, "nullish");
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -26868,7 +26868,7 @@ __name(_default2, "_default");
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -26884,7 +26884,7 @@ __name(prefault, "prefault");
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -26898,7 +26898,7 @@ __name(nonoptional, "nonoptional");
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -26911,7 +26911,7 @@ __name(success, "success");
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -26926,7 +26926,7 @@ __name(_catch2, "_catch");
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -26935,7 +26935,7 @@ __name(nan, "nan");
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -26980,7 +26980,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -26993,7 +26993,7 @@ __name(readonly, "readonly");
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -27006,7 +27006,7 @@ __name(templateLiteral, "templateLiteral");
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -27019,7 +27019,7 @@ __name(lazy, "lazy");
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -27032,7 +27032,7 @@ __name(promise, "promise");
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -27045,7 +27045,7 @@ __name(_function, "_function");
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -28358,13 +28358,13 @@ var getPattern = /* @__PURE__ */ __name((label, next) => {
   }
   return null;
 }, "getPattern");
-var tryDecode = /* @__PURE__ */ __name((str, decoder) => {
+var tryDecode = /* @__PURE__ */ __name((str, decoder2) => {
   try {
-    return decoder(str);
+    return decoder2(str);
   } catch {
     return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
       try {
-        return decoder(match2);
+        return decoder2(match2);
       } catch {
         return match2;
       }
@@ -30148,6 +30148,90 @@ var Hono3 = class extends Hono {
 // ../node_modules/.bun/hono@4.13.16/node_modules/hono/dist/helper/factory/index.js
 var createMiddleware = /* @__PURE__ */ __name((middleware) => middleware, "createMiddleware");
 
+// src/access.ts
+function accessConfig(env) {
+  if (!env.ACCESS_TEAM || !env.ACCESS_AUD) return null;
+  const emails = (env.ACCESS_EMAILS ?? "").split(",").map((e) => e.trim().toLowerCase()).filter(Boolean);
+  return { team: env.ACCESS_TEAM, aud: env.ACCESS_AUD, emails };
+}
+__name(accessConfig, "accessConfig");
+var decoder = new TextDecoder();
+function b64url(s) {
+  const pad = s.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((s.length + 3) % 4);
+  const bin = atob(pad);
+  const out = new Uint8Array(new ArrayBuffer(bin.length));
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+__name(b64url, "b64url");
+function json2(part) {
+  try {
+    const v = JSON.parse(decoder.decode(b64url(part)));
+    return v && typeof v === "object" ? v : null;
+  } catch {
+    return null;
+  }
+}
+__name(json2, "json");
+async function verifyAccess(token, cfg, keys, now = Date.now()) {
+  if (!token) return { ok: false, why: "no token" };
+  const parts = token.split(".");
+  if (parts.length !== 3) return { ok: false, why: "malformed" };
+  const [h = "", p = "", s = ""] = parts;
+  const header = json2(h);
+  const payload = json2(p);
+  if (!header || !payload) return { ok: false, why: "malformed" };
+  if (header.alg !== "RS256" || typeof header.kid !== "string") {
+    return { ok: false, why: "unexpected algorithm" };
+  }
+  let signature;
+  try {
+    signature = b64url(s);
+  } catch {
+    return { ok: false, why: "malformed" };
+  }
+  const byKid = /* @__PURE__ */ __name((list) => list.find((k) => k.kid === header.kid), "byKid");
+  const jwk = byKid(await keys(cfg.team, false)) ?? byKid(await keys(cfg.team, true));
+  if (!jwk) return { ok: false, why: "unknown key" };
+  const key = await crypto.subtle.importKey(
+    "jwk",
+    { kty: jwk.kty, n: jwk.n, e: jwk.e },
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  const signed = new TextEncoder().encode(`${h}.${p}`);
+  if (!await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key, signature, signed)) {
+    return { ok: false, why: "bad signature" };
+  }
+  const aud = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
+  if (!aud.includes(cfg.aud)) return { ok: false, why: "wrong audience" };
+  if (payload.iss !== `https://${cfg.team}`) return { ok: false, why: "wrong issuer" };
+  const secs = now / 1e3;
+  if (typeof payload.exp !== "number" || payload.exp <= secs) return { ok: false, why: "expired" };
+  if (typeof payload.nbf === "number" && payload.nbf > secs + 60) {
+    return { ok: false, why: "not yet valid" };
+  }
+  const email3 = typeof payload.email === "string" ? payload.email.trim().toLowerCase() : "";
+  if (!email3 || !cfg.emails.includes(email3)) return { ok: false, why: "email not allowed" };
+  return { ok: true, email: email3 };
+}
+__name(verifyAccess, "verifyAccess");
+function fetchedKeys(fetcher = fetch) {
+  let cached2 = null;
+  return async (team, fresh) => {
+    if (!fresh && cached2 && cached2.team === team && Date.now() - cached2.at < 6e5) {
+      return cached2.keys;
+    }
+    const r = await fetcher(`https://${team}/cdn-cgi/access/certs`);
+    if (!r.ok) return cached2?.team === team ? cached2.keys : [];
+    const body = await r.json();
+    cached2 = { team, keys: body.keys ?? [], at: Date.now() };
+    return cached2.keys;
+  };
+}
+__name(fetchedKeys, "fetchedKeys");
+
 // ../node_modules/.bun/hono@4.13.16/node_modules/hono/dist/helper/html/index.js
 var html = /* @__PURE__ */ __name((strings, ...values) => {
   const buffer = [""];
@@ -30182,9 +30266,16 @@ th, td { text-align: left; padding: .35rem .5rem; border-bottom: 1px solid #ddd;
 pre { background: #f5f5f5; padding: .75rem; overflow-x: auto; white-space: pre-wrap; }
 form.filters { display: flex; gap: .5rem; flex-wrap: wrap; margin-bottom: 1rem; }
 .muted { color: #666; }
+p.nav { display: flex; justify-content: space-between; gap: 1rem; }
 code.key { display: block; padding: .5rem; background: #f5f5f5; margin: .25rem 0 1rem; }
 `;
-function layout(title, body) {
+function nav(who) {
+  if (!who) return html`<p><a href="/dashboard">Brutal</a></p>`;
+  const account = who.via === "access" ? html`${who.email} · <a href="/cdn-cgi/access/logout">Sign out</a>` : html`Signed in with the read key (close the browser to sign out)`;
+  return html`<p class="nav"><a href="/dashboard">Brutal</a> <span class="muted">${account}</span></p>`;
+}
+__name(nav, "nav");
+function layout(title, body, who) {
   return html`<!doctype html>
     <html lang="en">
       <head>
@@ -30196,8 +30287,7 @@ function layout(title, body) {
         </style>
       </head>
       <body>
-        <p><a href="/">Brutal</a></p>
-        ${body}
+        ${nav(who)} ${body}
       </body>
     </html>`;
 }
@@ -30209,7 +30299,7 @@ function select(name, options, current) {
   </select>`;
 }
 __name(select, "select");
-function reportsPage(reports, q, next) {
+function reportsPage(reports, q, next, who) {
   const nextQuery = next ? new URLSearchParams({ ...q, before: next }).toString() : null;
   return layout(
     "Reports",
@@ -30229,7 +30319,7 @@ function reportsPage(reports, q, next) {
       (r) => html`<tr>
                   <td class="muted">${r.created_at.slice(0, 16).replace("T", " ")}</td>
                   <td>${r.kind}</td>
-                  <td><a href="/reports/${r.id}">${r.title}</a></td>
+                  <td><a href="/dashboard/reports/${r.id}">${r.title}</a></td>
                   <td>${r.tool_name ?? ""}</td>
                   <td>${r.impact ?? ""}</td>
                   <td>${r.status}</td>
@@ -30237,11 +30327,12 @@ function reportsPage(reports, q, next) {
     )}
             </tbody>
           </table>`}
-      ${nextQuery ? html`<p><a href="/?${nextQuery}">Older</a></p>` : ""}`
+      ${nextQuery ? html`<p><a href="/dashboard?${nextQuery}">Older</a></p>` : ""}`,
+    who
   );
 }
 __name(reportsPage, "reportsPage");
-function reportPage(r) {
+function reportPage(r, who) {
   const { recent_tool_calls: calls = [], ...context } = r.context;
   return layout(
     r.title,
@@ -30270,7 +30361,8 @@ function reportPage(r) {
             </tbody>
           </table>`}
       <h2>Context</h2>
-      <pre>${JSON.stringify(context, null, 2)}</pre>`
+      <pre>${JSON.stringify(context, null, 2)}</pre>`,
+    who
   );
 }
 __name(reportPage, "reportPage");
@@ -30285,7 +30377,7 @@ function setupPage(state) {
         <code class="key">${keys.ingest}</code>
         <p>Read key, for the dashboard, the CLI and coding agents (it reads and triages):</p>
         <code class="key">${keys.read}</code>
-        <p><a href="/">Open the dashboard</a> with any username and the read key as the password.</p>`
+        <p><a href="/dashboard">Open the dashboard</a> with any username and the read key as the password, or set up Cloudflare Access with <code>brutal-server access</code>.</p>`
     );
   }
   if (state.claimed) {
@@ -40405,7 +40497,7 @@ async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE
     return { tooLarge: false, text: "" };
   }
   const reader = request.body.getReader();
-  const decoder = new TextDecoder();
+  const decoder2 = new TextDecoder();
   let received = 0;
   let text = "";
   try {
@@ -40418,12 +40510,12 @@ async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE
       if (received > maxBytes) {
         return { tooLarge: true };
       }
-      text += decoder.decode(value, { stream: true });
+      text += decoder2.decode(value, { stream: true });
     }
   } finally {
     reader.releaseLock();
   }
-  return { tooLarge: false, text: text + decoder.decode() };
+  return { tooLarge: false, text: text + decoder2.decode() };
 }
 __name(readRequestBody, "readRequestBody");
 
@@ -41189,7 +41281,7 @@ data:
 // src/mcp.ts
 function buildServer(db, key) {
   const server = new McpServer({ name: "brutal", version: "0.1.0" });
-  const json2 = /* @__PURE__ */ __name((value) => ({
+  const json3 = /* @__PURE__ */ __name((value) => ({
     content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
   }), "json");
   if (key.kind === "ingest") {
@@ -41226,7 +41318,7 @@ function buildServer(db, key) {
     async (filter) => {
       const { reports, next } = await listReports(db, filter);
       const rows = reports.map(({ details: _d, context: _c, ...r }) => r);
-      return json2({ reports: rows, next });
+      return json3({ reports: rows, next });
     }
   );
   server.registerTool(
@@ -41238,7 +41330,7 @@ function buildServer(db, key) {
     async ({ id }) => {
       const report = await getReport(db, id);
       if (!report) return { isError: true, content: [{ type: "text", text: `No report ${id}.` }] };
-      return json2(report);
+      return json3(report);
     }
   );
   server.registerTool(
@@ -41254,7 +41346,7 @@ function buildServer(db, key) {
     async ({ id, ...update }) => {
       const report = await updateReport(db, id, update);
       if (!report) return { isError: true, content: [{ type: "text", text: `No report ${id}.` }] };
-      return json2(report);
+      return json3(report);
     }
   );
   server.registerTool(
@@ -41266,7 +41358,7 @@ function buildServer(db, key) {
         limit: external_exports.number().int().min(1).max(200).optional()
       }
     },
-    async ({ before, limit }) => json2(await listReports(db, { kind: "eval_candidate", before, limit }))
+    async ({ before, limit }) => json3(await listReports(db, { kind: "eval_candidate", before, limit }))
   );
   return server;
 }
@@ -41334,8 +41426,9 @@ __name(claim2, "claim");
 
 // src/app.ts
 var problem = /* @__PURE__ */ __name((error62, status, extra = {}) => Response.json({ error: error62, ...extra }, { status }), "problem");
-function createApp() {
+function createApp(options = {}) {
   const app = new Hono3();
+  const accessKeys = options.accessKeys ?? fetchedKeys();
   app.use(async (c, next) => {
     c.set("db", await migrated(c.env.DB));
     await next();
@@ -41388,6 +41481,22 @@ function createApp() {
     return c.html(setupPage({ wrongCode: true }), 403);
   });
   const dashboard = createMiddleware(async (c, next) => {
+    const access = accessConfig(c.env);
+    if (access) {
+      const verdict = await verifyAccess(
+        c.req.header("cf-access-jwt-assertion"),
+        access,
+        accessKeys
+      );
+      if (!verdict.ok) {
+        return c.text(
+          "Sign in through Cloudflare Access to see this dashboard. If you came here through it, your email is not one this instance lets in.",
+          403
+        );
+      }
+      c.set("signedIn", { via: "access", email: verdict.email });
+      return next();
+    }
     const secret = secretFrom(c.req.header("authorization"));
     const key = secret ? await findKey(c.var.db, secret) : null;
     if (key?.kind !== "read") {
@@ -41396,16 +41505,19 @@ function createApp() {
         headers: { "WWW-Authenticate": 'Basic realm="brutal", charset="UTF-8"' }
       });
     }
+    c.set("signedIn", { via: "read-key" });
     await next();
   });
-  app.get("/", dashboard, async (c) => {
+  app.get("/", (c) => c.redirect("/dashboard"));
+  app.get("/reports/:id", (c) => c.redirect(`/dashboard/reports/${c.req.param("id")}`, 301));
+  app.get("/dashboard", dashboard, async (c) => {
     const q = c.req.query();
     const page = await listReports(c.var.db, q);
-    return c.html(reportsPage(page.reports, q, page.next));
+    return c.html(reportsPage(page.reports, q, page.next, c.var.signedIn));
   });
-  app.get("/reports/:id", dashboard, async (c) => {
+  app.get("/dashboard/reports/:id", dashboard, async (c) => {
     const report = await getReport(c.var.db, c.req.param("id"));
-    return report ? c.html(reportPage(report)) : c.notFound();
+    return report ? c.html(reportPage(report, c.var.signedIn)) : c.notFound();
   });
   return app;
 }