@orpc/json-schema 1.14.6 → 2.0.0-beta.2

package/dist/index.mjs

@@ -1,5 +1,142 @@
-import { isObject, toArray, guard } from '@orpc/shared';
-import { CompositeSchemaConverter } from '@orpc/openapi';
+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 { ORPCError, cloneORPCError } from '@orpc/client';
+import { getProcedureContractOrThrow } from '@orpc/contract';
+
+const JSON_SCHEMA_LOGIC_KEYWORDS = /* @__PURE__ */ new Set([
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+]);
+const JSON_SCHEMA_PRIMITIVE_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
+const JSON_SCHEMA_RECORD_KEYWORDS = /* @__PURE__ */ new Set(["properties", "patternProperties", "dependentSchemas", "dependencies", "$defs"]);
+
+function encodeJsonPointerSegment(segment) {
+  return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function decodeJsonPointerSegment(segment) {
+  return segment.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function mapJsonSchemaRefs(value, map, schemaLevel = true, path = []) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => mapJsonSchemaRefs(item, map, schemaLevel, [...path, index]));
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (key === "$ref" && typeof val === "string") {
+      result[key] = map(val, [...path, key]);
+    } else if (!schemaLevel) {
+      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]);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+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;
+  });
+  if (defName === void 0) {
+    return schema;
+  }
+  const { $defs, ...rest } = rewritten;
+  return {
+    $ref: `#/$defs/${encodeJsonPointerSegment(defName)}`,
+    $defs: {
+      ...$defs,
+      [defName]: rest
+    }
+  };
+}
+function resolveJsonSchemaRootLocalRef(schema, $defs) {
+  if (typeof schema === "boolean") {
+    return schema;
+  }
+  if (arguments.length === 1) {
+    $defs = 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 { $ref: _ref, ...rest } = schema;
+  return resolveJsonSchemaRootLocalRef({
+    ...rest,
+    ...resolved
+  });
+}
+function findRecursiveJsonSchemaDefName(defs) {
+  let index = 0;
+  while (defs?.[`__schema${index}`] !== void 0) {
+    index++;
+  }
+  return `__schema${index}`;
+}
 
 var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
   JsonSchemaXNativeType2["BigInt"] = "bigint";
@@ -13,25 +150,30 @@ var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
 
 const FLEXIBLE_DATE_FORMAT_REGEX = /^[^-]+-[^-]+-[^-]+$/;
 class JsonSchemaCoercer {
-  coerce(schema, value, options = {}) {
-    const [, coerced] = this.#coerce(schema, value, options);
+  coerce([schema, optional], value) {
+    if (optional && value === void 0) {
+      return value;
+    }
+    const [, coerced] = this.coerceInternal(schema, schema, value);
     return coerced;
   }
-  #coerce(schema, originalValue, options) {
+  coerceInternal(rootSchema, schema, value) {
     if (typeof schema === "boolean") {
-      return [schema, originalValue];
+      return [schema, value];
     }
     if (Array.isArray(schema.type)) {
-      return this.#coerce({
-        anyOf: schema.type.map((type) => ({ ...schema, type }))
-      }, originalValue, options);
+      return this.coerceInternal(
+        rootSchema,
+        { anyOf: schema.type.map((type) => ({ ...schema, type })) },
+        value
+      );
     }
-    let coerced = originalValue;
+    let coerced = value;
     let satisfied = true;
     if (typeof schema.$ref === "string") {
-      const refSchema = options?.components?.[schema.$ref];
-      if (refSchema !== void 0) {
-        const [subSatisfied, subCoerced] = this.#coerce(refSchema, coerced, options);
+      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);
         coerced = subCoerced;
         satisfied = subSatisfied;
       }
@@ -39,11 +181,11 @@ class JsonSchemaCoercer {
     const enumValues = schema.const !== void 0 ? [schema.const] : schema.enum;
     if (enumValues !== void 0 && !enumValues.includes(coerced)) {
       if (typeof coerced === "string") {
-        const numberValue = this.#stringToNumber(coerced);
+        const numberValue = stringToNumber(coerced);
         if (enumValues.includes(numberValue)) {
           coerced = numberValue;
         } else {
-          const booleanValue = this.#stringToBoolean(coerced);
+          const booleanValue = stringToBoolean(coerced);
           if (enumValues.includes(booleanValue)) {
             coerced = booleanValue;
           } else {
@@ -54,7 +196,7 @@ class JsonSchemaCoercer {
         satisfied = false;
       }
     }
-    if (typeof schema.type === "string") {
+    if (schema.type) {
       switch (schema.type) {
         case "null": {
           if (coerced !== null) {
@@ -70,7 +212,7 @@ class JsonSchemaCoercer {
         }
         case "number": {
           if (typeof coerced === "string") {
-            coerced = this.#stringToNumber(coerced);
+            coerced = stringToNumber(coerced);
           }
           if (typeof coerced !== "number") {
             satisfied = false;
@@ -79,7 +221,7 @@ class JsonSchemaCoercer {
         }
         case "integer": {
           if (typeof coerced === "string") {
-            coerced = this.#stringToInteger(coerced);
+            coerced = stringToInteger(coerced);
           }
           if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
             satisfied = false;
@@ -88,7 +230,7 @@ class JsonSchemaCoercer {
         }
         case "boolean": {
           if (typeof coerced === "string") {
-            coerced = this.#stringToBoolean(coerced);
+            coerced = stringToBoolean(coerced);
           }
           if (typeof coerced !== "boolean") {
             satisfied = false;
@@ -106,7 +248,7 @@ class JsonSchemaCoercer {
                 satisfied = false;
                 return item;
               }
-              const [subSatisfied, subCoerced] = this.#coerce(subSchema, item, options);
+              const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, item);
               if (!subSatisfied) {
                 satisfied = false;
               }
@@ -130,25 +272,25 @@ class JsonSchemaCoercer {
           if (Array.isArray(coerced)) {
             coerced = { ...coerced };
           }
-          if (isObject(coerced)) {
+          if (isPlainObject(coerced)) {
             let shouldUseCoercedItems = false;
             const coercedItems = {};
-            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(([key, value]) => [new RegExp(key), value]);
+            const patternProperties = Object.entries(schema.patternProperties ?? {}).map(([key, value2]) => [new RegExp(key), value2]);
             for (const key in coerced) {
-              const value = coerced[key];
+              const value2 = coerced[key];
               const subSchema = schema.properties?.[key] ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
-              if (value === void 0 && !schema.required?.includes(key)) {
-                coercedItems[key] = value;
+              if (value2 === void 0 && !schema.required?.includes(key)) {
+                coercedItems[key] = value2;
               } else if (subSchema === void 0) {
-                coercedItems[key] = value;
+                coercedItems[key] = value2;
                 satisfied = false;
               } else {
-                const [subSatisfied, subCoerced] = this.#coerce(subSchema, value, options);
+                const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, value2);
                 coercedItems[key] = subCoerced;
                 if (!subSatisfied) {
                   satisfied = false;
                 }
-                if (subCoerced !== value) {
+                if (subCoerced !== value2) {
                   shouldUseCoercedItems = true;
                 }
               }
@@ -170,7 +312,7 @@ class JsonSchemaCoercer {
       switch (schema["x-native-type"]) {
         case JsonSchemaXNativeType.Date: {
           if (typeof coerced === "string") {
-            coerced = this.#stringToDate(coerced);
+            coerced = stringToDate(coerced);
           }
           if (!(coerced instanceof Date)) {
             satisfied = false;
@@ -180,10 +322,10 @@ class JsonSchemaCoercer {
         case JsonSchemaXNativeType.BigInt: {
           switch (typeof coerced) {
             case "string":
-              coerced = this.#stringToBigInt(coerced);
+              coerced = stringToBigInt(coerced);
               break;
             case "number":
-              coerced = this.#numberToBigInt(coerced);
+              coerced = numberToBigInt(coerced);
               break;
           }
           if (typeof coerced !== "bigint") {
@@ -193,7 +335,7 @@ class JsonSchemaCoercer {
         }
         case JsonSchemaXNativeType.RegExp: {
           if (typeof coerced === "string") {
-            coerced = this.#stringToRegExp(coerced);
+            coerced = stringToRegExp(coerced);
           }
           if (!(coerced instanceof RegExp)) {
             satisfied = false;
@@ -202,7 +344,7 @@ class JsonSchemaCoercer {
         }
         case JsonSchemaXNativeType.Url: {
           if (typeof coerced === "string") {
-            coerced = this.#stringToURL(coerced);
+            coerced = stringToURL(coerced);
           }
           if (!(coerced instanceof URL)) {
             satisfied = false;
@@ -211,7 +353,7 @@ class JsonSchemaCoercer {
         }
         case JsonSchemaXNativeType.Set: {
           if (Array.isArray(coerced)) {
-            coerced = this.#arrayToSet(coerced);
+            coerced = arrayToSet(coerced);
           }
           if (!(coerced instanceof Set)) {
             satisfied = false;
@@ -220,7 +362,7 @@ class JsonSchemaCoercer {
         }
         case JsonSchemaXNativeType.Map: {
           if (Array.isArray(coerced)) {
-            coerced = this.#arrayToMap(coerced);
+            coerced = arrayToMap(coerced);
           }
           if (!(coerced instanceof Map)) {
             satisfied = false;
@@ -231,7 +373,7 @@ class JsonSchemaCoercer {
     }
     if (schema.allOf) {
       for (const subSchema of schema.allOf) {
-        const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+        const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced);
         coerced = subCoerced;
         if (!subSatisfied) {
           satisfied = false;
@@ -242,7 +384,7 @@ class JsonSchemaCoercer {
       if (schema[key]) {
         let bestOptions;
         for (const subSchema of schema[key]) {
-          const [subSatisfied, subCoerced] = this.#coerce(subSchema, coerced, options);
+          const [subSatisfied, subCoerced] = this.coerceInternal(rootSchema, subSchema, coerced);
           if (subSatisfied) {
             if (!bestOptions || subCoerced === coerced) {
               bestOptions = { coerced: subCoerced, satisfied: subSatisfied };
@@ -257,107 +399,601 @@ class JsonSchemaCoercer {
       }
     }
     if (typeof schema.not !== "undefined") {
-      const [notSatisfied] = this.#coerce(schema.not, coerced, options);
+      const [notSatisfied] = this.coerceInternal(rootSchema, schema.not, coerced);
       if (notSatisfied) {
         satisfied = false;
       }
     }
     return [satisfied, coerced];
   }
-  #stringToNumber(value) {
-    const num = Number.parseFloat(value);
-    if (Number.isNaN(num) || num !== Number(value)) {
-      return value;
-    }
-    return num;
+}
+function stringToNumber(value) {
+  const num = Number.parseFloat(value);
+  if (Number.isNaN(num) || num !== Number(value)) {
+    return value;
   }
-  #stringToInteger(value) {
-    const num = Number.parseInt(value);
-    if (Number.isNaN(num) || num !== Number(value)) {
-      return value;
+  return num;
+}
+function stringToInteger(value) {
+  const num = Number.parseInt(value);
+  if (Number.isNaN(num) || num !== Number(value)) {
+    return value;
+  }
+  return num;
+}
+function stringToBoolean(value) {
+  const lower = value.toLowerCase();
+  if (lower === "false" || lower === "off") {
+    return false;
+  }
+  if (lower === "true" || lower === "on") {
+    return true;
+  }
+  return value;
+}
+function stringToBigInt(value) {
+  return tryOrUndefined(() => BigInt(value)) ?? value;
+}
+function numberToBigInt(value) {
+  return tryOrUndefined(() => BigInt(value)) ?? value;
+}
+function stringToDate(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
+    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 stringToURL(value) {
+  return tryOrUndefined(() => new URL(value)) ?? value;
+}
+function arrayToSet(value) {
+  const set = new Set(value);
+  if (set.size !== value.length) {
+    return value;
+  }
+  return set;
+}
+function arrayToMap(value) {
+  if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+    return value;
+  }
+  const result = new Map(value);
+  if (result.size !== value.length) {
+    return value;
+  }
+  return result;
+}
+
+function isJsonFileSchema(schema) {
+  return typeof schema !== "boolean" && schema.type === "string" && (typeof schema.contentMediaType === "string" || schema.format === "binary" || schema.contentEncoding === "binary");
+}
+function isJsonObjectSchema(schema) {
+  return typeof schema !== "boolean" && schema.type === "object";
+}
+function isJsonArraySchema(schema) {
+  return typeof schema !== "boolean" && schema.type === "array";
+}
+function isUnconstrainedSchema(schema) {
+  if (typeof schema === "boolean") {
+    return schema;
+  }
+  if (Object.keys(schema).every((k) => !JSON_SCHEMA_LOGIC_KEYWORDS.has(k))) {
+    return true;
+  }
+  return false;
+}
+function ensureJsonSchemaObject(schema) {
+  if (typeof schema === "boolean") {
+    return schema ? {} : { not: {} };
+  }
+  return schema;
+}
+
+function combineJsonSchemasWithComposition(keyword, schemas) {
+  if (schemas.length <= 1) {
+    return schemas[0] ?? true;
+  }
+  const mergedDefs = {};
+  const compositionBranches = [];
+  for (let i = 0; i < schemas.length; i++) {
+    const schema = schemas[i];
+    if (typeof schema === "boolean") {
+      compositionBranches.push(schema);
+      continue;
     }
-    return num;
+    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;
+      }
+    ));
+  }
+  const result = { [keyword]: compositionBranches };
+  if (Object.keys(mergedDefs).length > 0) {
+    result.$defs = mergedDefs;
   }
-  #stringToBoolean(value) {
-    const lower = value.toLowerCase();
-    if (lower === "false" || lower === "off") {
+  return result;
+}
+function isJsonPrimitiveSchema(schema) {
+  return flattenJsonUnionSchema(schema).every((s) => {
+    if (typeof s === "boolean") {
       return false;
     }
-    if (lower === "true" || lower === "on") {
+    if (typeof s.type === "string" && JSON_SCHEMA_PRIMITIVE_TYPES.has(s.type)) {
       return true;
     }
-    return value;
+    if (s.const !== void 0) {
+      return true;
+    }
+    if (s.enum !== void 0) {
+      return true;
+    }
+    return false;
+  });
+}
+function combineJsonObjectSchemaEntries(entries) {
+  const properties = {};
+  const required = [];
+  const mergedDefs = {};
+  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;
+    });
   }
-  #stringToBigInt(value) {
-    return guard(() => BigInt(value)) ?? value;
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
   }
-  #numberToBigInt(value) {
-    return guard(() => BigInt(value)) ?? value;
+  if (Object.keys(mergedDefs).length > 0) {
+    schema.$defs = mergedDefs;
   }
-  #stringToDate(value) {
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime()) || !FLEXIBLE_DATE_FORMAT_REGEX.test(value)) {
-      return value;
+  return schema;
+}
+function extractJsonObjectSchemaEntries(schema) {
+  schema = hoistRecursiveRefToDef(schema);
+  if (typeof schema !== "object") {
+    return void 0;
+  }
+  const result = extractJsonObjectSchemaEntriesInternal(omit(schema, ["$defs"]), schema.$defs, /* @__PURE__ */ new Set());
+  if (!result.objectLike) {
+    return void 0;
+  }
+  return result.entries.map(([n, s, ...r]) => [n, withRootDefs(s, schema.$defs), ...r]);
+}
+function extractJsonObjectSchemaEntriesInternal(schema, $defs, resolvingRefs) {
+  if (typeof schema !== "object") {
+    return { entries: [], objectLike: false };
+  }
+  if (typeof schema.$ref === "string") {
+    if (resolvingRefs.has(schema.$ref)) {
+      return { entries: [], objectLike: true };
+    }
+    const resolved = resolveJsonSchemaRootLocalRef(schema, $defs);
+    if (resolved !== schema) {
+      return extractJsonObjectSchemaEntriesInternal(resolved, $defs, new Set(resolvingRefs).add(schema.$ref));
+    }
+  }
+  const sources = [];
+  if (schema.properties) {
+    sources.push({
+      entries: Object.entries(schema.properties).map(([name, propertySchema]) => {
+        return [
+          name,
+          propertySchema,
+          !schema.required?.includes(name)
+        ];
+      }),
+      source: "direct"
+    });
+  }
+  let objectLike = schema.type === "object" || schema.properties !== void 0 || schema.required !== void 0 || schema.additionalProperties !== void 0;
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    const branches = schema[keyword];
+    if (branches === void 0) {
+      continue;
     }
-    return date;
+    const branchResults = branches.map((branch) => extractJsonObjectSchemaEntriesInternal(branch, $defs, resolvingRefs));
+    if (branchResults.some((result) => !result.objectLike)) {
+      return { entries: [], objectLike: false };
+    }
+    const entriesByName = /* @__PURE__ */ new Map();
+    for (const result of branchResults) {
+      for (const entry of result.entries) {
+        const entries = entriesByName.get(entry[0]);
+        if (entries) {
+          entries.push(entry);
+        } else {
+          entriesByName.set(entry[0], [entry]);
+        }
+      }
+    }
+    objectLike = true;
+    sources.push({
+      entries: Array.from(entriesByName.entries()).map(([name, entries]) => {
+        const schemas = deduplicateJsonSchemas(entries.map((entry) => entry[1]));
+        const required = keyword === "allOf" ? entries.some((entry) => !entry[2]) : branchResults.every((result) => {
+          const entry = result.entries.find((item) => item[0] === name);
+          return entry !== void 0 && !entry[2];
+        });
+        return [
+          name,
+          schemas.length === 1 ? schemas[0] : keyword === "allOf" ? { allOf: schemas } : { anyOf: schemas },
+          !required
+        ];
+      }),
+      source: keyword
+    });
   }
-  #stringToRegExp(value) {
-    const match = value.match(/^\/(.*)\/([a-z]*)$/);
-    if (match) {
-      const [, pattern, flags] = match;
-      return guard(() => new RegExp(pattern, flags)) ?? value;
+  const sourceEntries = /* @__PURE__ */ new Map();
+  for (const { entries, source } of sources) {
+    for (const entry of entries) {
+      const existing = sourceEntries.get(entry[0]);
+      if (existing) {
+        existing[source] = entry;
+      } else {
+        sourceEntries.set(entry[0], { [source]: entry });
+      }
     }
-    return value;
   }
-  #stringToURL(value) {
-    return guard(() => new URL(value)) ?? value;
+  return {
+    entries: Array.from(sourceEntries.entries()).map(([name, entries]) => {
+      const schemas = deduplicateJsonSchemas([
+        entries.direct?.[1],
+        entries.allOf?.[1],
+        entries.anyOf?.[1],
+        entries.oneOf?.[1]
+      ].filter((schema2) => schema2 !== void 0));
+      return [
+        name,
+        schemas.length === 1 ? schemas[0] : { allOf: schemas },
+        [entries.direct, entries.allOf, entries.anyOf, entries.oneOf].every((entry) => entry === void 0 || entry[2])
+      ];
+    }),
+    objectLike
+  };
+}
+function flattenJsonUnionSchema(schema) {
+  return deduplicateJsonSchemas(flattenJsonUnionSchemaInternal(schema, /* @__PURE__ */ new Set()));
+}
+function flattenJsonUnionSchemaInternal(schema, resolvingRefs) {
+  if (typeof schema !== "object") {
+    return [schema];
   }
-  #arrayToSet(value) {
-    const set = new Set(value);
-    if (set.size !== value.length) {
-      return value;
+  if (typeof schema.$ref === "string") {
+    if (resolvingRefs.has(schema.$ref)) {
+      return [];
+    }
+    const resolved = resolveJsonSchemaRootLocalRef(schema);
+    if (resolved !== schema) {
+      const result = flattenJsonUnionSchemaInternal(resolved, resolvingRefs.add(schema.$ref));
+      if (result.length > 1) {
+        return result;
+      }
     }
-    return set;
   }
-  #arrayToMap(value) {
-    if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
-      return value;
+  const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = schema;
+  const entries = Object.entries(rest).filter(([, val]) => val !== void 0);
+  for (const keyword of ["anyOf", "oneOf"]) {
+    if (schema[keyword]) {
+      return schema[keyword].flatMap((s) => {
+        s = ensureJsonSchemaObject(s);
+        const mergedSchema = {
+          ...s,
+          ...Object.fromEntries(entries.filter(([key]) => s[key] === void 0)),
+          $defs: schema.$defs
+        };
+        const conflicts = entries.filter(([key]) => s[key] !== void 0);
+        if (conflicts.length) {
+          mergedSchema.allOf = [...toArray(mergedSchema.allOf), Object.fromEntries(conflicts)];
+        }
+        return flattenJsonUnionSchemaInternal(mergedSchema, resolvingRefs);
+      });
     }
-    const result = new Map(value);
-    if (result.size !== value.length) {
-      return value;
+  }
+  return [schema];
+}
+function matchArrayableJsonSchema(schema) {
+  const schemas = flattenJsonUnionSchema(schema);
+  if (schemas.length !== 2) {
+    return void 0;
+  }
+  const arraySchema = schemas.find(isJsonArraySchema);
+  if (arraySchema === void 0) {
+    return void 0;
+  }
+  const items1 = arraySchema.items ?? true;
+  const items2 = schemas.find((s) => s !== arraySchema);
+  const logicItem1 = Object.fromEntries(
+    Object.entries(ensureJsonSchemaObject(items1)).filter(([key]) => JSON_SCHEMA_LOGIC_KEYWORDS.has(key))
+  );
+  const logicItem2 = Object.fromEntries(
+    Object.entries(ensureJsonSchemaObject(items2)).filter(([key]) => JSON_SCHEMA_LOGIC_KEYWORDS.has(key))
+  );
+  if (!isDeepEqual(logicItem1, logicItem2)) {
+    return void 0;
+  }
+  return [items2, arraySchema];
+}
+function deduplicateJsonSchemas(schemas) {
+  const result = [];
+  for (const schema of schemas) {
+    if (result.some((i) => isDeepEqual(i, schema))) {
+      continue;
+    }
+    result.push(schema);
+  }
+  return result;
+}
+function withRootDefs(schema, $defs) {
+  if (typeof schema === "boolean" || !$defs) {
+    return schema;
+  }
+  return { ...schema, $defs };
+}
+
+class DelegatingJsonSchemaConverter {
+  constructor(converters = []) {
+    this.converters = converters;
+  }
+  async convert(schema, direction) {
+    for (const converter of this.converters) {
+      if (await 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];
+  }
+}
+
+class StandardJsonSchemaConverter {
+  condition(schema, _direction) {
+    return Boolean(
+      schema && "jsonSchema" in schema["~standard"] && isTypescriptObject(schema["~standard"].jsonSchema) && "input" in schema["~standard"].jsonSchema && typeof schema["~standard"].jsonSchema.input === "function" && "output" in schema["~standard"].jsonSchema && typeof schema["~standard"].jsonSchema.output === "function"
+    );
+  }
+  convert(schema, direction) {
+    return this.convertInternal(schema, direction);
+  }
+  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];
+    } catch {
+      return [{}, true];
     }
-    return result;
   }
 }
 
-class SmartCoercionPlugin {
+class SmartCoercionHandlerPlugin {
+  name = "~smart-coercion";
   converter;
   coercer;
   cache = /* @__PURE__ */ new WeakMap();
   constructor(options = {}) {
-    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));
+    this.converter = new DelegatingJsonSchemaConverter([
+      ...toArray(options.converters),
+      new StandardJsonSchemaConverter()
+    ]);
     this.coercer = new JsonSchemaCoercer();
   }
   init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.unshift(async (options2) => {
-      const inputSchema = options2.procedure["~orpc"].inputSchema;
-      if (!inputSchema) {
-        return options2.next();
+    return {
+      ...options,
+      clientInterceptors: [
+        async ({ next, input, ...interceptorOptions }) => {
+          const inputSchemas = interceptorOptions.procedure["~orpc"].inputSchemas;
+          if (!inputSchemas) {
+            return next();
+          }
+          const coercedInput = await this.coerceValue(inputSchemas, input);
+          return next({ ...interceptorOptions, input: coercedInput });
+        },
+        ...toArray(options.clientInterceptors)
+      ]
+    };
+  }
+  async coerceValue(schemas, value) {
+    for (const schema of schemas) {
+      let converted = this.cache.get(schema);
+      if (!converted) {
+        converted = await this.converter.convert(schema, "input");
+        this.cache.set(schema, converted);
       }
-      const coercedInput = await this.#coerce(inputSchema, options2.input);
-      return options2.next({ ...options2, input: coercedInput });
-    });
+      value = this.coercer.coerce(converted, value);
+    }
+    return value;
   }
-  async #coerce(schema, value) {
-    let jsonSchema = this.cache.get(schema);
-    if (!jsonSchema) {
-      jsonSchema = (await this.converter.convert(schema, { strategy: "input" }))[1];
-      this.cache.set(schema, jsonSchema);
+}
+
+class SmartCoercionLinkPlugin {
+  constructor(contract, options = {}) {
+    this.contract = contract;
+    this.converter = new DelegatingJsonSchemaConverter([
+      ...toArray(options.converters),
+      new StandardJsonSchemaConverter()
+    ]);
+    this.coercer = new JsonSchemaCoercer();
+  }
+  name = "~smart-coercion";
+  /**
+   * Output and error values should be coerced before validation.
+   */
+  after = ["~response-validation"];
+  converter;
+  coercer;
+  cache = /* @__PURE__ */ new WeakMap();
+  init(options) {
+    return {
+      ...options,
+      interceptors: [
+        ...toArray(options.interceptors),
+        async ({ next, path }) => {
+          const procedure = getProcedureContractOrThrow(this.contract, path);
+          try {
+            const output = await next();
+            const outputSchemas = procedure["~orpc"].outputSchemas;
+            if (!outputSchemas) {
+              return output;
+            }
+            const coercedOutput = await 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;
+            if (!dataSchema) {
+              throw error;
+            }
+            const cloned = cloneORPCError(error);
+            cloned.data = await this.coerceValue([dataSchema], cloned.data);
+            throw cloned;
+          }
+        }
+      ]
+    };
+  }
+  async coerceValue(schemas, value) {
+    for (const schema of schemas) {
+      let converted = this.cache.get(schema);
+      if (!converted) {
+        converted = await this.converter.convert(schema, "output");
+        this.cache.set(schema, converted);
+      }
+      value = this.coercer.coerce(converted, value);
     }
-    return this.coercer.coerce(jsonSchema, value);
+    return value;
   }
 }
 
-export { JsonSchemaCoercer, JsonSchemaXNativeType, SmartCoercionPlugin };
+export { DelegatingJsonSchemaConverter, JsonSchemaCoercer, JsonSchemaXNativeType, SmartCoercionHandlerPlugin, SmartCoercionLinkPlugin, StandardJsonSchemaConverter, combineJsonObjectSchemaEntries, combineJsonSchemasWithComposition, decodeJsonPointerSegment, deduplicateJsonSchemas, encodeJsonPointerSegment, ensureJsonSchemaObject, extractJsonObjectSchemaEntries, flattenJsonUnionSchema, hoistRecursiveRefToDef, isJsonArraySchema, isJsonFileSchema, isJsonObjectSchema, isJsonPrimitiveSchema, isUnconstrainedSchema, mapJsonSchemaRefs, matchArrayableJsonSchema, resolveJsonSchemaRootLocalRef };