@open-macaron/review 0.3.1 → 0.3.2

package/macaron-review.mjs

@@ -9173,434 +9173,6 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-// ../../node_modules/.pnpm/deepmerge-ts@8.0.2/node_modules/deepmerge-ts/dist/index.mjs
-var actions = {
-  defaultMerge: /* @__PURE__ */ Symbol("deepmerge-ts: default merge"),
-  skip: /* @__PURE__ */ Symbol("deepmerge-ts: skip")
-};
-var actionsInto = {
-  defaultMerge: actions.defaultMerge
-};
-function defaultMetaDataUpdater(previousMeta, mergeInfo) {
-  const ancestor = {
-    key: mergeInfo.key,
-    parents: mergeInfo.parents,
-    values: mergeInfo.values,
-    result: mergeInfo.result
-  };
-  const prevHierarchy = previousMeta?.hierarchy;
-  return {
-    ...ancestor,
-    hierarchy: prevHierarchy === void 0 ? [ancestor] : [...prevHierarchy, ancestor]
-  };
-}
-function defaultFilterValues(values, meta3) {
-  return values.includes(void 0) ? values.filter((value) => value !== void 0) : values;
-}
-function shouldFallbackToDefault(utils, fallback, result) {
-  return result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions[fallback] !== utils.defaultMergeFunctions[fallback];
-}
-function resolveCustomMergeFunctions(options, defaultMergeFunctions) {
-  return {
-    ...defaultMergeFunctions,
-    ...Object.fromEntries(Object.entries(options).filter(([key]) => Object.hasOwn(defaultMergeFunctions, key)).map(([key, option]) => option === false ? [key, defaultMergeFunctions.mergeOthers] : typeof option === "function" ? [key, option] : [key, defaultMergeFunctions[key]]))
-  };
-}
-function mergeArrays$1(values, utils, meta3) {
-  return values.flat();
-}
-function mergeSets$1(values, utils, meta3) {
-  const result = /* @__PURE__ */ new Set();
-  for (const set2 of values) {
-    for (const element of set2) {
-      result.add(element);
-    }
-  }
-  return result;
-}
-function mergeOthers$1(values, utils, meta3) {
-  return values.at(-1);
-}
-var ObjectType;
-(function(ObjectType2) {
-  ObjectType2[ObjectType2["NOT"] = 0] = "NOT";
-  ObjectType2[ObjectType2["RECORD"] = 1] = "RECORD";
-  ObjectType2[ObjectType2["ARRAY"] = 2] = "ARRAY";
-  ObjectType2[ObjectType2["SET"] = 3] = "SET";
-  ObjectType2[ObjectType2["MAP"] = 4] = "MAP";
-  ObjectType2[ObjectType2["OTHER"] = 5] = "OTHER";
-})(ObjectType || (ObjectType = {}));
-function getObjectType(object2) {
-  if (typeof object2 !== "object" || object2 === null) {
-    return ObjectType.NOT;
-  }
-  if (Array.isArray(object2)) {
-    return ObjectType.ARRAY;
-  }
-  if (isRecord(object2)) {
-    return ObjectType.RECORD;
-  }
-  if (object2 instanceof Set) {
-    return ObjectType.SET;
-  }
-  if (object2 instanceof Map) {
-    return ObjectType.MAP;
-  }
-  return ObjectType.OTHER;
-}
-function getKeysOfObjects(objects) {
-  const keys = /* @__PURE__ */ new Set();
-  for (const currentObject of objects) {
-    const stringKeys = Object.keys(currentObject);
-    for (const stringKey of stringKeys) {
-      keys.add(stringKey);
-    }
-    const symbols = Object.getOwnPropertySymbols(currentObject);
-    if (symbols.length > 0) {
-      for (const symbol2 of symbols) {
-        if (Object.prototype.propertyIsEnumerable.call(currentObject, symbol2)) {
-          keys.add(symbol2);
-        }
-      }
-    }
-  }
-  return keys;
-}
-function getKeysOfObject(object2) {
-  const symbols = Object.getOwnPropertySymbols(object2).filter((symbol2) => Object.prototype.propertyIsEnumerable.call(object2, symbol2));
-  return [...Object.keys(object2), ...symbols];
-}
-function objectHasProperty(object2, property) {
-  return typeof object2 === "object" && Object.prototype.propertyIsEnumerable.call(object2, property);
-}
-function isRecord(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null || prototype === Object.prototype) {
-    return true;
-  }
-  const objectToString = Object.prototype.toString.call(value);
-  if (objectToString !== "[object Object]" && objectToString !== "[object Module]") {
-    return false;
-  }
-  const { constructor } = value;
-  if (constructor === void 0) {
-    return true;
-  }
-  const constructorPrototype = constructor.prototype;
-  if (constructorPrototype === null || typeof constructorPrototype !== "object") {
-    return false;
-  }
-  const constructorToString = Object.prototype.toString.call(constructorPrototype);
-  if (constructorToString !== "[object Object]" && constructorToString !== "[object Module]") {
-    return false;
-  }
-  if (!Object.hasOwn(constructorPrototype, "isPrototypeOf")) {
-    return false;
-  }
-  return true;
-}
-function getCyclicReferenceDepth(object2, hierarchy, index) {
-  if (hierarchy === void 0 || hierarchy.length === 0) {
-    return 0;
-  }
-  let mut_depth = 1;
-  for (let mut_index = hierarchy.length - 1; mut_index >= 0; mut_index--) {
-    const { parents } = hierarchy[mut_index];
-    if (parents[index] === object2 || parents.includes(object2)) {
-      return mut_depth;
-    }
-    mut_depth += 1;
-  }
-  return 0;
-}
-function getMetaDataHierarchy(meta3) {
-  return meta3?.hierarchy;
-}
-function mergeRecords$1(values, utils, meta3) {
-  if (values.length === 2) {
-    const result = {};
-    const mergeProperty = (key, propValues) => {
-      const updatedMeta = utils.metaDataUpdater(meta3, {
-        key,
-        parents: values,
-        values: propValues,
-        result
-      });
-      const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
-      if (propertyResult === actions.skip) {
-        return;
-      }
-      if (key === "__proto__") {
-        Object.defineProperty(result, key, {
-          value: propertyResult,
-          configurable: true,
-          enumerable: true,
-          writable: true
-        });
-      } else {
-        result[key] = propertyResult;
-      }
-    };
-    const firstValue = values[0];
-    const secondValue = values[1];
-    for (const key of getKeysOfObject(firstValue)) {
-      mergeProperty(key, objectHasProperty(secondValue, key) ? [firstValue[key], secondValue[key]] : [firstValue[key]]);
-    }
-    for (const key of getKeysOfObject(secondValue)) {
-      if (!objectHasProperty(firstValue, key)) {
-        mergeProperty(key, [secondValue[key]]);
-      }
-    }
-    return result;
-  }
-  return mergeRecordsGeneral(values, utils, meta3);
-}
-function mergeRecordsGeneral(values, utils, meta3) {
-  const result = {};
-  for (const key of getKeysOfObjects(values)) {
-    const propValues = [];
-    for (const value of values) {
-      if (objectHasProperty(value, key)) {
-        propValues.push(value[key]);
-      }
-    }
-    const updatedMeta = utils.metaDataUpdater(meta3, {
-      key,
-      parents: values,
-      values: propValues,
-      result
-    });
-    const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
-    if (propertyResult === actions.skip) {
-      continue;
-    }
-    if (key === "__proto__") {
-      Object.defineProperty(result, key, {
-        value: propertyResult,
-        configurable: true,
-        enumerable: true,
-        writable: true
-      });
-    } else {
-      result[key] = propertyResult;
-    }
-  }
-  return result;
-}
-function mergeMaps$1(values, utils, meta3) {
-  const result = /* @__PURE__ */ new Map();
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const map2 of values) {
-    for (const [key, value] of map2) {
-      const mut_keyValues = valuesByKey.get(key);
-      if (mut_keyValues === void 0) {
-        valuesByKey.set(key, [value]);
-      } else {
-        mut_keyValues.push(value);
-      }
-    }
-  }
-  for (const [key, keyValues] of valuesByKey) {
-    const updatedMeta = utils.metaDataUpdater(meta3, {
-      key,
-      parents: values,
-      values: keyValues,
-      result
-    });
-    const keyResult = mergeUnknowns(keyValues, utils, updatedMeta);
-    if (keyResult === actions.skip) {
-      continue;
-    }
-    result.set(key, keyResult);
-  }
-  return result;
-}
-function resolveCyclicReferences(value, utils, meta3) {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  const hierarchy = getMetaDataHierarchy(meta3);
-  const depth = getCyclicReferenceDepth(value, hierarchy, 0);
-  if (hierarchy !== void 0 && depth > 0) {
-    return hierarchy[hierarchy.length - depth]?.result;
-  }
-  const type = getObjectType(value);
-  if (type === ObjectType.RECORD) {
-    const record2 = value;
-    let mut_changed = false;
-    const result = {};
-    for (const key of getKeysOfObject(record2)) {
-      const propVal = record2[key];
-      const updatedMeta = utils.metaDataUpdater(meta3, {
-        key,
-        parents: [record2],
-        values: [propVal],
-        result
-      });
-      const resolvedProp = resolveCyclicReferences(propVal, utils, updatedMeta);
-      if (resolvedProp !== propVal) {
-        mut_changed = true;
-      }
-      if (key === "__proto__") {
-        Object.defineProperty(result, key, {
-          value: resolvedProp,
-          configurable: true,
-          enumerable: true,
-          writable: true
-        });
-      } else {
-        result[key] = resolvedProp;
-      }
-    }
-    return mut_changed ? result : value;
-  }
-  return value;
-}
-function mergeCircularReferences$1(values, cyclicDepths, utils, meta3) {
-  const depth = cyclicDepths[0];
-  const hierarchy = getMetaDataHierarchy(meta3);
-  for (let mut_index = 1; mut_index < values.length; mut_index++) {
-    if (cyclicDepths[mut_index] !== depth) {
-      const lastCyclicDepth = cyclicDepths.at(-1);
-      return lastCyclicDepth === 0 ? resolveCyclicReferences(values.at(-1), utils, meta3) : hierarchy?.[hierarchy.length - lastCyclicDepth]?.result;
-    }
-  }
-  return hierarchy?.[hierarchy.length - depth]?.result;
-}
-var mergeFunctions = {
-  mergeRecords: mergeRecords$1,
-  mergeArrays: mergeArrays$1,
-  mergeSets: mergeSets$1,
-  mergeMaps: mergeMaps$1,
-  mergeCircularReferences: mergeCircularReferences$1,
-  mergeOthers: mergeOthers$1
-};
-function deepmergeCustom(options = {}, rootMetaData) {
-  const utils = getUtils$1(options, customizedDeepmerge);
-  function customizedDeepmerge(...objects) {
-    return mergeUnknowns(objects, utils, rootMetaData ?? void 0);
-  }
-  return customizedDeepmerge;
-}
-function getUtils$1(options, customizedDeepmerge) {
-  const defaultMergeFns = mergeFunctions;
-  const defaultMetaDataUpd = defaultMetaDataUpdater;
-  return {
-    defaultMergeFunctions: defaultMergeFns,
-    mergeFunctions: resolveCustomMergeFunctions(options, defaultMergeFns),
-    metaDataUpdater: typeof options.metaDataUpdater === "function" ? options.metaDataUpdater : defaultMetaDataUpd,
-    deepmerge: customizedDeepmerge,
-    useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
-    filterValues: options.filterValues === false ? void 0 : typeof options.filterValues === "function" ? options.filterValues : defaultFilterValues,
-    maxDepth: typeof options.maxDepth === "number" && !Number.isNaN(options.maxDepth) && options.maxDepth >= 0 ? options.maxDepth : 1e3,
-    actions
-  };
-}
-function mergeUnknowns(values, utils, meta3) {
-  const filteredValues = utils.filterValues?.(values, meta3) ?? values;
-  if (filteredValues.length === 0) {
-    return void 0;
-  }
-  const hierarchy = getMetaDataHierarchy(meta3);
-  const currentDepth = hierarchy?.length ?? (typeof meta3 === "number" ? meta3 : meta3?.depth ?? 0);
-  if (utils.maxDepth !== void 0 && currentDepth >= utils.maxDepth) {
-    return mergeOthers(filteredValues, utils, meta3);
-  }
-  if (filteredValues.length === 1) {
-    if (hierarchy !== void 0) {
-      const depth = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
-      if (depth > 0) {
-        return hierarchy[hierarchy.length - depth]?.result ?? hierarchy[hierarchy.length - depth]?.parents[0];
-      }
-    }
-    return mergeOthers(filteredValues, utils, meta3);
-  }
-  const type = getObjectType(filteredValues[0]);
-  if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    if (filteredValues.length === 2) {
-      if (getObjectType(filteredValues[1]) !== type) {
-        return mergeOthers(filteredValues, utils, meta3);
-      }
-      const d0 = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
-      const d1 = getCyclicReferenceDepth(filteredValues[1], hierarchy, 1);
-      if (d0 !== 0 || d1 !== 0) {
-        return mergeCircularReferences(filteredValues, [d0, d1], utils, meta3);
-      }
-    } else {
-      const cyclicDepths = new Array(filteredValues.length);
-      cyclicDepths[0] = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
-      for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
-        if (getObjectType(filteredValues[mut_index]) !== type) {
-          return mergeOthers(filteredValues, utils, meta3);
-        }
-        cyclicDepths[mut_index] = getCyclicReferenceDepth(filteredValues[mut_index], hierarchy, mut_index);
-      }
-      if (cyclicDepths.some((depth) => depth !== 0)) {
-        return mergeCircularReferences(filteredValues, cyclicDepths, utils, meta3);
-      }
-    }
-  }
-  switch (type) {
-    case ObjectType.RECORD: {
-      return mergeRecords(filteredValues, utils, meta3);
-    }
-    case ObjectType.ARRAY: {
-      return mergeArrays(filteredValues, utils, meta3);
-    }
-    case ObjectType.SET: {
-      return mergeSets(filteredValues, utils, meta3);
-    }
-    case ObjectType.MAP: {
-      return mergeMaps(filteredValues, utils, meta3);
-    }
-    default: {
-      return mergeOthers(filteredValues, utils, meta3);
-    }
-  }
-}
-function mergeRecords(values, utils, meta3) {
-  const result = utils.mergeFunctions.mergeRecords(values, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeRecords", result)) {
-    return utils.defaultMergeFunctions.mergeRecords(values, utils, meta3);
-  }
-  return result;
-}
-function mergeArrays(values, utils, meta3) {
-  const result = utils.mergeFunctions.mergeArrays(values, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeArrays", result)) {
-    return utils.defaultMergeFunctions.mergeArrays(values);
-  }
-  return result;
-}
-function mergeSets(values, utils, meta3) {
-  const result = utils.mergeFunctions.mergeSets(values, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeSets", result)) {
-    return utils.defaultMergeFunctions.mergeSets(values);
-  }
-  return result;
-}
-function mergeMaps(values, utils, meta3) {
-  const result = utils.mergeFunctions.mergeMaps(values, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeMaps", result)) {
-    return utils.defaultMergeFunctions.mergeMaps(values, utils, meta3);
-  }
-  return result;
-}
-function mergeCircularReferences(values, cyclicDepths, utils, meta3) {
-  const result = utils.mergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeCircularReferences", result)) {
-    return utils.defaultMergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta3);
-  }
-  return result;
-}
-function mergeOthers(values, utils, meta3) {
-  const result = utils.mergeFunctions.mergeOthers(values, utils, meta3);
-  if (shouldFallbackToDefault(utils, "mergeOthers", result)) {
-    return utils.defaultMergeFunctions.mergeOthers(values);
-  }
-  return result;
-}
-
 // ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -28448,885 +28020,1383 @@ function detectVersion(schema, defaultTarget) {
   if ($schema === "http://json-schema.org/draft-07/schema#") {
     return "draft-7";
   }
