@orpc/json-schema 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/index.mjs

@@ -1,5 +1,4 @@
-import { get, isPlainObject, toArray, tryOrUndefined, isDeepEqual, omit, isTypescriptObject } from '@orpc/shared';
-export { Format as JsonSchemaFormat, TypeName as JsonSchemaType } from 'json-schema-typed/draft-2020-12';
+import { setOwn, get, isPlainObject, tryOrUndefined, getOwn, toArray, isDeepEqual, omit, isTypescriptObject } from '@orpc/shared';
 import { ORPCError, cloneORPCError } from '@orpc/client';
 import { getProcedureContractOrThrow } from '@orpc/contract';
 
@@ -59,6 +58,28 @@ function encodeJsonPointerSegment(segment) {
 function decodeJsonPointerSegment(segment) {
   return segment.replaceAll("~1", "/").replaceAll("~0", "~");
 }
+function visitJsonSchemaRefs(value, visit, schemaLevel = true, seen = /* @__PURE__ */ new Set()) {
+  if (!value || typeof value !== "object" || seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      visitJsonSchemaRefs(item, visit, schemaLevel, seen);
+    }
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    const val = value[key];
+    if (key === "$ref" && typeof val === "string") {
+      visit(val);
+    } else if (!schemaLevel) {
+      visitJsonSchemaRefs(val, visit, true, seen);
+    } else if (JSON_SCHEMA_LOGIC_KEYWORDS.has(key) || JSON_SCHEMA_RECORD_KEYWORDS.has(key)) {
+      visitJsonSchemaRefs(val, visit, !JSON_SCHEMA_RECORD_KEYWORDS.has(key), seen);
+    }
+  }
+}
 function mapJsonSchemaRefs(value, map, schemaLevel = true, path = []) {
   if (!value || typeof value !== "object") {
     return value;
@@ -67,15 +88,16 @@ function mapJsonSchemaRefs(value, map, schemaLevel = true, path = []) {
     return value.map((item, index) => mapJsonSchemaRefs(item, map, schemaLevel, [...path, index]));
   }
   const result = {};
-  for (const [key, val] of Object.entries(value)) {
+  for (const key of Object.keys(value)) {
+    const val = value[key];
     if (key === "$ref" && typeof val === "string") {
-      result[key] = map(val, [...path, key]);
+      setOwn(result, key, map(val, [...path, key]));
     } else if (!schemaLevel) {
-      result[key] = mapJsonSchemaRefs(val, map, true, [...path, key]);
+      setOwn(result, key, mapJsonSchemaRefs(val, map, true, [...path, key]));
     } else if (JSON_SCHEMA_LOGIC_KEYWORDS.has(key) || JSON_SCHEMA_RECORD_KEYWORDS.has(key)) {
-      result[key] = mapJsonSchemaRefs(val, map, !JSON_SCHEMA_RECORD_KEYWORDS.has(key), [...path, key]);
+      setOwn(result, key, mapJsonSchemaRefs(val, map, !JSON_SCHEMA_RECORD_KEYWORDS.has(key), [...path, key]));
     } else {
-      result[key] = val;
+      setOwn(result, key, val);
     }
   }
   return result;
@@ -84,20 +106,19 @@ function hoistRecursiveRefToDef(schema) {
   if (typeof schema !== "object") {
     return schema;
   }
-  let defName;
-  const rewritten = mapJsonSchemaRefs(schema, (ref) => {
-    if (ref === "#" || ref.startsWith("#/") && !ref.startsWith("#/$defs/") && get(schema, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== void 0) {
-      defName ??= findRecursiveJsonSchemaDefName(schema.$defs);
-      return `#/$defs/${encodeJsonPointerSegment(defName)}${ref.slice(1)}`;
-    }
-    return ref;
+  const isRootRef = (ref) => ref === "#" || ref.startsWith("#/") && !ref.startsWith("#/$defs/") && get(schema, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== void 0;
+  let hasRootRef = false;
+  visitJsonSchemaRefs(schema, (ref) => {
+    hasRootRef ||= isRootRef(ref);
   });
-  if (defName === void 0) {
+  if (!hasRootRef) {
     return schema;
   }
-  const { $defs, ...rest } = rewritten;
+  const defName = findRecursiveJsonSchemaDefName(schema.$defs);
+  const defRef = `#/$defs/${encodeJsonPointerSegment(defName)}`;
+  const { $defs, ...rest } = mapJsonSchemaRefs(schema, (ref) => isRootRef(ref) ? `${defRef}${ref.slice(1)}` : ref);
   return {
-    $ref: `#/$defs/${encodeJsonPointerSegment(defName)}`,
+    $ref: defRef,
     $defs: {
       ...$defs,
       [defName]: rest
@@ -114,21 +135,24 @@ function resolveJsonSchemaRootLocalRef(schema, $defs) {
   if (!$defs) {
     return schema;
   }
-  if (typeof schema.$ref !== "string" || !schema.$ref.startsWith("#/$defs/")) {
-    return schema;
-  }
-  const resolved = get($defs, schema.$ref.slice("#/$defs/".length).split("/").map(decodeJsonPointerSegment));
-  if (resolved === void 0) {
-    return schema;
-  }
-  if (typeof resolved !== "object") {
-    return resolved;
+  const followedRefs = /* @__PURE__ */ new Set();
+  let current = schema;
+  while (typeof current.$ref === "string" && current.$ref.startsWith("#/$defs/") && !followedRefs.has(current.$ref)) {
+    followedRefs.add(current.$ref);
+    const resolved = get($defs, current.$ref.slice("#/$defs/".length).split("/").map(decodeJsonPointerSegment));
+    if (resolved === void 0) {
+      return current;
+    }
+    if (typeof resolved !== "object") {
+      return resolved;
+    }
+    const { $ref: _ref, ...rest } = current;
+    current = {
+      ...rest,
+      ...resolved
+    };
   }
-  const { $ref: _ref, ...rest } = schema;
-  return resolveJsonSchemaRootLocalRef({
-    ...rest,
-    ...resolved
-  });
+  return current;
 }
 function findRecursiveJsonSchemaDefName(defs) {
   let index = 0;
@@ -138,9 +162,40 @@ function findRecursiveJsonSchemaDefName(defs) {
   return `__schema${index}`;
 }
 
+var JsonSchemaType = /* @__PURE__ */ ((JsonSchemaType2) => {
+  JsonSchemaType2["Array"] = "array";
+  JsonSchemaType2["Boolean"] = "boolean";
+  JsonSchemaType2["Integer"] = "integer";
+  JsonSchemaType2["Null"] = "null";
+  JsonSchemaType2["Number"] = "number";
+  JsonSchemaType2["Object"] = "object";
+  JsonSchemaType2["String"] = "string";
+  return JsonSchemaType2;
+})(JsonSchemaType || {});
+var JsonSchemaFormat = /* @__PURE__ */ ((JsonSchemaFormat2) => {
+  JsonSchemaFormat2["Date"] = "date";
+  JsonSchemaFormat2["DateTime"] = "date-time";
+  JsonSchemaFormat2["Duration"] = "duration";
+  JsonSchemaFormat2["Email"] = "email";
+  JsonSchemaFormat2["Hostname"] = "hostname";
+  JsonSchemaFormat2["IDNEmail"] = "idn-email";
+  JsonSchemaFormat2["IDNHostname"] = "idn-hostname";
+  JsonSchemaFormat2["IPv4"] = "ipv4";
+  JsonSchemaFormat2["IPv6"] = "ipv6";
+  JsonSchemaFormat2["IRI"] = "iri";
+  JsonSchemaFormat2["IRIReference"] = "iri-reference";
+  JsonSchemaFormat2["JSONPointer"] = "json-pointer";
+  JsonSchemaFormat2["RegEx"] = "regex";
+  JsonSchemaFormat2["RelativeJSONPointer"] = "relative-json-pointer";
+  JsonSchemaFormat2["Time"] = "time";
+  JsonSchemaFormat2["URI"] = "uri";
+  JsonSchemaFormat2["URIReference"] = "uri-reference";
+  JsonSchemaFormat2["URITemplate"] = "uri-template";
+  JsonSchemaFormat2["UUID"] = "uuid";
+  return JsonSchemaFormat2;
+})(JsonSchemaFormat || {});
 var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
   JsonSchemaXNativeType2["BigInt"] = "bigint";
-  JsonSchemaXNativeType2["RegExp"] = "regexp";
   JsonSchemaXNativeType2["Date"] = "date";
   JsonSchemaXNativeType2["Url"] = "url";
   JsonSchemaXNativeType2["Set"] = "set";
@@ -148,7 +203,41 @@ var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
   return JsonSchemaXNativeType2;
 })(JsonSchemaXNativeType || {});
 
-const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
+const UNSATISFIED = 0;
+const LOOSELY_SATISFIED = 1;
+const SATISFIED = 2;
+const NATIVE_TYPES = /* @__PURE__ */ new Map([
+  [JsonSchemaXNativeType.Date, {
+    types: ["string"],
+    is: (value) => value instanceof Date,
+    coerce: (value) => typeof value === "string" ? stringToDate(value) : value
+  }],
+  [JsonSchemaXNativeType.BigInt, {
+    types: ["string", "integer", "number"],
+    is: (value) => typeof value === "bigint",
+    coerce: (value) => typeof value === "string" ? stringToBigInt(value) : typeof value === "number" ? numberToBigInt(value) : value
+  }],
+  [JsonSchemaXNativeType.Url, {
+    types: ["string"],
+    is: (value) => value instanceof URL,
+    coerce: (value) => typeof value === "string" ? stringToURL(value) : value
+  }],
+  [JsonSchemaXNativeType.Set, {
+    types: ["array"],
+    is: (value) => value instanceof Set,
+    coerce: (value) => Array.isArray(value) ? arrayToSet(value) : value,
+    afterTypeCheck: true
+  }],
+  [JsonSchemaXNativeType.Map, {
+    types: ["array"],
+    is: (value) => value instanceof Map,
+    coerce: (value) => Array.isArray(value) ? arrayToMap(value) : value,
+    afterTypeCheck: true
+  }]
+]);
+function minSatisfaction(a, b) {
+  return a < b ? a : b;
+}
 class JsonSchemaCoercer {
   coerce([schema, optional], value) {
     if (optional && value === void 0) {
@@ -157,25 +246,29 @@ class JsonSchemaCoercer {
     const [, coerced] = this.coerceInternal(schema, schema, value);
     return coerced;
   }
-  coerceInternal(rootSchema, schema, value) {
+  coerceInternal(rootSchema, schema, value, appliedRefs) {
     if (typeof schema === "boolean") {
-      return [schema, value];
+      return [schema ? SATISFIED : UNSATISFIED, value];
     }
     if (Array.isArray(schema.type)) {
       return this.coerceInternal(
         rootSchema,
         { anyOf: schema.type.map((type) => ({ ...schema, type })) },
-        value
+        value,
+        appliedRefs
       );
     }
     let coerced = value;
-    let satisfied = true;
+    let satisfied = SATISFIED;
     if (typeof schema.$ref === "string") {
       const resolved = schema.$ref.startsWith("#/") ? get(rootSchema, schema.$ref.slice("#/".length).split("/").map(decodeJsonPointerSegment)) : schema.$ref === "#" ? rootSchema : void 0;
-      if (resolved !== void 0) {
-        const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, resolved, coerced);
+      if (resolved !== void 0 && !appliedRefs?.has(resolved)) {
+        appliedRefs ??= /* @__PURE__ */ new Set();
+        appliedRefs.add(resolved);
+        const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, resolved, coerced, appliedRefs);
+        appliedRefs.delete(resolved);
         coerced = subCoerced;
-        satisfied = subSatisfied;
+        satisfied = minSatisfaction(satisfied, subSatisfied);
       }
     }
     const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
@@ -189,24 +282,29 @@ class JsonSchemaCoercer {
           if (enumValues.includes(booleanValue)) {
             coerced = booleanValue;
           } else {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
         }
       } else {
-        satisfied = false;
+        satisfied = UNSATISFIED;
       }
     }
-    if (schema.type) {
+    const declaredNativeType = NATIVE_TYPES.get(schema["x-native-type"]);
+    const nativeType = schema.type === void 0 || declaredNativeType?.types.includes(schema.type) ? declaredNativeType : void 0;
+    if (nativeType && !nativeType.afterTypeCheck) {
+      coerced = nativeType.coerce(coerced);
+    }
+    if (schema.type && !nativeType?.is(coerced)) {
       switch (schema.type) {
         case "null": {
           if (coerced !== null) {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
         case "string": {
           if (typeof coerced !== "string") {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
@@ -215,7 +313,7 @@ class JsonSchemaCoercer {
             coerced = stringToNumber(coerced);
           }
           if (typeof coerced !== "number") {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
@@ -224,7 +322,7 @@ class JsonSchemaCoercer {
             coerced = stringToInteger(coerced);
           }
           if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
@@ -233,7 +331,7 @@ class JsonSchemaCoercer {
             coerced = stringToBoolean(coerced);
           }
           if (typeof coerced !== "boolean") {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
@@ -245,26 +343,24 @@ class JsonSchemaCoercer {
             const coercedItems = coerced.map((item, i) => {
               const subSchema = prefixItemSchemas[i] ?? itemSchema;
               if (subSchema === void 0) {
-                satisfied = false;
+                satisfied = minSatisfaction(satisfied, LOOSELY_SATISFIED);
                 return item;
               }
               const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, item);
-              if (!subSatisfied) {
-                satisfied = false;
-              }
+              satisfied = minSatisfaction(satisfied, subSatisfied);
               if (subCoerced !== item) {
                 shouldUseCoercedItems = true;
               }
               return subCoerced;
             });
-            if (coercedItems.length < prefixItemSchemas.length) {
-              satisfied = false;
+            if (typeof schema.minItems === "number" && coercedItems.length < schema.minItems) {
+              satisfied = UNSATISFIED;
             }
             if (shouldUseCoercedItems) {
               coerced = coercedItems;
             }
           } else {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
@@ -274,153 +370,123 @@ class JsonSchemaCoercer {
           }
           if (isPlainObject(coerced)) {
             let shouldUseCoercedItems = false;
-            const coercedItems = {};
-            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(([key, value2]) => [new RegExp(key), value2]);
-            for (const key in coerced) {
+            const coercedItems = { ...coerced };
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).flatMap(([key, value2]) => {
+              const pattern = tryOrUndefined(() => new RegExp(key));
+              return pattern ? [[pattern, value2]] : [];
+            });
+            const propertySchemas = schema.properties ?? {};
+            for (const key of Object.keys(coerced)) {
               const value2 = coerced[key];
-              const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
-              if (value2 === void 0 && !schema.required?.includes(key)) {
-                coercedItems[key] = value2;
-              } else if (subSchema === void 0) {
-                coercedItems[key] = value2;
-                satisfied = false;
-              } else {
-                const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, value2);
-                coercedItems[key] = subCoerced;
-                if (!subSatisfied) {
-                  satisfied = false;
-                }
-                if (subCoerced !== value2) {
-                  shouldUseCoercedItems = true;
+              const subSchema = getOwn(propertySchemas, key) ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+              if (value2 !== void 0 || schema.required?.includes(key)) {
+                if (subSchema === void 0) {
+                  satisfied = minSatisfaction(satisfied, LOOSELY_SATISFIED);
+                } else {
+                  const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, value2);
+                  coercedItems[key] = subCoerced;
+                  satisfied = minSatisfaction(satisfied, subSatisfied);
+                  if (subCoerced !== value2) {
+                    shouldUseCoercedItems = true;
+                  }
                 }
               }
             }
             if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
-              satisfied = false;
+              satisfied = UNSATISFIED;
             }
             if (shouldUseCoercedItems) {
               coerced = coercedItems;
             }
           } else {
-            satisfied = false;
+            satisfied = UNSATISFIED;
           }
           break;
         }
       }
     }
-    if ("x-native-type" in schema && typeof schema["x-native-type"] === "string") {
-      switch (schema["x-native-type"]) {
-        case JsonSchemaXNativeType.Date: {
-          if (typeof coerced === "string") {
-            coerced = stringToDate(coerced);
-          }
-          if (!(coerced instanceof Date)) {
-            satisfied = false;
-          }
-          break;
-        }
-        case JsonSchemaXNativeType.BigInt: {
-          switch (typeof coerced) {
-            case "string":
-              coerced = stringToBigInt(coerced);
-              break;
-            case "number":
-              coerced = numberToBigInt(coerced);
-              break;
-          }
-          if (typeof coerced !== "bigint") {
-            satisfied = false;
-          }
-          break;
-        }
-        case JsonSchemaXNativeType.RegExp: {
-          if (typeof coerced === "string") {
-            coerced = stringToRegExp(coerced);
-          }
-          if (!(coerced instanceof RegExp)) {
-            satisfied = false;
-          }
-          break;
-        }
-        case JsonSchemaXNativeType.Url: {
-          if (typeof coerced === "string") {
-            coerced = stringToURL(coerced);
-          }
-          if (!(coerced instanceof URL)) {
-            satisfied = false;
-          }
-          break;
-        }
-        case JsonSchemaXNativeType.Set: {
-          if (Array.isArray(coerced)) {
-            coerced = arrayToSet(coerced);
-          }
-          if (!(coerced instanceof Set)) {
-            satisfied = false;
-          }
-          break;
-        }
-        case JsonSchemaXNativeType.Map: {
-          if (Array.isArray(coerced)) {
-            coerced = arrayToMap(coerced);
-          }
-          if (!(coerced instanceof Map)) {
-            satisfied = false;
-          }
-          break;
-        }
+    if (nativeType) {
+      if (nativeType.afterTypeCheck) {
+        coerced = nativeType.coerce(coerced);
+      }
+      if (!nativeType.is(coerced)) {
+        satisfied = UNSATISFIED;
       }
     }
     if (schema.allOf) {
       for (const subSchema of schema.allOf) {
-        const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced);
+        const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced, appliedRefs);
         coerced = subCoerced;
-        if (!subSatisfied) {
-          satisfied = false;
-        }
+        satisfied = minSatisfaction(satisfied, subSatisfied);
       }
     }
     for (const key of ["anyOf", "oneOf"]) {
       if (schema[key]) {
-        let bestOptions;
+        let best;
         for (const subSchema of schema[key]) {
-          const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced);
-          if (subSatisfied) {
-            if (!bestOptions || subCoerced === coerced) {
-              bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
-            }
-            if (subCoerced === coerced) {
-              break;
-            }
+          const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced, appliedRefs);
+          if (subSatisfied === UNSATISFIED) {
+            continue;
+          }
+          if (subCoerced === coerced) {
+            best = { satisfied: subSatisfied, value: subCoerced };
+            break;
           }
+          if (!best || subSatisfied > best.satisfied) {
+            best = { satisfied: subSatisfied, value: subCoerced };
+          }
+        }
+        if (best) {
+          coerced = best.value;
+          satisfied = minSatisfaction(satisfied, best.satisfied);
+        } else {
+          satisfied = UNSATISFIED;
         }
-        coerced = bestOptions ? bestOptions.coerced : coerced;
-        satisfied = bestOptions ? bestOptions.satisfied : false;
       }
     }
     if (typeof schema.not !== "undefined") {
-      const [notSatisfied] = this.coerceInternal(rootSchema, schema.not, coerced);
-      if (notSatisfied) {
-        satisfied = false;
+      const [notSatisfied] = this.coerceInternal(rootSchema, schema.not, coerced, appliedRefs);
+      if (notSatisfied !== UNSATISFIED) {
+        satisfied = UNSATISFIED;
       }
     }
     return [satisfied, coerced];
   }
 }
+const NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
 function stringToNumber(value) {
-  const num = Number.parseFloat(value);
-  if (Number.isNaN(num) || num !== Number(value)) {
+  if (!NUMBER_PATTERN.test(value)) {
+    return value;
+  }
+  const num = Number(value);
+  if (num < Number.MIN_SAFE_INTEGER || num > Number.MAX_SAFE_INTEGER) {
     return value;
   }
   return num;
 }
+const INTEGER_PATTERN = /^-?(?:0|[1-9]\d*)$/;
 function stringToInteger(value) {
-  const num = Number.parseInt(value);
-  if (Number.isNaN(num) || num !== Number(value)) {
+  if (!INTEGER_PATTERN.test(value)) {
+    return value;
+  }
+  const num = Number(value);
+  if (!Number.isSafeInteger(num)) {
     return value;
   }
   return num;
 }
+function stringToBigInt(value) {
+  if (!INTEGER_PATTERN.test(value)) {
+    return value;
+  }
+  return BigInt(value);
+}
+function numberToBigInt(value) {
+  if (!Number.isInteger(value)) {
+    return value;
+  }
+  return BigInt(value);
+}
 function stringToBoolean(value) {
   const lower = value.toLowerCase();
   if (lower === "false" || lower === "off") {
@@ -431,26 +497,29 @@ function stringToBoolean(value) {
   }
   return value;
 }
-function stringToBigInt(value) {
-  return tryOrUndefined(() => BigInt(value)) ?? value;
-}
-function numberToBigInt(value) {
-  return tryOrUndefined(() => BigInt(value)) ?? value;
-}
+const DATE_TIME_PATTERN = /^(?!-0{6})(?:[+-]\d{2})?\d{4}-\d{2}-\d{2}(?:[T ].*)?$/;
+const DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 function stringToDate(value) {
+  if (!DATE_TIME_PATTERN.test(value)) {
+    return value;
+  }
+  const yearEnd = value.indexOf("-", 1);
+  const month = readTwoDigits(value, yearEnd + 1);
+  const day = readTwoDigits(value, yearEnd + 4);
+  if (day < 1 || day > (DAYS_IN_MONTH[month - 1] ?? 0) || month === 2 && day === 29 && !isLeapYear(Number(value.slice(0, yearEnd)))) {
+    return value;
+  }
   const date = new Date(value);
-  if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+  if (Number.isNaN(date.getTime())) {
     return value;
   }
   return date;
 }
-function stringToRegExp(value) {
-  const match = value.match(/^\/(.*)\/([a-z]*)$/);
-  if (match) {
-    const [, pattern, flags] = match;
-    return tryOrUndefined(() => new RegExp(pattern, flags)) ?? value;
-  }
-  return value;
+function readTwoDigits(value, index) {
+  return (value.charCodeAt(index) - 48) * 10 + value.charCodeAt(index + 1) - 48;
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
 }
 function stringToURL(value) {
   return tryOrUndefined(() => new URL(value)) ?? value;
@@ -513,148 +582,85 @@ function ensureJsonSchemaObject(schema) {
   return schema;
 }
 
+function promoteJsonSchemaDefs(schema, mergedDefs, basePath) {
+  const { $defs, ...rootBody } = schema;
+  const renameMap = /* @__PURE__ */ new Map();
+  const mapRef = (ref) => {
+    if (ref === "#") {
+      return basePath;
+    }
+    if (ref.startsWith("#/$defs/")) {
+      const [encodedName, ...segments] = ref.slice("#/$defs/".length).split("/");
+      const newName = renameMap.get(decodeJsonPointerSegment(encodedName));
+      return newName === void 0 ? ref : ["#/$defs", encodeJsonPointerSegment(newName), ...segments].join("/");
+    }
+    if (ref.startsWith("#/") && get(rootBody, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== void 0) {
+      return `${basePath}/${ref.slice(2)}`;
+    }
+    return ref;
+  };
+  const defs = Object.entries($defs ?? {}).filter(([, def]) => def !== void 0);
+  if (defs.length > 0) {
+    const promoted = /* @__PURE__ */ new Map();
+    const reserved = /* @__PURE__ */ new Set([...mergedDefs.keys(), ...defs.map(([name]) => name)]);
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const [name, def] of defs) {
+        const body = mapJsonSchemaRefs(def, mapRef);
+        promoted.set(name, body);
+        if (renameMap.has(name) || !mergedDefs.has(name) || isDeepEqual(mergedDefs.get(name), body)) {
+          continue;
+        }
+        let counter = 2;
+        while (reserved.has(`${name}${counter}`)) {
+          counter++;
+        }
+        reserved.add(`${name}${counter}`);
+        renameMap.set(name, `${name}${counter}`);
+        changed = true;
+      }
+    }
+    for (const [name, body] of promoted) {
+      mergedDefs.set(renameMap.get(name) ?? name, body);
+    }
+  }
+  return mapJsonSchemaRefs(rootBody, mapRef);
+}
 function combineJsonSchemasWithComposition(keyword, schemas) {
   if (schemas.length <= 1) {
     return schemas[0] ?? true;
   }
-  const mergedDefs = {};
+  const mergedDefs = /* @__PURE__ */ new Map();
   const compositionBranches = [];
   for (let i = 0; i < schemas.length; i++) {
     const schema = schemas[i];
-    if (typeof schema === "boolean") {
-      compositionBranches.push(schema);
-      continue;
-    }
-    const { $defs, ...rest } = schema;
-    const renameMap = {};
-    const promotedNames = /* @__PURE__ */ new Set();
-    if ($defs) {
-      for (const [name, def] of Object.entries($defs)) {
-        if (def === void 0)
-          continue;
-        promotedNames.add(name);
-        if (name in mergedDefs) {
-          if (isDeepEqual(mergedDefs[name], def)) {
-            continue;
-          }
-          let counter = 2;
-          let newName = `${name}${counter}`;
-          while (newName in mergedDefs) {
-            counter++;
-            newName = `${name}${counter}`;
-          }
-          mergedDefs[newName] = def;
-          renameMap[name] = newName;
-        } else {
-          mergedDefs[name] = def;
-        }
-      }
-    }
-    compositionBranches.push(mapJsonSchemaRefs(
-      rest,
-      (ref) => {
-        if (ref === "#") {
-          return `#/${keyword}/${i}`;
-        }
-        if (ref.startsWith("#/$defs/")) {
-          const afterPrefix = ref.slice("#/$defs/".length);
-          const slashIdx = afterPrefix.indexOf("/");
-          const encodedSegment = slashIdx === -1 ? afterPrefix : afterPrefix.slice(0, slashIdx);
-          const rest2 = slashIdx === -1 ? "" : afterPrefix.slice(slashIdx);
-          const defName = decodeJsonPointerSegment(encodedSegment);
-          if (!promotedNames.has(defName)) {
-            return ref;
-          }
-          if (defName in renameMap) {
-            return `#/$defs/${encodeJsonPointerSegment(renameMap[defName])}${rest2}`;
-          }
-          return ref;
-        }
-        if (ref.startsWith("#/") && get(rest, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== void 0) {
-          return `#/${keyword}/${i}/${ref.slice(2)}`;
-        }
-        return ref;
-      }
-    ));
+    compositionBranches.push(typeof schema === "boolean" ? schema : promoteJsonSchemaDefs(schema, mergedDefs, `#/${keyword}/${i}`));
   }
   const result = { [keyword]: compositionBranches };
-  if (Object.keys(mergedDefs).length > 0) {
-    result.$defs = mergedDefs;
+  if (mergedDefs.size > 0) {
+    result.$defs = Object.fromEntries(mergedDefs);
   }
   return result;
 }
 function combineJsonObjectSchemaEntries(entries) {
-  const properties = {};
+  const properties = /* @__PURE__ */ new Map();
   const required = [];
-  const mergedDefs = {};
+  const mergedDefs = /* @__PURE__ */ new Map();
   for (const [name, propertySchema, optional] of entries) {
     if (!optional) {
       required.push(name);
     }
-    if (typeof propertySchema === "boolean") {
-      properties[name] = propertySchema;
-      continue;
-    }
-    const { $defs, ...rest } = propertySchema;
-    const renameMap = {};
-    const promotedNames = /* @__PURE__ */ new Set();
-    if ($defs) {
-      for (const [defName, def] of Object.entries($defs)) {
-        if (def === void 0) {
-          continue;
-        }
-        promotedNames.add(defName);
-        if (defName in mergedDefs) {
-          if (isDeepEqual(mergedDefs[defName], def)) {
-            continue;
-          }
-          let counter = 2;
-          let newName = `${defName}${counter}`;
-          while (newName in mergedDefs) {
-            counter++;
-            newName = `${defName}${counter}`;
-          }
-          mergedDefs[newName] = def;
-          renameMap[defName] = newName;
-        } else {
-          mergedDefs[defName] = def;
-        }
-      }
-    }
-    const propertyPathPrefix = `#/properties/${encodeJsonPointerSegment(name)}`;
-    properties[name] = mapJsonSchemaRefs(rest, (ref) => {
-      if (ref.startsWith("#/$defs/")) {
-        const afterPrefix = ref.slice("#/$defs/".length);
-        const slashIdx = afterPrefix.indexOf("/");
-        const encodedSegment = slashIdx === -1 ? afterPrefix : afterPrefix.slice(0, slashIdx);
-        const refRest = slashIdx === -1 ? "" : afterPrefix.slice(slashIdx);
-        const defName = decodeJsonPointerSegment(encodedSegment);
-        if (!promotedNames.has(defName)) {
-          return ref;
-        }
-        if (defName in renameMap) {
-          return `#/$defs/${encodeJsonPointerSegment(renameMap[defName])}${refRest}`;
-        }
-        return ref;
-      }
-      if (ref === "#") {
-        return propertyPathPrefix;
-      }
-      if (ref.startsWith("#/") && get(rest, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== void 0) {
-        return `${propertyPathPrefix}/${ref.slice(2)}`;
-      }
-      return ref;
-    });
+    properties.set(name, typeof propertySchema === "boolean" ? propertySchema : promoteJsonSchemaDefs(propertySchema, mergedDefs, `#/properties/${encodeJsonPointerSegment(name)}`));
   }
   const schema = {
     type: "object",
-    properties
+    properties: Object.fromEntries(properties)
   };
   if (required.length > 0) {
     schema.required = required;
   }
-  if (Object.keys(mergedDefs).length > 0) {
-    schema.$defs = mergedDefs;
+  if (mergedDefs.size > 0) {
+    schema.$defs = Object.fromEntries(mergedDefs);
   }
   return schema;
 }
@@ -755,7 +761,7 @@ function extractJsonObjectSchemaEntriesInternal(schema, $defs, resolvingRefs) {
       return [
         name,
         schemas.length === 1 ? schemas[0] : { allOf: schemas },
-        [entries.direct, entries.allOf, entries.anyOf, entries.oneOf].every((entry) => entry === void 0 || entry[2])
+        !schema.required?.includes(name) && [entries.allOf, entries.anyOf, entries.oneOf].every((entry) => entry === void 0 || entry[2])
       ];
     }),
     objectLike
@@ -774,7 +780,7 @@ function flattenJsonUnionSchemaInternal(schema, resolvingRefs) {
     }
     const resolved = resolveJsonSchemaRootLocalRef(schema);
     if (resolved !== schema) {
-      const result = flattenJsonUnionSchemaInternal(resolved, resolvingRefs.add(schema.$ref));
+      const result = flattenJsonUnionSchemaInternal(resolved, new Set(resolvingRefs).add(schema.$ref));
       if (result.length > 1) {
         return result;
       }
@@ -844,26 +850,29 @@ class DelegatingJsonSchemaConverter {
   constructor(converters = []) {
     this.converters = converters;
   }
-  async convert(schema, direction) {
+  convert(schema, direction) {
     for (const converter of this.converters) {
-      if (await converter.condition(schema, direction)) {
+      if (converter.condition(schema, direction)) {
         return converter.convert(schema, direction);
       }
     }
-    const optional = !(await schema?.["~standard"].validate(void 0))?.issues?.length;
-    if (schema && "jsonSchema" in schema["~standard"] && schema["~standard"].jsonSchema) {
-      try {
-        return [
-          schema["~standard"].jsonSchema[direction](),
-          optional
-        ];
-      } catch {
-      }
-    }
-    return [{}, optional];
+    return [{}, true];
   }
 }
 
+function isStandardSchemaOptional(schema, direction) {
+  try {
+    const result = schema["~standard"].validate(void 0);
+    if (result instanceof Promise) {
+      result.catch(() => {
+      });
+      return false;
+    }
+    return !result.issues && (direction === "input" || result.value === void 0);
+  } catch {
+    return false;
+  }
+}
 class StandardJsonSchemaConverter {
   condition(schema, _direction) {
     return Boolean(
@@ -876,15 +885,7 @@ class StandardJsonSchemaConverter {
   convertInternal(schema, direction) {
     try {
       const jsonSchema = direction === "input" ? schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }) : schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
-      let optional = false;
-      try {
-        const result = schema["~standard"].validate(void 0);
-        if (!(result instanceof Promise) && !result.issues) {
-          optional = direction === "input" ? true : result.value === void 0;
-        }
-      } catch {
-      }
-      return [jsonSchema, optional];
+      return [jsonSchema, isStandardSchemaOptional(schema, direction)];
     } catch {
       return [{}, true];
     }
@@ -907,23 +908,23 @@ class SmartCoercionHandlerPlugin {
     return {
       ...options,
       clientInterceptors: [
-        async ({ next, input, ...interceptorOptions }) => {
+        ({ next, input, ...interceptorOptions }) => {
           const inputSchemas = interceptorOptions.procedure["~orpc"].inputSchemas;
           if (!inputSchemas) {
             return next();
           }
-          const coercedInput = await this.coerceValue(inputSchemas, input);
+          const coercedInput = this.coerceValue(inputSchemas, input);
           return next({ ...interceptorOptions, input: coercedInput });
         },
         ...toArray(options.clientInterceptors)
       ]
     };
   }
-  async coerceValue(schemas, value) {
+  coerceValue(schemas, value) {
     for (const schema of schemas) {
       let converted = this.cache.get(schema);
       if (!converted) {
-        converted = await this.converter.convert(schema, "input");
+        converted = this.converter.convert(schema, "input");
         this.cache.set(schema, converted);
       }
       value = this.coercer.coerce(converted, value);
@@ -962,30 +963,30 @@ class SmartCoercionLinkPlugin {
             if (!outputSchemas) {
               return output;
             }
-            const coercedOutput = await this.coerceValue(outputSchemas, output);
+            const coercedOutput = this.coerceValue(outputSchemas, output);
             return coercedOutput;
           } catch (error) {
             if (!(error instanceof ORPCError) || !error.defined) {
               throw error;
             }
             const errorMap = procedure["~orpc"].errorMap;
-            const dataSchema = errorMap[error.code]?.data;
+            const dataSchema = getOwn(errorMap, error.code)?.data;
             if (!dataSchema) {
               throw error;
             }
             const cloned = cloneORPCError(error);
-            cloned.data = await this.coerceValue([dataSchema], cloned.data);
+            cloned.data = this.coerceValue([dataSchema], cloned.data);
             throw cloned;
           }
         }
       ]
     };
   }
-  async coerceValue(schemas, value) {
+  coerceValue(schemas, value) {
     for (const schema of schemas) {
       let converted = this.cache.get(schema);
       if (!converted) {
-        converted = await this.converter.convert(schema, "output");
+        converted = this.converter.convert(schema, "output");
         this.cache.set(schema, converted);
       }
       value = this.coercer.coerce(converted, value);
@@ -994,4 +995,4 @@ class SmartCoercionLinkPlugin {
   }
 }
 
-export { DelegatingJsonSchemaConverter, JsonSchemaCoercer, JsonSchemaXNativeType, SmartCoercionHandlerPlugin, SmartCoercionLinkPlugin, StandardJsonSchemaConverter, combineJsonObjectSchemaEntries, combineJsonSchemasWithComposition, decodeJsonPointerSegment, deduplicateJsonSchemas, encodeJsonPointerSegment, ensureJsonSchemaObject, extractJsonObjectSchemaEntries, flattenJsonUnionSchema, hoistRecursiveRefToDef, isJsonArraySchema, isJsonFileSchema, isJsonObjectSchema, isJsonPrimitiveSchema, isUnconstrainedSchema, mapJsonSchemaRefs, matchArrayableJsonSchema, resolveJsonSchemaRootLocalRef };
+export { DelegatingJsonSchemaConverter, JsonSchemaCoercer, JsonSchemaFormat, JsonSchemaType, JsonSchemaXNativeType, SmartCoercionHandlerPlugin, SmartCoercionLinkPlugin, StandardJsonSchemaConverter, combineJsonObjectSchemaEntries, combineJsonSchemasWithComposition, decodeJsonPointerSegment, deduplicateJsonSchemas, encodeJsonPointerSegment, ensureJsonSchemaObject, extractJsonObjectSchemaEntries, flattenJsonUnionSchema, hoistRecursiveRefToDef, isJsonArraySchema, isJsonFileSchema, isJsonObjectSchema, isJsonPrimitiveSchema, isStandardSchemaOptional, isUnconstrainedSchema, mapJsonSchemaRefs, matchArrayableJsonSchema, resolveJsonSchemaRootLocalRef, visitJsonSchemaRefs };