-  if ($schema === "http://json-schema.org/draft-04/schema#") {
-    return "draft-4";
+  if ($schema === "http://json-schema.org/draft-04/schema#") {
+    return "draft-4";
+  }
+  return defaultTarget ?? "draft-2020-12";
+}
+function applyMinItems(items, minItems) {
+  return items.map((item, index) => index < minItems ? item : item.optional());
+}
+function decodeJSONPointerSegment(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function resolveRef(ref, ctx) {
+  if (!ref.startsWith("#")) {
+    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+  }
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
+    return ctx.rootSchema;
+  }
+  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+  if (path[0] === defsKey) {
+    const key = path[1] === void 0 ? void 0 : decodeJSONPointerSegment(path[1]);
+    if (!key || !ctx.defs[key]) {
+      throw new Error(`Reference not found: ${ref}`);
+    }
+    return ctx.defs[key];
+  }
+  throw new Error(`Reference not found: ${ref}`);
+}
+function checkObjectGuards(objectSchema, guards) {
+  const guard = z.transform((value) => value).check((payload) => {
+    const value = payload.value;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return;
+    const keys = Object.getOwnPropertyNames(value);
+    if (guards.minProperties !== void 0 && keys.length < guards.minProperties) {
+      payload.issues.push({
+        origin: "object",
+        code: "too_small",
+        minimum: guards.minProperties,
+        inclusive: true,
+        message: `Too small: expected object to have >=${guards.minProperties} properties`,
+        input: value,
+        inst: objectSchema,
+        continue: true
+      });
+    }
+    if (guards.maxProperties !== void 0 && keys.length > guards.maxProperties) {
+      payload.issues.push({
+        origin: "object",
+        code: "too_big",
+        maximum: guards.maxProperties,
+        inclusive: true,
+        message: `Too big: expected object to have <=${guards.maxProperties} properties`,
+        input: value,
+        inst: objectSchema,
+        continue: true
+      });
+    }
+    if (guards.keySchema) {
+      for (const key of keys) {
+        const result = guards.keySchema.safeParse(key);
+        if (result.success)
+          continue;
+        payload.issues.push({
+          code: "invalid_key",
+          origin: "record",
+          issues: result.error.issues,
+          input: key,
+          path: [key],
+          continue: true
+        });
+      }
+    }
+  });
+  return guard.pipe(objectSchema);
+}
+function canonicalKey(value, seen) {
+  if (value === null)
+    return "z";
+  const type = typeof value;
+  if (type !== "object") {
+    if (type === "number" && Number.isNaN(value))
+      return null;
+    const raw = String(value);
+    return `${type[0]}${raw.length}:${raw}`;
+  }
+  if (seen.has(value))
+    return null;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const parts2 = [];
+      for (const item of value) {
+        const key = canonicalKey(item, seen);
+        if (key === null)
+          return null;
+        parts2.push(key);
+      }
+      return `a${parts2.length}:[${parts2.join(",")}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const parts = [];
+    for (const k of keys) {
+      const key = canonicalKey(value[k], seen);
+      if (key === null)
+        return null;
+      parts.push(`${k.length}:${k}=${key}`);
+    }
+    return `o${parts.length}:{${parts.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
+}
+var SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "items",
+  "prefixItems",
+  "additionalItems",
+  "additionalProperties",
+  "contains",
+  "propertyNames",
+  "not",
+  "if",
+  "then",
+  "else",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "contentSchema"
+]);
+var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies",
+  "$defs",
+  "definitions"
+]);
+function containsRef(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (Array.isArray(value))
+    return value.some(containsRef);
+  if (typeof value.$ref === "string")
+    return true;
+  return Object.entries(value).some(([key, sub]) => {
+    if (SCHEMA_KEYWORDS.has(key))
+      return containsRef(sub);
+    if (!SCHEMA_MAP_KEYWORDS.has(key) || typeof sub !== "object" || sub === null)
+      return false;
+    return Object.values(sub).some(containsRef);
+  });
+}
+function plural(n) {
+  return n === 1 ? "element" : "elements";
+}
+function checkArrayGuards(arraySchema, guards) {
+  const guard = z.transform((value) => value).check((payload) => {
+    const items = payload.value;
+    if (!Array.isArray(items))
+      return;
+    if (guards.uniqueItems === true) {
+      const firstSeen = /* @__PURE__ */ new Map();
+      for (let i = 0; i < items.length; i++) {
+        const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
+        if (key === null)
+          continue;
+        const first = firstSeen.get(key);
+        if (first === void 0) {
+          firstSeen.set(key, i);
+          continue;
+        }
+        payload.issues.push({
+          code: "custom",
+          message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
+          input: items,
+          path: [i],
+          continue: true
+        });
+      }
+    }
+    if (guards.containsSchema) {
+      const minContains = guards.minContains ?? 1;
+      const ceiling = guards.maxContains !== void 0 ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
+      let matches = 0;
+      for (const item of items) {
+        if (guards.containsSchema.safeParse(item).success && ++matches >= ceiling)
+          break;
+      }
+      if (matches < minContains) {
+        payload.issues.push({
+          code: "custom",
+          message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches}`,
+          input: items,
+          continue: true
+        });
+      }
+      if (guards.maxContains !== void 0 && matches > guards.maxContains) {
+        payload.issues.push({
+          code: "custom",
+          message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
+          input: items,
+          continue: true
+        });
+      }
+    }
+  });
+  return guard.pipe(arraySchema);
+}
+function getTupleRest(restSchema, ctx) {
+  if (restSchema === false) {
+    return void 0;
+  }
+  if (restSchema === void 0 || restSchema === true) {
+    return z.any();
   }
-  return defaultTarget ?? "draft-2020-12";
-}
-function applyMinItems(items, minItems) {
-  return items.map((item, index) => index < minItems ? item : item.optional());
-}
-function decodeJSONPointerSegment(segment) {
-  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+  return convertSchema(restSchema, ctx);
 }
-function resolveRef(ref, ctx) {
-  if (!ref.startsWith("#")) {
-    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+var fullTime = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+function convertBaseSchema(schema, ctx) {
+  if (schema.not !== void 0) {
+    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+      return z.never();
+    }
+    throw new Error("not is not supported in Zod (except { not: {} } for never)");
   }
-  const path = ref.slice(1).split("/").filter(Boolean);
-  if (path.length === 0) {
-    return ctx.rootSchema;
+  if (schema.unevaluatedItems !== void 0) {
+    throw new Error("unevaluatedItems is not supported");
   }
-  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path[0] === defsKey) {
-    const key = path[1] === void 0 ? void 0 : decodeJSONPointerSegment(path[1]);
-    if (!key || !ctx.defs[key]) {
-      throw new Error(`Reference not found: ${ref}`);
-    }
-    return ctx.defs[key];
+  if (schema.unevaluatedProperties !== void 0) {
+    throw new Error("unevaluatedProperties is not supported");
   }
-  throw new Error(`Reference not found: ${ref}`);
-}
-function checkObjectGuards(objectSchema, guards) {
-  const guard = z.transform((value) => value).check((payload) => {
-    const value = payload.value;
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-      return;
-    const keys = Object.getOwnPropertyNames(value);
-    if (guards.minProperties !== void 0 && keys.length < guards.minProperties) {
-      payload.issues.push({
-        origin: "object",
-        code: "too_small",
-        minimum: guards.minProperties,
-        inclusive: true,
-        message: `Too small: expected object to have >=${guards.minProperties} properties`,
-        input: value,
-        inst: objectSchema,
-        continue: true
-      });
+  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
+    throw new Error("Conditional schemas (if/then/else) are not supported");
+  }
+  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
+    throw new Error("dependentSchemas and dependentRequired are not supported");
+  }
+  if (schema.$ref) {
+    const refPath = schema.$ref;
+    if (ctx.refs.has(refPath)) {
+      return ctx.refs.get(refPath);
     }
-    if (guards.maxProperties !== void 0 && keys.length > guards.maxProperties) {
-      payload.issues.push({
-        origin: "object",
-        code: "too_big",
-        maximum: guards.maxProperties,
-        inclusive: true,
-        message: `Too big: expected object to have <=${guards.maxProperties} properties`,
-        input: value,
-        inst: objectSchema,
-        continue: true
+    if (ctx.processing.has(refPath)) {
+      return z.lazy(() => {
+        if (!ctx.refs.has(refPath)) {
+          throw new Error(`Circular reference not resolved: ${refPath}`);
+        }
+        return ctx.refs.get(refPath);
       });
     }
-    if (guards.keySchema) {
-      for (const key of keys) {
-        const result = guards.keySchema.safeParse(key);
-        if (result.success)
-          continue;
-        payload.issues.push({
-          code: "invalid_key",
-          origin: "record",
-          issues: result.error.issues,
-          input: key,
-          path: [key],
-          continue: true
-        });
-      }
+    ctx.processing.add(refPath);
+    const resolved = resolveRef(refPath, ctx);
+    const zodSchema2 = convertSchema(resolved, ctx);
+    ctx.refs.set(refPath, zodSchema2);
+    ctx.processing.delete(refPath);
+    return zodSchema2;
+  }
+  if (schema.enum !== void 0) {
+    const enumValues = schema.enum;
+    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+      return z.null();
     }
-  });
-  return guard.pipe(objectSchema);
-}
-function canonicalKey(value, seen) {
-  if (value === null)
-    return "z";
-  const type = typeof value;
-  if (type !== "object") {
-    if (type === "number" && Number.isNaN(value))
-      return null;
-    const raw = String(value);
-    return `${type[0]}${raw.length}:${raw}`;
+    if (enumValues.length === 0) {
+      return z.never();
+    }
+    if (enumValues.length === 1) {
+      return z.literal(enumValues[0]);
+    }
+    if (enumValues.every((v) => typeof v === "string")) {
+      return z.enum(enumValues);
+    }
+    const literalSchemas = enumValues.map((v) => z.literal(v));
+    if (literalSchemas.length < 2) {
+      return literalSchemas[0];
+    }
+    return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (seen.has(value))
-    return null;
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      const parts2 = [];
-      for (const item of value) {
-        const key = canonicalKey(item, seen);
-        if (key === null)
-          return null;
-        parts2.push(key);
+  if (schema.const !== void 0) {
+    return z.literal(schema.const);
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    const typeSchemas = type.map((t) => {
+      const typeSchema = { ...schema, type: t };
+      return convertBaseSchema(typeSchema, ctx);
+    });
+    if (typeSchemas.length === 0) {
+      return z.never();
+    }
+    if (typeSchemas.length === 1) {
+      return typeSchemas[0];
+    }
+    return z.union(typeSchemas);
+  }
+  if (!type) {
+    return z.any();
+  }
+  let zodSchema;
+  switch (type) {
+    case "string": {
+      let stringSchema = z.string();
+      if (schema.format) {
+        const format = schema.format;
+        if (format === "email") {
+          stringSchema = stringSchema.check(z.email());
+        } else if (format === "uri" || format === "uri-reference") {
+          stringSchema = stringSchema.check(z.url());
+        } else if (format === "uuid" || format === "guid") {
+          stringSchema = stringSchema.check(z.uuid());
+        } else if (format === "date-time") {
+          stringSchema = stringSchema.check(z.iso.datetime({ offset: true }));
+        } else if (format === "date") {
+          stringSchema = stringSchema.check(z.iso.date());
+        } else if (format === "time") {
+          stringSchema = stringSchema.check(z.regex(fullTime));
+        } else if (format === "duration") {
+          stringSchema = stringSchema.check(z.iso.duration());
+        } else if (format === "hostname") {
+          stringSchema = stringSchema.check(z.hostname());
+        } else if (format === "ipv4") {
+          stringSchema = stringSchema.check(z.ipv4());
+        } else if (format === "ipv6") {
+          stringSchema = stringSchema.check(z.ipv6());
+        } else if (format === "mac") {
+          stringSchema = stringSchema.check(z.mac());
+        } else if (format === "cidr") {
+          stringSchema = stringSchema.check(z.cidrv4());
+        } else if (format === "cidr-v6") {
+          stringSchema = stringSchema.check(z.cidrv6());
+        } else if (format === "base64") {
+          stringSchema = stringSchema.check(z.base64());
+        } else if (format === "base64url") {
+          stringSchema = stringSchema.check(z.base64url());
+        } else if (format === "e164") {
+          stringSchema = stringSchema.check(z.e164());
+        } else if (format === "credit_card") {
+          stringSchema = stringSchema.check(z.creditCard());
+        } else if (format === "iban") {
+          stringSchema = stringSchema.check(z.iban());
+        } else if (format === "jwt") {
+          stringSchema = stringSchema.check(z.jwt());
+        } else if (format === "emoji") {
+          stringSchema = stringSchema.check(z.emoji());
+        } else if (format === "nanoid") {
+          stringSchema = stringSchema.check(z.nanoid());
+        } else if (format === "cuid") {
+          stringSchema = stringSchema.check(z.cuid());
+        } else if (format === "cuid2") {
+          stringSchema = stringSchema.check(z.cuid2());
+        } else if (format === "ulid") {
+          stringSchema = stringSchema.check(z.ulid());
+        } else if (format === "xid") {
+          stringSchema = stringSchema.check(z.xid());
+        } else if (format === "ksuid") {
+          stringSchema = stringSchema.check(z.ksuid());
+        }
+      }
+      if (typeof schema.minLength === "number") {
+        stringSchema = stringSchema.min(schema.minLength);
+      }
+      if (typeof schema.maxLength === "number") {
+        stringSchema = stringSchema.max(schema.maxLength);
+      }
+      if (schema.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      }
+      zodSchema = stringSchema;
+      break;
+    }
+    case "number":
+    case "integer": {
+      let numberSchema = type === "integer" ? z.number().int() : z.number();
+      if (typeof schema.minimum === "number" && schema.exclusiveMinimum !== true) {
+        numberSchema = numberSchema.min(schema.minimum);
+      }
+      if (typeof schema.maximum === "number" && schema.exclusiveMaximum !== true) {
+        numberSchema = numberSchema.max(schema.maximum);
+      }
+      if (typeof schema.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
+        numberSchema = numberSchema.gt(schema.minimum);
+      }
+      if (typeof schema.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
+        numberSchema = numberSchema.lt(schema.maximum);
+      }
+      if (typeof schema.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema.multipleOf);
       }
-      return `a${parts2.length}:[${parts2.join(",")}]`;
+      zodSchema = numberSchema;
+      break;
     }
-    const keys = Object.keys(value).sort();
-    const parts = [];
-    for (const k of keys) {
-      const key = canonicalKey(value[k], seen);
-      if (key === null)
-        return null;
-      parts.push(`${k.length}:${k}=${key}`);
+    case "boolean": {
+      zodSchema = z.boolean();
+      break;
     }
-    return `o${parts.length}:{${parts.join(",")}}`;
-  } finally {
-    seen.delete(value);
-  }
-}
-var SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
-  "items",
-  "prefixItems",
-  "additionalItems",
-  "additionalProperties",
-  "contains",
-  "propertyNames",
-  "not",
-  "if",
-  "then",
-  "else",
-  "allOf",
-  "anyOf",
-  "oneOf",
-  "unevaluatedItems",
-  "unevaluatedProperties",
-  "contentSchema"
-]);
-var SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
-  "properties",
-  "patternProperties",
-  "dependentSchemas",
-  "dependencies",
-  "$defs",
-  "definitions"
-]);
-function containsRef(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  if (Array.isArray(value))
-    return value.some(containsRef);
-  if (typeof value.$ref === "string")
-    return true;
-  return Object.entries(value).some(([key, sub]) => {
-    if (SCHEMA_KEYWORDS.has(key))
-      return containsRef(sub);
-    if (!SCHEMA_MAP_KEYWORDS.has(key) || typeof sub !== "object" || sub === null)
-      return false;
-    return Object.values(sub).some(containsRef);
-  });
-}
-function plural(n) {
-  return n === 1 ? "element" : "elements";
-}
-function checkArrayGuards(arraySchema, guards) {
-  const guard = z.transform((value) => value).check((payload) => {
-    const items = payload.value;
-    if (!Array.isArray(items))
-      return;
-    if (guards.uniqueItems === true) {
-      const firstSeen = /* @__PURE__ */ new Map();
-      for (let i = 0; i < items.length; i++) {
-        const key = canonicalKey(items[i], /* @__PURE__ */ new Set());
-        if (key === null)
-          continue;
-        const first = firstSeen.get(key);
-        if (first === void 0) {
-          firstSeen.set(key, i);
-          continue;
+    case "null": {
+      zodSchema = z.null();
+      break;
+    }
+    case "object": {
+      const shape = {};
+      const properties = schema.properties || {};
+      const requiredSet = new Set(schema.required || []);
+      const additionalSchema = typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : void 0;
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const propZodSchema = convertSchema(propSchema, ctx);
+        assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
+      }
+      if (schema.patternProperties) {
+        const patternProps = schema.patternProperties;
+        const patternKeys = Object.keys(patternProps);
+        const looseRecords = [];
+        for (const pattern of patternKeys) {
+          const patternValue = convertSchema(patternProps[pattern], ctx);
+          const keySchema = z.string().regex(new RegExp(pattern));
+          looseRecords.push(z.looseRecord(keySchema, patternValue));
+        }
+        const schemasToIntersect = [];
+        if (Object.keys(shape).length > 0) {
+          schemasToIntersect.push(z.object(shape).passthrough());
+        }
+        schemasToIntersect.push(...looseRecords);
+        if (schemasToIntersect.length === 0) {
+          zodSchema = z.object({}).passthrough();
+        } else if (schemasToIntersect.length === 1) {
+          zodSchema = schemasToIntersect[0];
+        } else {
+          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          for (let i = 2; i < schemasToIntersect.length; i++) {
+            result = z.intersection(result, schemasToIntersect[i]);
+          }
+          zodSchema = result;
+        }
+        if (schema.additionalProperties === false) {
+          const propertyKeys = Object.keys(shape);
+          const patterns = patternKeys.map((p) => new RegExp(p));
+          const basePatternSchema = zodSchema;
+          zodSchema = zodSchema.check((payload) => {
+            if (!isPlainObject(payload.value))
+              return;
+            const unrecognized = [];
+            for (const key of Object.keys(payload.value)) {
+              if (propertyKeys.includes(key))
+                continue;
+              if (patterns.some((regex) => regex.test(key)))
+                continue;
+              unrecognized.push(key);
+            }
+            if (unrecognized.length) {
+              payload.issues.push({
+                code: "unrecognized_keys",
+                keys: unrecognized,
+                input: payload.value,
+                inst: basePatternSchema
+              });
+            }
+          });
+        }
+      } else {
+        const objectSchema = z.object(shape);
+        if (schema.additionalProperties === false) {
+          zodSchema = objectSchema.strict();
+        } else if (additionalSchema) {
+          zodSchema = objectSchema.catchall(additionalSchema);
+        } else {
+          zodSchema = objectSchema.passthrough();
         }
-        payload.issues.push({
-          code: "custom",
-          message: `Array items must be unique: element at index ${i} duplicates the one at index ${first}`,
-          input: items,
-          path: [i],
-          continue: true
-        });
       }
-    }
-    if (guards.containsSchema) {
-      const minContains = guards.minContains ?? 1;
-      const ceiling = guards.maxContains !== void 0 ? guards.maxContains + 1 : Number.POSITIVE_INFINITY;
-      let matches = 0;
-      for (const item of items) {
-        if (guards.containsSchema.safeParse(item).success && ++matches >= ceiling)
-          break;
+      const hasKeyGuard = schema.propertyNames !== void 0 && schema.propertyNames !== true;
+      const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : void 0;
+      const maxProperties = typeof schema.maxProperties === "number" ? schema.maxProperties : void 0;
+      if (hasKeyGuard || minProperties !== void 0 || maxProperties !== void 0) {
+        let keySchema;
+        if (hasKeyGuard) {
+          const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === void 0 ? { type: "string", ...schema.propertyNames } : schema.propertyNames;
+          keySchema = convertSchema(keyJSONSchema, ctx);
+        }
+        zodSchema = checkObjectGuards(zodSchema, { keySchema, minProperties, maxProperties });
       }
-      if (matches < minContains) {
-        payload.issues.push({
-          code: "custom",
-          message: `Array must contain at least ${minContains} matching ${plural(minContains)}; found ${matches}`,
-          input: items,
-          continue: true
-        });
+      break;
+    }
+    case "array": {
+      const prefixItems = schema.prefixItems;
+      const items = schema.items;
+      if (prefixItems && Array.isArray(prefixItems)) {
+        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
+        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+        const positionalItems = applyMinItems(tupleItems, minItems);
+        const rest = !Array.isArray(items) ? getTupleRest(items, ctx) : void 0;
+        const tupleSchema = z.tuple(positionalItems);
+        zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (Array.isArray(items)) {
+        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
+        const tupleItems = items.map((item) => convertSchema(item, ctx));
+        const positionalItems = applyMinItems(tupleItems, minItems);
+        const rest = getTupleRest(schema.additionalItems, ctx);
+        const tupleSchema = z.tuple(positionalItems);
+        zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (items !== void 0) {
+        const element = convertSchema(items, ctx);
+        let arraySchema = z.array(element);
+        if (typeof schema.minItems === "number") {
+          arraySchema = arraySchema.min(schema.minItems);
+        }
+        if (typeof schema.maxItems === "number") {
+          arraySchema = arraySchema.max(schema.maxItems);
+        }
+        zodSchema = arraySchema;
+      } else {
+        zodSchema = z.array(z.any());
       }
-      if (guards.maxContains !== void 0 && matches > guards.maxContains) {
-        payload.issues.push({
-          code: "custom",
-          message: `Array must contain at most ${guards.maxContains} matching ${plural(guards.maxContains)}`,
-          input: items,
-          continue: true
+      if (schema.uniqueItems === true || schema.contains !== void 0) {
+        zodSchema = checkArrayGuards(zodSchema, {
+          uniqueItems: schema.uniqueItems === true,
+          containsSchema: schema.contains !== void 0 ? convertSchema(schema.contains, ctx) : void 0,
+          minContains: typeof schema.minContains === "number" ? schema.minContains : void 0,
+          maxContains: typeof schema.maxContains === "number" ? schema.maxContains : void 0
         });
       }
+      break;
     }
-  });
-  return guard.pipe(arraySchema);
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+  return zodSchema;
 }
-function getTupleRest(restSchema, ctx) {
-  if (restSchema === false) {
-    return void 0;
+function convertSchema(schema, ctx) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
+  }
+  let baseSchema = convertBaseSchema(schema, ctx);
+  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+    const anyOfUnion = z.union(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
   }
-  if (restSchema === void 0 || restSchema === true) {
-    return z.any();
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+    const oneOfUnion = z.xor(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
   }
-  return convertSchema(restSchema, ctx);
-}
-var fullTime = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
-function convertBaseSchema(schema, ctx) {
-  if (schema.not !== void 0) {
-    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-      return z.never();
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    if (schema.allOf.length === 0) {
+      baseSchema = hasExplicitType ? baseSchema : z.any();
+    } else {
+      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      const startIdx = hasExplicitType ? 0 : 1;
+      for (let i = startIdx; i < schema.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      }
+      baseSchema = result;
     }
-    throw new Error("not is not supported in Zod (except { not: {} } for never)");
-  }
-  if (schema.unevaluatedItems !== void 0) {
-    throw new Error("unevaluatedItems is not supported");
   }
-  if (schema.unevaluatedProperties !== void 0) {
-    throw new Error("unevaluatedProperties is not supported");
+  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+    baseSchema = z.nullable(baseSchema);
   }
-  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
-    throw new Error("Conditional schemas (if/then/else) are not supported");
+  if (schema.readOnly === true) {
+    baseSchema = z.readonly(baseSchema);
   }
-  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
-    throw new Error("dependentSchemas and dependentRequired are not supported");
+  if (schema.default !== void 0) {
+    baseSchema = baseSchema.default(schema.default);
   }
-  if (schema.$ref) {
-    const refPath = schema.$ref;
-    if (ctx.refs.has(refPath)) {
-      return ctx.refs.get(refPath);
+  const extraMeta = {};
+  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+  for (const key of coreMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    if (ctx.processing.has(refPath)) {
-      return z.lazy(() => {
-        if (!ctx.refs.has(refPath)) {
-          throw new Error(`Circular reference not resolved: ${refPath}`);
-        }
-        return ctx.refs.get(refPath);
-      });
+  }
+  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+  for (const key of contentMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
     }
-    ctx.processing.add(refPath);
-    const resolved = resolveRef(refPath, ctx);
-    const zodSchema2 = convertSchema(resolved, ctx);
-    ctx.refs.set(refPath, zodSchema2);
-    ctx.processing.delete(refPath);
-    return zodSchema2;
   }
-  if (schema.enum !== void 0) {
-    const enumValues = schema.enum;
-    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-      return z.null();
+  if (schema.type === "object" && schema.$ref === void 0) {
+    if (schema.propertyNames !== void 0 && !containsRef(schema.propertyNames)) {
+      extraMeta.propertyNames = schema.propertyNames;
     }
-    if (enumValues.length === 0) {
-      return z.never();
+    for (const key of ["minProperties", "maxProperties"]) {
+      if (schema[key] !== void 0)
+        extraMeta[key] = schema[key];
     }
-    if (enumValues.length === 1) {
-      return z.literal(enumValues[0]);
+  }
+  if (schema.type === "array" && schema.$ref === void 0) {
+    if (schema.contains !== void 0 && !containsRef(schema.contains)) {
+      extraMeta.contains = schema.contains;
     }
-    if (enumValues.every((v) => typeof v === "string")) {
-      return z.enum(enumValues);
+    for (const key of ["uniqueItems", "minContains", "maxContains"]) {
+      if (schema[key] !== void 0)
+        extraMeta[key] = schema[key];
     }
-    const literalSchemas = enumValues.map((v) => z.literal(v));
-    if (literalSchemas.length < 2) {
-      return literalSchemas[0];
+  }
+  for (const key of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key)) {
+      assignProp(extraMeta, key, schema[key]);
     }
-    return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
   }
-  if (schema.const !== void 0) {
-    return z.literal(schema.const);
+  if (Object.keys(extraMeta).length > 0) {
+    ctx.registry.add(baseSchema, extraMeta);
   }
-  const type = schema.type;
-  if (Array.isArray(type)) {
-    const typeSchemas = type.map((t) => {
-      const typeSchema = { ...schema, type: t };
-      return convertBaseSchema(typeSchema, ctx);
-    });
-    if (typeSchemas.length === 0) {
-      return z.never();
-    }
-    if (typeSchemas.length === 1) {
-      return typeSchemas[0];
-    }
-    return z.union(typeSchemas);
+  if (schema.description) {
+    baseSchema = baseSchema.describe(schema.description);
   }
-  if (!type) {
-    return z.any();
+  return baseSchema;
+}
+function fromJSONSchema(schema, params) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
   }
-  let zodSchema;
-  switch (type) {
-    case "string": {
-      let stringSchema = z.string();
-      if (schema.format) {
-        const format = schema.format;
-        if (format === "email") {
-          stringSchema = stringSchema.check(z.email());
-        } else if (format === "uri" || format === "uri-reference") {
-          stringSchema = stringSchema.check(z.url());
-        } else if (format === "uuid" || format === "guid") {
-          stringSchema = stringSchema.check(z.uuid());
-        } else if (format === "date-time") {
-          stringSchema = stringSchema.check(z.iso.datetime({ offset: true }));
-        } else if (format === "date") {
-          stringSchema = stringSchema.check(z.iso.date());
-        } else if (format === "time") {
-          stringSchema = stringSchema.check(z.regex(fullTime));
-        } else if (format === "duration") {
-          stringSchema = stringSchema.check(z.iso.duration());
-        } else if (format === "hostname") {
-          stringSchema = stringSchema.check(z.hostname());
-        } else if (format === "ipv4") {
-          stringSchema = stringSchema.check(z.ipv4());
-        } else if (format === "ipv6") {
-          stringSchema = stringSchema.check(z.ipv6());
-        } else if (format === "mac") {
-          stringSchema = stringSchema.check(z.mac());
-        } else if (format === "cidr") {
-          stringSchema = stringSchema.check(z.cidrv4());
-        } else if (format === "cidr-v6") {
-          stringSchema = stringSchema.check(z.cidrv6());
-        } else if (format === "base64") {
-          stringSchema = stringSchema.check(z.base64());
-        } else if (format === "base64url") {
-          stringSchema = stringSchema.check(z.base64url());
-        } else if (format === "e164") {
-          stringSchema = stringSchema.check(z.e164());
-        } else if (format === "credit_card") {
-          stringSchema = stringSchema.check(z.creditCard());
-        } else if (format === "iban") {
-          stringSchema = stringSchema.check(z.iban());
-        } else if (format === "jwt") {
-          stringSchema = stringSchema.check(z.jwt());
-        } else if (format === "emoji") {
-          stringSchema = stringSchema.check(z.emoji());
-        } else if (format === "nanoid") {
-          stringSchema = stringSchema.check(z.nanoid());
-        } else if (format === "cuid") {
-          stringSchema = stringSchema.check(z.cuid());
-        } else if (format === "cuid2") {
-          stringSchema = stringSchema.check(z.cuid2());
-        } else if (format === "ulid") {
-          stringSchema = stringSchema.check(z.ulid());
-        } else if (format === "xid") {
-          stringSchema = stringSchema.check(z.xid());
-        } else if (format === "ksuid") {
-          stringSchema = stringSchema.check(z.ksuid());
+  let normalized;
+  try {
+    normalized = JSON.parse(JSON.stringify(schema));
+  } catch {
+    throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+  }
+  const version2 = detectVersion(normalized, params?.defaultTarget);
+  const defs = normalized.$defs || normalized.definitions || {};
+  const ctx = {
+    version: version2,
+    defs,
+    refs: /* @__PURE__ */ new Map(),
+    processing: /* @__PURE__ */ new Set(),
+    rootSchema: normalized,
+    registry: params?.registry ?? globalRegistry
+  };
+  return convertSchema(normalized, ctx);
+}
+
+// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/visit.js
+var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
+function visit(schema, fnOrHandlers) {
+  const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
+    const h = fnOrHandlers[node2._zod.def.type];
+    return h ? h(node2, rewritten) : node2;
+  };
+  const cache = /* @__PURE__ */ new Map();
+  function run2(s) {
+    const cached2 = cache.get(s);
+    if (cached2 === RESOLVING) {
+      return new $ZodLazy({
+        type: "lazy",
+        getter: () => cache.get(s)
+      });
+    }
+    if (cached2 !== void 0)
+      return cached2;
+    cache.set(s, RESOLVING);
+    const inner = mapInner(s);
+    const mapped = fn(inner, inner !== s);
+    cache.set(s, mapped);
+    return mapped;
+  }
+  function mapInner(s) {
+    const def = s._zod.def;
+    const kind = def.type;
+    switch (kind) {
+      case "object": {
+        const oldShape = def.shape;
+        const keys = Object.keys(oldShape);
+        let changed = false;
+        const newShape = {};
+        for (const k of keys) {
+          const mapped = run2(oldShape[k]);
+          if (mapped !== oldShape[k])
+            changed = true;
+          newShape[k] = mapped;
+        }
+        let newCatchall = def.catchall;
+        if (def.catchall) {
+          newCatchall = run2(def.catchall);
+          if (newCatchall !== def.catchall)
+            changed = true;
+        }
+        return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
+      }
+      case "array": {
+        const mapped = run2(def.element);
+        return mapped === def.element ? s : clone(s, { ...def, element: mapped });
+      }
+      case "tuple": {
+        const oldItems = def.items;
+        let changed = false;
+        const newItems = [];
+        for (const item of oldItems) {
+          const mapped = run2(item);
+          if (mapped !== item)
+            changed = true;
+          newItems.push(mapped);
         }
+        let newRest = def.rest;
+        if (def.rest) {
+          newRest = run2(def.rest);
+          if (newRest !== def.rest)
+            changed = true;
+        }
+        return changed ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
       }
-      if (typeof schema.minLength === "number") {
-        stringSchema = stringSchema.min(schema.minLength);
-      }
-      if (typeof schema.maxLength === "number") {
-        stringSchema = stringSchema.max(schema.maxLength);
-      }
-      if (schema.pattern) {
-        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      case "record":
+      case "map": {
+        const newKey = run2(def.keyType);
+        const newVal = run2(def.valueType);
+        return newKey === def.keyType && newVal === def.valueType ? s : clone(s, { ...def, keyType: newKey, valueType: newVal });
       }
-      zodSchema = stringSchema;
-      break;
-    }
-    case "number":
-    case "integer": {
-      let numberSchema = type === "integer" ? z.number().int() : z.number();
-      if (typeof schema.minimum === "number" && schema.exclusiveMinimum !== true) {
-        numberSchema = numberSchema.min(schema.minimum);
+      case "set": {
+        const newVal = run2(def.valueType);
+        return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
       }
-      if (typeof schema.maximum === "number" && schema.exclusiveMaximum !== true) {
-        numberSchema = numberSchema.max(schema.maximum);
+      case "union": {
+        const oldOptions = def.options;
+        let changed = false;
+        const newOptions = [];
+        for (const opt of oldOptions) {
+          const mapped = run2(opt);
+          if (mapped !== opt)
+            changed = true;
+          newOptions.push(mapped);
+        }
+        return changed ? clone(s, { ...def, options: newOptions }) : s;
       }
-      if (typeof schema.exclusiveMinimum === "number") {
-        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
-      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
-        numberSchema = numberSchema.gt(schema.minimum);
+      case "intersection": {
+        const newLeft = run2(def.left);
+        const newRight = run2(def.right);
+        return newLeft === def.left && newRight === def.right ? s : clone(s, { ...def, left: newLeft, right: newRight });
       }
-      if (typeof schema.exclusiveMaximum === "number") {
-        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
-      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
-        numberSchema = numberSchema.lt(schema.maximum);
+      case "optional":
+      case "nullable":
+      case "default":
+      case "prefault":
+      case "catch":
+      case "readonly":
+      case "nonoptional":
+      case "promise":
+      case "success": {
+        const newInner = run2(def.innerType);
+        return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
       }
-      if (typeof schema.multipleOf === "number") {
-        numberSchema = numberSchema.multipleOf(schema.multipleOf);
+      case "pipe": {
+        const newIn = run2(def.in);
+        const newOut = run2(def.out);
+        return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
       }
-      zodSchema = numberSchema;
-      break;
-    }
-    case "boolean": {
-      zodSchema = z.boolean();
-      break;
-    }
-    case "null": {
-      zodSchema = z.null();
-      break;
-    }
-    case "object": {
-      const shape = {};
-      const properties = schema.properties || {};
-      const requiredSet = new Set(schema.required || []);
-      const additionalSchema = typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : void 0;
-      for (const [key, propSchema] of Object.entries(properties)) {
-        const propZodSchema = convertSchema(propSchema, ctx);
-        assignProp(shape, key, requiredSet.has(key) ? propZodSchema : propZodSchema.optional());
+      case "function": {
+        const newInput = run2(def.input);
+        const newOutput = run2(def.output);
+        return newInput === def.input && newOutput === def.output ? s : clone(s, { ...def, input: newInput, output: newOutput });
       }
-      if (schema.patternProperties) {
-        const patternProps = schema.patternProperties;
-        const patternKeys = Object.keys(patternProps);
-        const looseRecords = [];
-        for (const pattern of patternKeys) {
-          const patternValue = convertSchema(patternProps[pattern], ctx);
-          const keySchema = z.string().regex(new RegExp(pattern));
-          looseRecords.push(z.looseRecord(keySchema, patternValue));
-        }
-        const schemasToIntersect = [];
-        if (Object.keys(shape).length > 0) {
-          schemasToIntersect.push(z.object(shape).passthrough());
-        }
-        schemasToIntersect.push(...looseRecords);
-        if (schemasToIntersect.length === 0) {
-          zodSchema = z.object({}).passthrough();
-        } else if (schemasToIntersect.length === 1) {
-          zodSchema = schemasToIntersect[0];
-        } else {
-          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
-          for (let i = 2; i < schemasToIntersect.length; i++) {
-            result = z.intersection(result, schemasToIntersect[i]);
-          }
-          zodSchema = result;
-        }
-        if (schema.additionalProperties === false) {
-          const propertyKeys = Object.keys(shape);
-          const patterns = patternKeys.map((p) => new RegExp(p));
-          const basePatternSchema = zodSchema;
-          zodSchema = zodSchema.check((payload) => {
-            if (!isPlainObject(payload.value))
-              return;
-            const unrecognized = [];
-            for (const key of Object.keys(payload.value)) {
-              if (propertyKeys.includes(key))
-                continue;
-              if (patterns.some((regex) => regex.test(key)))
-                continue;
-              unrecognized.push(key);
-            }
-            if (unrecognized.length) {
-              payload.issues.push({
-                code: "unrecognized_keys",
-                keys: unrecognized,
-                input: payload.value,
-                inst: basePatternSchema
-              });
-            }
-          });
-        }
-      } else {
-        const objectSchema = z.object(shape);
-        if (schema.additionalProperties === false) {
-          zodSchema = objectSchema.strict();
-        } else if (additionalSchema) {
-          zodSchema = objectSchema.catchall(additionalSchema);
-        } else {
-          zodSchema = objectSchema.passthrough();
-        }
+      case "lazy": {
+        const original = def.getter;
+        const { _cachedInner, ...rest } = def;
+        return clone(s, { ...rest, getter: () => run2(original()) });
       }
-      const hasKeyGuard = schema.propertyNames !== void 0 && schema.propertyNames !== true;
-      const minProperties = typeof schema.minProperties === "number" ? schema.minProperties : void 0;
-      const maxProperties = typeof schema.maxProperties === "number" ? schema.maxProperties : void 0;
-      if (hasKeyGuard || minProperties !== void 0 || maxProperties !== void 0) {
-        let keySchema;
-        if (hasKeyGuard) {
-          const keyJSONSchema = typeof schema.propertyNames === "object" && schema.propertyNames.type === void 0 ? { type: "string", ...schema.propertyNames } : schema.propertyNames;
-          keySchema = convertSchema(keyJSONSchema, ctx);
-        }
-        zodSchema = checkObjectGuards(zodSchema, { keySchema, minProperties, maxProperties });
+      // A leaf by choice: `parts` are regex fragments, not data positions.
+      case "template_literal":
+      // Leaves.
+      case "string":
+      case "number":
+      case "int":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+      case "undefined":
+      case "null":
+      case "void":
+      case "never":
+      case "any":
+      case "unknown":
+      case "date":
+      case "nan":
+      case "enum":
+      case "literal":
+      case "file":
+      case "transform":
+      case "custom":
+        return s;
+      default: {
+        kind;
+        return s;
       }
-      break;
     }
-    case "array": {
-      const prefixItems = schema.prefixItems;
-      const items = schema.items;
-      if (prefixItems && Array.isArray(prefixItems)) {
-        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
-        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
-        const positionalItems = applyMinItems(tupleItems, minItems);
-        const rest = !Array.isArray(items) ? getTupleRest(items, ctx) : void 0;
-        const tupleSchema = z.tuple(positionalItems);
-        zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-        }
-      } else if (Array.isArray(items)) {
-        const minItems = typeof schema.minItems === "number" ? schema.minItems : 0;
-        const tupleItems = items.map((item) => convertSchema(item, ctx));
-        const positionalItems = applyMinItems(tupleItems, minItems);
-        const rest = getTupleRest(schema.additionalItems, ctx);
-        const tupleSchema = z.tuple(positionalItems);
-        zodSchema = rest ? tupleSchema.rest(rest) : tupleSchema;
-        if (typeof schema.minItems === "number") {
-          zodSchema = zodSchema.check(z.minLength(schema.minItems));
-        }
-        if (typeof schema.maxItems === "number") {
-          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
-        }
-      } else if (items !== void 0) {
-        const element = convertSchema(items, ctx);
-        let arraySchema = z.array(element);
-        if (typeof schema.minItems === "number") {
-          arraySchema = arraySchema.min(schema.minItems);
-        }
-        if (typeof schema.maxItems === "number") {
-          arraySchema = arraySchema.max(schema.maxItems);
-        }
-        zodSchema = arraySchema;
-      } else {
-        zodSchema = z.array(z.any());
-      }
-      if (schema.uniqueItems === true || schema.contains !== void 0) {
-        zodSchema = checkArrayGuards(zodSchema, {
-          uniqueItems: schema.uniqueItems === true,
-          containsSchema: schema.contains !== void 0 ? convertSchema(schema.contains, ctx) : void 0,
-          minContains: typeof schema.minContains === "number" ? schema.minContains : void 0,
-          maxContains: typeof schema.maxContains === "number" ? schema.maxContains : void 0
-        });
-      }
-      break;
+  }
+  return run2(schema);
+}
+
+// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/deep-partial.js
+function deepPartial(schema) {
+  return visit(schema, {
+    object: (s) => s.partial(),
+    // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
+    union: (s) => {
+      const def = s._zod.def;
+      return def.discriminator === void 0 ? s : union(def.options);
     }
-    default:
-      throw new Error(`Unsupported type: ${type}`);
-  }
-  return zodSchema;
+  });
 }
-function convertSchema(schema, ctx) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
-  }
-  let baseSchema = convertBaseSchema(schema, ctx);
-  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
-  if (schema.anyOf && Array.isArray(schema.anyOf)) {
-    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-    const anyOfUnion = z.union(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
-  }
-  if (schema.oneOf && Array.isArray(schema.oneOf)) {
-    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-    const oneOfUnion = z.xor(options);
-    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
-  }
-  if (schema.allOf && Array.isArray(schema.allOf)) {
-    if (schema.allOf.length === 0) {
-      baseSchema = hasExplicitType ? baseSchema : z.any();
-    } else {
-      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
-      const startIdx = hasExplicitType ? 0 : 1;
-      for (let i = startIdx; i < schema.allOf.length; i++) {
-        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
-      }
-      baseSchema = result;
+
+// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/in-out.js
+function withChecks(side, checks) {
+  if (!checks?.length)
+    return side;
+  const def = side._zod.def;
+  return clone(side, mergeDefs(def, { checks: [...def.checks ?? [], ...checks] }), { parent: true });
+}
+function outSide(def) {
+  return withChecks(def.out, def.checks);
+}
+function inSide(def) {
+  return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+function input(schema) {
+  return visit(schema, {
+    pipe: (s) => inSide(s._zod.def),
+    // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+    default: (s, rewritten) => rewritten ? optional(s._zod.def.innerType) : s,
+    // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+    catch: (s, rewritten) => rewritten ? s._zod.def.innerType : s
+  });
+}
+function output(schema) {
+  return visit(schema, {
+    pipe: (s) => outSide(s._zod.def),
+    // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+    prefault: (s, rewritten) => rewritten ? s._zod.def.innerType : s
+  });
+}
+
+// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/coerce.js
+var coerce_exports = {};
+__export(coerce_exports, {
+  bigint: () => bigint3,
+  boolean: () => boolean3,
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint3(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date4(params) {
+  return _coercedDate(ZodDate, params);
+}
+
+// ../contracts/src/capability.ts
+var Capability = external_exports.enum(["triage", "plan", "implement", "reproduce", "verify", "review", "remember"]);
+
+// ../contracts/src/ids.ts
+var GitHubLogin = external_exports.string().regex(/^(?!-)[A-Za-z0-9-]{1,39}(?<!-)(\[bot\])?$/, "not a GitHub login").brand();
+var RepoSlug = external_exports.string().regex(/^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/, "expected owner/name").brand();
+var CommitSha = external_exports.string().regex(/^[0-9a-f]{40}$/, "expected a full commit SHA").brand();
+var BotBranch = external_exports.string().regex(/^macaron\/[0-9]+-[a-z0-9-]{1,48}$/, "expected macaron/<number>-<slug>").brand();
+var Ticket = external_exports.string().regex(/^t_[A-Za-z0-9_-]{32,64}$/, "not a ticket").brand();
+var Slug = external_exports.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "expected kebab-case").max(64).brand();
+var Usd = external_exports.number().nonnegative().max(1e3);
+
+// ../contracts/src/accounts.ts
+var Timestamp = external_exports.iso.datetime({ offset: true });
+var Capabilities = external_exports.array(Capability).min(1, "grant at least one capability").refine((capabilities) => new Set(capabilities).size === capabilities.length, "a capability appears twice");
+var Me = external_exports.object({
+  githubId: external_exports.int().positive(),
+  githubLogin: GitHubLogin,
+  name: external_exports.string(),
+  avatarUrl: external_exports.url().nullable(),
+  role: external_exports.enum(["user", "admin"]),
+  capabilities: external_exports.array(Capability)
+});
+var InvitationStatus = external_exports.enum(["pending", "accepted", "revoked", "expired"]);
+var Invitation = external_exports.object({
+  id: external_exports.uuid(),
+  githubId: external_exports.int().positive(),
+  githubLogin: GitHubLogin,
+  capabilities: external_exports.array(Capability),
+  invitedBy: GitHubLogin,
+  createdAt: Timestamp,
+  expiresAt: Timestamp,
+  status: InvitationStatus
+});
+var Invitations = external_exports.object({ invitations: external_exports.array(Invitation) });
+var CreateInvitation = external_exports.object({ githubLogin: GitHubLogin, capabilities: Capabilities });
+var UserAccount = external_exports.object({
+  id: external_exports.string().min(1),
+  githubId: external_exports.int().positive(),
+  githubLogin: GitHubLogin,
+  name: external_exports.string(),
+  avatarUrl: external_exports.url().nullable(),
+  role: external_exports.enum(["user", "admin"]),
+  capabilities: external_exports.array(Capability),
+  createdAt: Timestamp,
+  lastSignInAt: Timestamp.nullable()
+});
+var UserAccounts = external_exports.object({ users: external_exports.array(UserAccount) });
+var SetCapabilities = external_exports.object({ capabilities: Capabilities });
+var FieldError = external_exports.object({ error: external_exports.string(), field: external_exports.string(), message: external_exports.string() });
+var UsageRun = external_exports.object({
+  id: external_exports.uuid(),
+  repo: external_exports.string(),
+  number: external_exports.int().positive(),
+  kind: external_exports.enum(["issue", "pull"]),
+  mode: external_exports.string(),
+  status: external_exports.enum(["pending", "dispatched", "running", "completed", "failed", "aborted"]),
+  model: external_exports.string(),
+  /** Settled cost; null until the backend reported the run's final usage. */
+  costUsd: external_exports.number().nonnegative().nullable(),
+  createdAt: Timestamp
+});
+var UsagePage = external_exports.object({
+  runs: external_exports.array(UsageRun),
+  /** Pass as `before` for the next page; null on the last one. */
+  nextCursor: external_exports.string().nullable(),
+  /** This calendar month (UTC), settled runs only. */
+  monthUsd: external_exports.number().nonnegative(),
+  monthRuns: external_exports.int().nonnegative()
+});
+var UsageQuery = external_exports.object({
+  before: external_exports.string().optional(),
+  limit: external_exports.coerce.number().int().min(1).max(100).default(25)
+});
+
+// ../contracts/src/auth-fields.ts
+var AUTH_COOKIE_PREFIX = "macaron";
+var SESSION_COOKIE = `__Secure-${AUTH_COOKIE_PREFIX}.session_token`;
+
+// ../../node_modules/.pnpm/deepmerge-ts@8.0.2/node_modules/deepmerge-ts/dist/index.mjs
+var actions = {
+  defaultMerge: /* @__PURE__ */ Symbol("deepmerge-ts: default merge"),
+  skip: /* @__PURE__ */ Symbol("deepmerge-ts: skip")
+};
+var actionsInto = {
+  defaultMerge: actions.defaultMerge
+};
+function defaultMetaDataUpdater(previousMeta, mergeInfo) {
+  const ancestor = {
+    key: mergeInfo.key,
+    parents: mergeInfo.parents,
+    values: mergeInfo.values,
+    result: mergeInfo.result
+  };
+  const prevHierarchy = previousMeta?.hierarchy;
+  return {
+    ...ancestor,
+    hierarchy: prevHierarchy === void 0 ? [ancestor] : [...prevHierarchy, ancestor]
+  };
+}
+function defaultFilterValues(values, meta3) {
+  return values.includes(void 0) ? values.filter((value) => value !== void 0) : values;
+}
+function shouldFallbackToDefault(utils, fallback, result) {
+  return result === actions.defaultMerge || utils.useImplicitDefaultMerging && result === void 0 && utils.mergeFunctions[fallback] !== utils.defaultMergeFunctions[fallback];
+}
+function resolveCustomMergeFunctions(options, defaultMergeFunctions) {
+  return {
+    ...defaultMergeFunctions,
+    ...Object.fromEntries(Object.entries(options).filter(([key]) => Object.hasOwn(defaultMergeFunctions, key)).map(([key, option]) => option === false ? [key, defaultMergeFunctions.mergeOthers] : typeof option === "function" ? [key, option] : [key, defaultMergeFunctions[key]]))
+  };
+}
+function mergeArrays$1(values, utils, meta3) {
+  return values.flat();
+}
+function mergeSets$1(values, utils, meta3) {
+  const result = /* @__PURE__ */ new Set();
+  for (const set2 of values) {
+    for (const element of set2) {
+      result.add(element);
     }
   }
-  if (schema.nullable === true && ctx.version === "openapi-3.0") {
-    baseSchema = z.nullable(baseSchema);
+  return result;
+}
+function mergeOthers$1(values, utils, meta3) {
+  return values.at(-1);
+}
+var ObjectType;
+(function(ObjectType2) {
+  ObjectType2[ObjectType2["NOT"] = 0] = "NOT";
+  ObjectType2[ObjectType2["RECORD"] = 1] = "RECORD";
+  ObjectType2[ObjectType2["ARRAY"] = 2] = "ARRAY";
+  ObjectType2[ObjectType2["SET"] = 3] = "SET";
+  ObjectType2[ObjectType2["MAP"] = 4] = "MAP";
+  ObjectType2[ObjectType2["OTHER"] = 5] = "OTHER";
+})(ObjectType || (ObjectType = {}));
+function getObjectType(object2) {
+  if (typeof object2 !== "object" || object2 === null) {
+    return ObjectType.NOT;
   }
-  if (schema.readOnly === true) {
-    baseSchema = z.readonly(baseSchema);
+  if (Array.isArray(object2)) {
+    return ObjectType.ARRAY;
   }
-  if (schema.default !== void 0) {
-    baseSchema = baseSchema.default(schema.default);
+  if (isRecord(object2)) {
+    return ObjectType.RECORD;
   }
-  const extraMeta = {};
-  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
+  if (object2 instanceof Set) {
+    return ObjectType.SET;
   }
-  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
-    }
+  if (object2 instanceof Map) {
+    return ObjectType.MAP;
   }
-  if (schema.type === "object" && schema.$ref === void 0) {
-    if (schema.propertyNames !== void 0 && !containsRef(schema.propertyNames)) {
-      extraMeta.propertyNames = schema.propertyNames;
+  return ObjectType.OTHER;
+}
+function getKeysOfObjects(objects) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const currentObject of objects) {
+    const stringKeys = Object.keys(currentObject);
+    for (const stringKey of stringKeys) {
+      keys.add(stringKey);
     }
-    for (const key of ["minProperties", "maxProperties"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
+    const symbols = Object.getOwnPropertySymbols(currentObject);
+    if (symbols.length > 0) {
+      for (const symbol2 of symbols) {
+        if (Object.prototype.propertyIsEnumerable.call(currentObject, symbol2)) {
+          keys.add(symbol2);
+        }
+      }
     }
   }
-  if (schema.type === "array" && schema.$ref === void 0) {
-    if (schema.contains !== void 0 && !containsRef(schema.contains)) {
-      extraMeta.contains = schema.contains;
-    }
-    for (const key of ["uniqueItems", "minContains", "maxContains"]) {
-      if (schema[key] !== void 0)
-        extraMeta[key] = schema[key];
-    }
+  return keys;
+}
+function getKeysOfObject(object2) {
+  const symbols = Object.getOwnPropertySymbols(object2).filter((symbol2) => Object.prototype.propertyIsEnumerable.call(object2, symbol2));
+  return [...Object.keys(object2), ...symbols];
+}
+function objectHasProperty(object2, property) {
+  return typeof object2 === "object" && Object.prototype.propertyIsEnumerable.call(object2, property);
+}
+function isRecord(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null || prototype === Object.prototype) {
+    return true;
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      assignProp(extraMeta, key, schema[key]);
-    }
+  const objectToString = Object.prototype.toString.call(value);
+  if (objectToString !== "[object Object]" && objectToString !== "[object Module]") {
+    return false;
   }
-  if (Object.keys(extraMeta).length > 0) {
-    ctx.registry.add(baseSchema, extraMeta);
+  const { constructor } = value;
+  if (constructor === void 0) {
+    return true;
+  }
+  const constructorPrototype = constructor.prototype;
+  if (constructorPrototype === null || typeof constructorPrototype !== "object") {
+    return false;
+  }
+  const constructorToString = Object.prototype.toString.call(constructorPrototype);
+  if (constructorToString !== "[object Object]" && constructorToString !== "[object Module]") {
+    return false;
   }
-  if (schema.description) {
-    baseSchema = baseSchema.describe(schema.description);
+  if (!Object.hasOwn(constructorPrototype, "isPrototypeOf")) {
+    return false;
   }
-  return baseSchema;
+  return true;
 }
-function fromJSONSchema(schema, params) {
-  if (typeof schema === "boolean") {
-    return schema ? z.any() : z.never();
+function getCyclicReferenceDepth(object2, hierarchy, index) {
+  if (hierarchy === void 0 || hierarchy.length === 0) {
+    return 0;
   }
-  let normalized;
-  try {
-    normalized = JSON.parse(JSON.stringify(schema));
-  } catch {
-    throw new Error("fromJSONSchema input is not valid JSON (possibly cyclic); use $defs/$ref for recursive schemas");
+  let mut_depth = 1;
+  for (let mut_index = hierarchy.length - 1; mut_index >= 0; mut_index--) {
+    const { parents } = hierarchy[mut_index];
+    if (parents[index] === object2 || parents.includes(object2)) {
+      return mut_depth;
+    }
+    mut_depth += 1;
   }
-  const version2 = detectVersion(normalized, params?.defaultTarget);
-  const defs = normalized.$defs || normalized.definitions || {};
-  const ctx = {
-    version: version2,
-    defs,
-    refs: /* @__PURE__ */ new Map(),
-    processing: /* @__PURE__ */ new Set(),
-    rootSchema: normalized,
-    registry: params?.registry ?? globalRegistry
-  };
-  return convertSchema(normalized, ctx);
+  return 0;
 }
-
-// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/visit.js
-var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
-function visit(schema, fnOrHandlers) {
-  const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
-    const h = fnOrHandlers[node2._zod.def.type];
-    return h ? h(node2, rewritten) : node2;
-  };
-  const cache = /* @__PURE__ */ new Map();
-  function run2(s) {
-    const cached2 = cache.get(s);
-    if (cached2 === RESOLVING) {
-      return new $ZodLazy({
-        type: "lazy",
-        getter: () => cache.get(s)
+function getMetaDataHierarchy(meta3) {
+  return meta3?.hierarchy;
+}
+function mergeRecords$1(values, utils, meta3) {
+  if (values.length === 2) {
+    const result = {};
+    const mergeProperty = (key, propValues) => {
+      const updatedMeta = utils.metaDataUpdater(meta3, {
+        key,
+        parents: values,
+        values: propValues,
+        result
       });
-    }
-    if (cached2 !== void 0)
-      return cached2;
-    cache.set(s, RESOLVING);
-    const inner = mapInner(s);
-    const mapped = fn(inner, inner !== s);
-    cache.set(s, mapped);
-    return mapped;
-  }
-  function mapInner(s) {
-    const def = s._zod.def;
-    const kind = def.type;
-    switch (kind) {
-      case "object": {
-        const oldShape = def.shape;
-        const keys = Object.keys(oldShape);
-        let changed = false;
-        const newShape = {};
-        for (const k of keys) {
-          const mapped = run2(oldShape[k]);
-          if (mapped !== oldShape[k])
-            changed = true;
-          newShape[k] = mapped;
-        }
-        let newCatchall = def.catchall;
-        if (def.catchall) {
-          newCatchall = run2(def.catchall);
-          if (newCatchall !== def.catchall)
-            changed = true;
-        }
-        return changed ? clone(s, { ...def, shape: newShape, catchall: newCatchall }) : s;
-      }
-      case "array": {
-        const mapped = run2(def.element);
-        return mapped === def.element ? s : clone(s, { ...def, element: mapped });
-      }
-      case "tuple": {
-        const oldItems = def.items;
-        let changed = false;
-        const newItems = [];
-        for (const item of oldItems) {
-          const mapped = run2(item);
-          if (mapped !== item)
-            changed = true;
-          newItems.push(mapped);
-        }
-        let newRest = def.rest;
-        if (def.rest) {
-          newRest = run2(def.rest);
-          if (newRest !== def.rest)
-            changed = true;
-        }
-        return changed ? clone(s, { ...def, items: newItems, rest: newRest }) : s;
-      }
-      case "record":
-      case "map": {
-        const newKey = run2(def.keyType);
-        const newVal = run2(def.valueType);
-        return newKey === def.keyType && newVal === def.valueType ? s : clone(s, { ...def, keyType: newKey, valueType: newVal });
-      }
-      case "set": {
-        const newVal = run2(def.valueType);
-        return newVal === def.valueType ? s : clone(s, { ...def, valueType: newVal });
-      }
-      case "union": {
-        const oldOptions = def.options;
-        let changed = false;
-        const newOptions = [];
-        for (const opt of oldOptions) {
-          const mapped = run2(opt);
-          if (mapped !== opt)
-            changed = true;
-          newOptions.push(mapped);
-        }
-        return changed ? clone(s, { ...def, options: newOptions }) : s;
-      }
-      case "intersection": {
-        const newLeft = run2(def.left);
-        const newRight = run2(def.right);
-        return newLeft === def.left && newRight === def.right ? s : clone(s, { ...def, left: newLeft, right: newRight });
-      }
-      case "optional":
-      case "nullable":
-      case "default":
-      case "prefault":
-      case "catch":
-      case "readonly":
-      case "nonoptional":
-      case "promise":
-      case "success": {
-        const newInner = run2(def.innerType);
-        return newInner === def.innerType ? s : clone(s, { ...def, innerType: newInner });
+      const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
+      if (propertyResult === actions.skip) {
+        return;
       }
-      case "pipe": {
-        const newIn = run2(def.in);
-        const newOut = run2(def.out);
-        return newIn === def.in && newOut === def.out ? s : clone(s, { ...def, in: newIn, out: newOut });
+      if (key === "__proto__") {
+        Object.defineProperty(result, key, {
+          value: propertyResult,
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      } else {
+        result[key] = propertyResult;
       }
-      case "function": {
-        const newInput = run2(def.input);
-        const newOutput = run2(def.output);
-        return newInput === def.input && newOutput === def.output ? s : clone(s, { ...def, input: newInput, output: newOutput });
+    };
+    const firstValue = values[0];
+    const secondValue = values[1];
+    for (const key of getKeysOfObject(firstValue)) {
+      mergeProperty(key, objectHasProperty(secondValue, key) ? [firstValue[key], secondValue[key]] : [firstValue[key]]);
+    }
+    for (const key of getKeysOfObject(secondValue)) {
+      if (!objectHasProperty(firstValue, key)) {
+        mergeProperty(key, [secondValue[key]]);
       }
-      case "lazy": {
-        const original = def.getter;
-        const { _cachedInner, ...rest } = def;
-        return clone(s, { ...rest, getter: () => run2(original()) });
+    }
+    return result;
+  }
+  return mergeRecordsGeneral(values, utils, meta3);
+}
+function mergeRecordsGeneral(values, utils, meta3) {
+  const result = {};
+  for (const key of getKeysOfObjects(values)) {
+    const propValues = [];
+    for (const value of values) {
+      if (objectHasProperty(value, key)) {
+        propValues.push(value[key]);
       }
-      // A leaf by choice: `parts` are regex fragments, not data positions.
-      case "template_literal":
-      // Leaves.
-      case "string":
-      case "number":
-      case "int":
-      case "boolean":
-      case "bigint":
-      case "symbol":
-      case "undefined":
-      case "null":
-      case "void":
-      case "never":
-      case "any":
-      case "unknown":
-      case "date":
-      case "nan":
-      case "enum":
-      case "literal":
-      case "file":
-      case "transform":
-      case "custom":
-        return s;
-      default: {
-        kind;
-        return s;
+    }
+    const updatedMeta = utils.metaDataUpdater(meta3, {
+      key,
+      parents: values,
+      values: propValues,
+      result
+    });
+    const propertyResult = mergeUnknowns(propValues, utils, updatedMeta);
+    if (propertyResult === actions.skip) {
+      continue;
+    }
+    if (key === "__proto__") {
+      Object.defineProperty(result, key, {
+        value: propertyResult,
+        configurable: true,
+        enumerable: true,
+        writable: true
+      });
+    } else {
+      result[key] = propertyResult;
+    }
+  }
+  return result;
+}
+function mergeMaps$1(values, utils, meta3) {
+  const result = /* @__PURE__ */ new Map();
+  const valuesByKey = /* @__PURE__ */ new Map();
+  for (const map2 of values) {
+    for (const [key, value] of map2) {
+      const mut_keyValues = valuesByKey.get(key);
+      if (mut_keyValues === void 0) {
+        valuesByKey.set(key, [value]);
+      } else {
+        mut_keyValues.push(value);
       }
     }
   }
-  return run2(schema);
+  for (const [key, keyValues] of valuesByKey) {
+    const updatedMeta = utils.metaDataUpdater(meta3, {
+      key,
+      parents: values,
+      values: keyValues,
+      result
+    });
+    const keyResult = mergeUnknowns(keyValues, utils, updatedMeta);
+    if (keyResult === actions.skip) {
+      continue;
+    }
+    result.set(key, keyResult);
+  }
+  return result;
 }
-
-// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/deep-partial.js
-function deepPartial(schema) {
-  return visit(schema, {
-    object: (s) => s.partial(),
-    // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
-    union: (s) => {
-      const def = s._zod.def;
-      return def.discriminator === void 0 ? s : union(def.options);
+function resolveCyclicReferences(value, utils, meta3) {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const hierarchy = getMetaDataHierarchy(meta3);
+  const depth = getCyclicReferenceDepth(value, hierarchy, 0);
+  if (hierarchy !== void 0 && depth > 0) {
+    return hierarchy[hierarchy.length - depth]?.result;
+  }
+  const type = getObjectType(value);
+  if (type === ObjectType.RECORD) {
+    const record2 = value;
+    let mut_changed = false;
+    const result = {};
+    for (const key of getKeysOfObject(record2)) {
+      const propVal = record2[key];
+      const updatedMeta = utils.metaDataUpdater(meta3, {
+        key,
+        parents: [record2],
+        values: [propVal],
+        result
+      });
+      const resolvedProp = resolveCyclicReferences(propVal, utils, updatedMeta);
+      if (resolvedProp !== propVal) {
+        mut_changed = true;
+      }
+      if (key === "__proto__") {
+        Object.defineProperty(result, key, {
+          value: resolvedProp,
+          configurable: true,
+          enumerable: true,
+          writable: true
+        });
+      } else {
+        result[key] = resolvedProp;
+      }
     }
-  });
+    return mut_changed ? result : value;
+  }
+  return value;
 }
-
-// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/in-out.js
-function withChecks(side, checks) {
-  if (!checks?.length)
-    return side;
-  const def = side._zod.def;
-  return clone(side, mergeDefs(def, { checks: [...def.checks ?? [], ...checks] }), { parent: true });
+function mergeCircularReferences$1(values, cyclicDepths, utils, meta3) {
+  const depth = cyclicDepths[0];
+  const hierarchy = getMetaDataHierarchy(meta3);
+  for (let mut_index = 1; mut_index < values.length; mut_index++) {
+    if (cyclicDepths[mut_index] !== depth) {
+      const lastCyclicDepth = cyclicDepths.at(-1);
+      return lastCyclicDepth === 0 ? resolveCyclicReferences(values.at(-1), utils, meta3) : hierarchy?.[hierarchy.length - lastCyclicDepth]?.result;
+    }
+  }
+  return hierarchy?.[hierarchy.length - depth]?.result;
 }
-function outSide(def) {
-  return withChecks(def.out, def.checks);
+var mergeFunctions = {
+  mergeRecords: mergeRecords$1,
+  mergeArrays: mergeArrays$1,
+  mergeSets: mergeSets$1,
+  mergeMaps: mergeMaps$1,
+  mergeCircularReferences: mergeCircularReferences$1,
+  mergeOthers: mergeOthers$1
+};
+function deepmergeCustom(options = {}, rootMetaData) {
+  const utils = getUtils$1(options, customizedDeepmerge);
+  function customizedDeepmerge(...objects) {
+    return mergeUnknowns(objects, utils, rootMetaData ?? void 0);
+  }
+  return customizedDeepmerge;
 }
-function inSide(def) {
-  return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+function getUtils$1(options, customizedDeepmerge) {
+  const defaultMergeFns = mergeFunctions;
+  const defaultMetaDataUpd = defaultMetaDataUpdater;
+  return {
+    defaultMergeFunctions: defaultMergeFns,
+    mergeFunctions: resolveCustomMergeFunctions(options, defaultMergeFns),
+    metaDataUpdater: typeof options.metaDataUpdater === "function" ? options.metaDataUpdater : defaultMetaDataUpd,
+    deepmerge: customizedDeepmerge,
+    useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
+    filterValues: options.filterValues === false ? void 0 : typeof options.filterValues === "function" ? options.filterValues : defaultFilterValues,
+    maxDepth: typeof options.maxDepth === "number" && !Number.isNaN(options.maxDepth) && options.maxDepth >= 0 ? options.maxDepth : 1e3,
+    actions
+  };
 }
-function input(schema) {
-  return visit(schema, {
-    pipe: (s) => inSide(s._zod.def),
-    // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
-    default: (s, rewritten) => rewritten ? optional(s._zod.def.innerType) : s,
-    // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
-    catch: (s, rewritten) => rewritten ? s._zod.def.innerType : s
-  });
+function mergeUnknowns(values, utils, meta3) {
+  const filteredValues = utils.filterValues?.(values, meta3) ?? values;
+  if (filteredValues.length === 0) {
+    return void 0;
+  }
+  const hierarchy = getMetaDataHierarchy(meta3);
+  const currentDepth = hierarchy?.length ?? (typeof meta3 === "number" ? meta3 : meta3?.depth ?? 0);
+  if (utils.maxDepth !== void 0 && currentDepth >= utils.maxDepth) {
+    return mergeOthers(filteredValues, utils, meta3);
+  }
+  if (filteredValues.length === 1) {
+    if (hierarchy !== void 0) {
+      const depth = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      if (depth > 0) {
+        return hierarchy[hierarchy.length - depth]?.result ?? hierarchy[hierarchy.length - depth]?.parents[0];
+      }
+    }
+    return mergeOthers(filteredValues, utils, meta3);
+  }
+  const type = getObjectType(filteredValues[0]);
+  if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
+    if (filteredValues.length === 2) {
+      if (getObjectType(filteredValues[1]) !== type) {
+        return mergeOthers(filteredValues, utils, meta3);
+      }
+      const d0 = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      const d1 = getCyclicReferenceDepth(filteredValues[1], hierarchy, 1);
+      if (d0 !== 0 || d1 !== 0) {
+        return mergeCircularReferences(filteredValues, [d0, d1], utils, meta3);
+      }
+    } else {
+      const cyclicDepths = new Array(filteredValues.length);
+      cyclicDepths[0] = getCyclicReferenceDepth(filteredValues[0], hierarchy, 0);
+      for (let mut_index = 1; mut_index < filteredValues.length; mut_index++) {
+        if (getObjectType(filteredValues[mut_index]) !== type) {
+          return mergeOthers(filteredValues, utils, meta3);
+        }
+        cyclicDepths[mut_index] = getCyclicReferenceDepth(filteredValues[mut_index], hierarchy, mut_index);
+      }
+      if (cyclicDepths.some((depth) => depth !== 0)) {
+        return mergeCircularReferences(filteredValues, cyclicDepths, utils, meta3);
+      }
+    }
+  }
+  switch (type) {
+    case ObjectType.RECORD: {
+      return mergeRecords(filteredValues, utils, meta3);
+    }
+    case ObjectType.ARRAY: {
+      return mergeArrays(filteredValues, utils, meta3);
+    }
+    case ObjectType.SET: {
+      return mergeSets(filteredValues, utils, meta3);
+    }
+    case ObjectType.MAP: {
+      return mergeMaps(filteredValues, utils, meta3);
+    }
+    default: {
+      return mergeOthers(filteredValues, utils, meta3);
+    }
+  }
 }
-function output(schema) {
-  return visit(schema, {
-    pipe: (s) => outSide(s._zod.def),
-    // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
-    prefault: (s, rewritten) => rewritten ? s._zod.def.innerType : s
-  });
+function mergeRecords(values, utils, meta3) {
+  const result = utils.mergeFunctions.mergeRecords(values, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeRecords", result)) {
+    return utils.defaultMergeFunctions.mergeRecords(values, utils, meta3);
+  }
+  return result;
 }
-
-// ../../node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/coerce.js
-var coerce_exports = {};
-__export(coerce_exports, {
-  bigint: () => bigint3,
-  boolean: () => boolean3,
-  date: () => date4,
-  number: () => number3,
-  string: () => string3
-});
-function string3(params) {
-  return _coercedString(ZodString, params);
+function mergeArrays(values, utils, meta3) {
+  const result = utils.mergeFunctions.mergeArrays(values, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeArrays", result)) {
+    return utils.defaultMergeFunctions.mergeArrays(values);
+  }
+  return result;
 }
-function number3(params) {
-  return _coercedNumber(ZodNumber, params);
+function mergeSets(values, utils, meta3) {
+  const result = utils.mergeFunctions.mergeSets(values, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeSets", result)) {
+    return utils.defaultMergeFunctions.mergeSets(values);
+  }
+  return result;
 }
-function boolean3(params) {
-  return _coercedBoolean(ZodBoolean, params);
+function mergeMaps(values, utils, meta3) {
+  const result = utils.mergeFunctions.mergeMaps(values, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeMaps", result)) {
+    return utils.defaultMergeFunctions.mergeMaps(values, utils, meta3);
+  }
+  return result;
 }
-function bigint3(params) {
-  return _coercedBigint(ZodBigInt, params);
+function mergeCircularReferences(values, cyclicDepths, utils, meta3) {
+  const result = utils.mergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeCircularReferences", result)) {
+    return utils.defaultMergeFunctions.mergeCircularReferences(values, cyclicDepths, utils, meta3);
+  }
+  return result;
 }
-function date4(params) {
-  return _coercedDate(ZodDate, params);
+function mergeOthers(values, utils, meta3) {
+  const result = utils.mergeFunctions.mergeOthers(values, utils, meta3);
+  if (shouldFallbackToDefault(utils, "mergeOthers", result)) {
+    return utils.defaultMergeFunctions.mergeOthers(values);
+  }
+  return result;
 }
 
-// ../contracts/src/ids.ts
-var GitHubLogin = external_exports.string().regex(/^(?!-)[A-Za-z0-9-]{1,39}(?<!-)(\[bot\])?$/, "not a GitHub login").brand();
-var RepoSlug = external_exports.string().regex(/^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/, "expected owner/name").brand();
-var CommitSha = external_exports.string().regex(/^[0-9a-f]{40}$/, "expected a full commit SHA").brand();
-var BotBranch = external_exports.string().regex(/^macaron\/[0-9]+-[a-z0-9-]{1,48}$/, "expected macaron/<number>-<slug>").brand();
-var Ticket = external_exports.string().regex(/^t_[A-Za-z0-9_-]{32,64}$/, "not a ticket").brand();
-var Slug = external_exports.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "expected kebab-case").max(64).brand();
-var Usd = external_exports.number().nonnegative().max(1e3);
-
 // ../contracts/src/mode.ts
 var Mode = external_exports.enum(["triage", "plan", "implement", "address_review", "reproduce", "verify", "retro", "review"]);
 var Harness = external_exports.enum(["claude", "codex", "opencode"]);