@arrirpc/schema 0.69.2 → 0.71.0

package/dist/shared/{schema.4e2863ed.cjs → schema.BcsXcrqv.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-const jtdUtils = require('jtd-utils');
+const typeDefs = require('@arrirpc/type-defs');
 
 const int8Min = -128;
 const int8Max = 127;
@@ -33,9 +33,7 @@ function isASchema(input) {
   return "parse" in input.metadata[SCHEMA_METADATA] && typeof input.metadata[SCHEMA_METADATA] === "object";
 }
 function isAScalarSchema(input) {
-  return isASchema(input) && "type" in input && typeof input.type === "string" && // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-  (jtdUtils.TypeValues.includes(input.type) || // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-  NumberTypeValues.includes(input.type));
+  return isASchema(input) && "type" in input && typeof input.type === "string" && (typeDefs.TypeValues.includes(input.type) || NumberTypeValues.includes(input.type));
 }
 const NumberTypeValues = [
   "float32",
@@ -50,45 +48,91 @@ const NumberTypeValues = [
   "uint64"
 ];
 function isAAraySchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormElements(input);
+  return isASchema(input) && typeDefs.isSchemaFormElements(input);
 }
 function isAStringEnumSchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormEnum(input);
+  return isASchema(input) && typeDefs.isSchemaFormEnum(input);
 }
 function isADiscriminatorSchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormDiscriminator(input);
+  return isASchema(input) && typeDefs.isSchemaFormDiscriminator(input);
 }
 function isARecordSchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormValues(input);
+  return isASchema(input) && typeDefs.isSchemaFormValues(input);
 }
 function isAObjectSchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormProperties(input);
+  return isASchema(input) && typeDefs.isSchemaFormProperties(input);
 }
 function isObject(input) {
   return typeof input === "object" && input !== null;
 }
 function isARefSchema(input) {
-  return isASchema(input) && jtdUtils.isSchemaFormRef(input);
+  return isASchema(input) && typeDefs.isSchemaFormRef(input);
 }
 
-function any(options = {}) {
+function createStandardSchemaProperty(validate, parse) {
   return {
+    version: 1,
+    vendor: "arri",
+    validate(input) {
+      if (validate(input)) {
+        return {
+          value: input
+        };
+      }
+      const ctx = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      try {
+        const result = parse(input, ctx);
+        if (!result || ctx.errors.length) {
+          return {
+            issues: ctx.errors.map((err) => ({
+              message: err.message ?? "Unknown error",
+              path: err.instancePath.split("/").filter((val) => val.length > 0)
+            }))
+          };
+        }
+        return {
+          value: result
+        };
+      } catch (err) {
+        return {
+          issues: [
+            {
+              message: err instanceof Error ? err.message : `${err}`
+            }
+          ]
+        };
+      }
+    }
+  };
+}
+function hideInvalidProperties(schema) {
+  Object.defineProperty(schema, "~standard", { enumerable: false });
+}
+
+function any(options = {}) {
+  const validate = (input) => true;
+  const parse = (input, context) => {
+    if (context.instancePath.length === 0 && typeof input === "string") {
+      try {
+        return JSON.parse(input);
+      } catch {
+        return input;
+      }
+    }
+    return input;
+  };
+  const result = {
     metadata: {
       id: options.id,
       description: options.description,
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
-        output: void 0,
-        parse: (input, context) => {
-          if (context.instancePath.length === 0 && typeof input === "string") {
-            try {
-              return JSON.parse(input);
-            } catch {
-              return input;
-            }
-          }
-          return input;
-        },
+        output: undefined,
+        parse,
         coerce: (input, context) => {
           if (context.instancePath.length === 0 && typeof input === "string") {
             try {
@@ -99,17 +143,26 @@ function any(options = {}) {
           }
           return input;
         },
-        validate: (input) => true,
+        validate,
         serialize(input) {
           return JSON.stringify(input);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function array(schema, opts = {}) {
-  return {
+  const validateType = (input) => {
+    return validate$5(schema, input);
+  };
+  const parseType = (input, context) => {
+    return parse$6(schema, input, context, false);
+  };
+  const result = {
     elements: schema,
     metadata: {
       id: opts.id,
@@ -117,15 +170,11 @@ function array(schema, opts = {}) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: [],
-        parse(input, context) {
-          return parse$6(schema, input, context, false);
-        },
+        parse: parseType,
         coerce(input, context) {
           return parse$6(schema, input, context, true);
         },
-        validate(input) {
-          return validate$5(schema, input);
-        },
+        validate: validateType,
         serialize(input, context) {
           const strParts = [];
           for (let i = 0; i < input.length; i++) {
@@ -141,8 +190,11 @@ function array(schema, opts = {}) {
           return `[${strParts.join(",")}]`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validateType, parseType)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$5(innerSchema, input) {
   if (!Array.isArray(input)) {
@@ -167,7 +219,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
         schemaPath: `${data.schemaPath}/elements`,
         message: `Error at ${data.instancePath}. Invalid JSON.`
       });
-      return void 0;
+      return undefined;
     }
   }
   if (!Array.isArray(parsedInput)) {
@@ -176,7 +228,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/elements`,
       message: `Error at ${data.instancePath}. Expected array. Got ${typeof input}.`
     });
-    return void 0;
+    return undefined;
   }
   const result = [];
   for (let i = 0; i < parsedInput.length; i++) {
@@ -204,13 +256,13 @@ function parse$6(innerSchema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
 
 function boolean(opts = {}) {
-  return {
+  const result = {
     type: "boolean",
     metadata: {
       id: opts.id,
@@ -242,11 +294,14 @@ function boolean(opts = {}) {
             schemaPath: context.schemaPath,
             message: `Error at ${context.instancePath}. Unable to coerce ${input} to boolean.`
           });
-          return void 0;
+          return undefined;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate$4, parse$5)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$4(input) {
   return typeof input === "boolean";
@@ -267,25 +322,19 @@ function parse$5(input, data) {
       schemaPath: `${data.schemaPath}/type`,
       message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
     });
-    return void 0;
+    return undefined;
   }
   data.errors.push({
     instancePath: data.instancePath,
     schemaPath: `${data.schemaPath}/type`,
     message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
   });
-  return void 0;
+  return undefined;
 }
 function serialize$2(input) {
   return `${input}`;
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 function sanitizeJson(json) {
   return json.replace(/[\b]/g, "\\b").replace(/[\f]/g, "\\f").replace(/[\n]/g, "\\n").replace(/[\r]/g, "\\r").replace(/[\t]/g, "\\t");
 }
@@ -390,9 +439,9 @@ function errors(schema, input) {
   return errorList;
 }
 class ValidationError extends Error {
+  errors;
   constructor(options) {
     super(options.message);
-    __publicField(this, "errors");
     this.errors = options.errors;
   }
 }
@@ -411,7 +460,13 @@ function discriminator(propA, propB, propC) {
   if (isIdShorthand) {
     opts.id = propA;
   }
-  return {
+  const isType = (input) => {
+    return validate$2(discriminator2, mapping, input);
+  };
+  const parseType = (input, context) => {
+    return parse$3(discriminator2, mapping, input, context, false);
+  };
+  const result = {
     discriminator: discriminator2,
     mapping,
     metadata: {
@@ -420,12 +475,8 @@ function discriminator(propA, propB, propC) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        validate(input) {
-          return validate$2(discriminator2, mapping, input);
-        },
-        parse(input, context) {
-          return parse$3(discriminator2, mapping, input, context, false);
-        },
+        validate: isType,
+        parse: parseType,
         coerce: (input, context) => {
           return parse$3(discriminator2, mapping, input, context, true);
         },
@@ -438,18 +489,21 @@ function discriminator(propA, propB, propC) {
               context
             );
           }
-          const result = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
+          const result2 = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
             instancePath: context.instancePath,
             schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
             errors: context.errors,
             discriminatorKey: discriminator2,
             discriminatorValue: discriminatorVal
           });
-          return result;
+          return result2;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parseType)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$2(discriminator2, mapping, input) {
   if (!isObject(input)) {
@@ -479,7 +533,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/discriminator`,
       message: `Error at ${data.instancePath}. Expected object. Got ${typeof parsedInput}.`
     });
-    return void 0;
+    return undefined;
   }
   if (!(discriminator2 in parsedInput)) {
     data.errors.push({
@@ -487,7 +541,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/discriminator`,
       message: `Error at ${data.instancePath}/${discriminator2}. Discriminator field "${discriminator2}" cannot be undefined`
     });
-    return void 0;
+    return undefined;
   }
   const acceptedDiscriminatorVals = Object.keys(mapping);
   const discriminatorVal = parsedInput[discriminator2];
@@ -499,7 +553,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
         ", "
       )}]`
     });
-    return void 0;
+    return undefined;
   }
   const targetSchema = mapping[parsedInput[discriminator2]];
   if (!targetSchema) {
@@ -556,7 +610,20 @@ function enumerator(paramA, paramB) {
     }
     return false;
   };
-  return {
+  const parse = (input, context) => {
+    if (isType(input)) {
+      return input;
+    }
+    context.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/enum`,
+      message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+        ", "
+      )}]`
+    });
+    return undefined;
+  };
+  const result = {
     enum: enumVal,
     metadata: {
       id: meta?.id,
@@ -564,19 +631,7 @@ function enumerator(paramA, paramB) {
       isDeprecated: meta?.isDeprecated,
       [SCHEMA_METADATA]: {
         output: paramA[0] ?? "",
-        parse(input, context) {
-          if (isType(input)) {
-            return input;
-          }
-          context.errors.push({
-            instancePath: context.instancePath,
-            schemaPath: `${context.schemaPath}/enum`,
-            message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
-              ", "
-            )}]`
-          });
-          return void 0;
-        },
+        parse,
         coerce: (input, context) => {
           if (isType(input)) {
             return input;
@@ -588,7 +643,7 @@ function enumerator(paramA, paramB) {
               ", "
             )}]`
           });
-          return void 0;
+          return undefined;
         },
         validate: isType,
         serialize(input, context) {
@@ -598,8 +653,11 @@ function enumerator(paramA, paramB) {
           return `"${input}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function nullable(schema, opts = {}) {
@@ -609,7 +667,16 @@ function nullable(schema, opts = {}) {
     }
     return schema.metadata[SCHEMA_METADATA].validate(val);
   };
-  return {
+  const parse = (val, data) => {
+    if (data.instancePath.length === 0 && typeof val === "string" && val === "null") {
+      return null;
+    }
+    if (val === null) {
+      return null;
+    }
+    return schema.metadata[SCHEMA_METADATA].parse(val, data);
+  };
+  const result = {
     ...schema,
     nullable: true,
     metadata: {
@@ -620,15 +687,7 @@ function nullable(schema, opts = {}) {
         output: null,
         optional: schema.metadata[SCHEMA_METADATA].optional,
         validate: isType,
-        parse(val, data) {
-          if (data.instancePath.length === 0 && typeof val === "string" && val === "null") {
-            return null;
-          }
-          if (val === null) {
-            return null;
-          }
-          return schema.metadata[SCHEMA_METADATA].parse(val, data);
-        },
+        parse,
         coerce(val, data) {
           if (val === null) {
             return null;
@@ -650,39 +709,42 @@ function nullable(schema, opts = {}) {
       }
     }
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function optional(input, opts = {}) {
   const isType = (val) => {
-    if (val === void 0) {
+    if (val === undefined) {
       return true;
     }
     return input.metadata[SCHEMA_METADATA].validate(val);
   };
-  return {
+  const parse = (val, context) => {
+    if (typeof val === "undefined") {
+      return undefined;
+    }
+    if (context.instancePath.length === 0 && val === "undefined") {
+      return undefined;
+    }
+    return input.metadata[SCHEMA_METADATA].parse(val, context);
+  };
+  const result = {
     ...input,
     metadata: {
       id: opts.id ?? input.metadata.id,
       description: opts.description ?? input.metadata.description,
       isDeprecated: opts.isDeprecated ?? input.metadata.isDeprecated,
       [SCHEMA_METADATA]: {
-        output: void 0,
+        output: undefined,
         optional: true,
         validate: isType,
-        parse: (val, data) => {
-          if (typeof val === "undefined") {
-            return void 0;
-          }
-          if (data.instancePath.length === 0 && val === "undefined") {
-            return void 0;
-          }
-          return input.metadata[SCHEMA_METADATA].parse(val, data);
-        },
+        parse,
         coerce: (val, data) => {
           if (typeof val === "undefined") {
-            return void 0;
+            return undefined;
           }
           if (val === "undefined") {
-            return void 0;
+            return undefined;
           }
           return input.metadata[SCHEMA_METADATA].coerce(val, data);
         },
@@ -693,8 +755,11 @@ function optional(input, opts = {}) {
           return input.metadata[SCHEMA_METADATA].serialize(val, data);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function clone(input, opts = {}) {
   const schema = {
@@ -706,8 +771,10 @@ function clone(input, opts = {}) {
       [SCHEMA_METADATA]: {
         ...input.metadata[SCHEMA_METADATA]
       }
-    }
+    },
+    "~standard": input["~standard"]
   };
+  hideInvalidProperties(schema);
   return schema;
 }
 
@@ -723,7 +790,7 @@ function coerceNumber(input, options) {
         schemaPath: `${options.schemaPath}/type`,
         message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} into a number`
       });
-      return void 0;
+      return undefined;
     }
     return parseNumber(parsedInput, options);
   }
@@ -848,7 +915,7 @@ function int64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -859,9 +926,9 @@ function int64(opts = {}) {
       schemaPath: `${data.schemaPath}/type`,
       instancePath: data.instancePath
     });
-    return void 0;
+    return undefined;
   }
-  return {
+  const result = {
     type: "int64",
     metadata: {
       id: opts.id,
@@ -879,8 +946,11 @@ function int64(opts = {}) {
           return `"${input.toString()}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function uint64(opts = {}) {
   function isType(input) {
@@ -905,7 +975,7 @@ function uint64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -916,9 +986,9 @@ function uint64(opts = {}) {
       schemaPath: `${data.schemaPath}/type`,
       instancePath: data.instancePath
     });
-    return void 0;
+    return undefined;
   }
-  return {
+  const result = {
     type: "uint64",
     metadata: {
       id: opts.id,
@@ -936,11 +1006,14 @@ function uint64(opts = {}) {
           return `"${input.toString()}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validateNumber(input) {
-  return typeof input === "number" || !Number.isNaN(input);
+  return typeof input === "number";
 }
 function validateInt(input, minVal, maxValue) {
   return Number.isInteger(input) && input >= minVal && input <= maxValue;
@@ -957,7 +1030,7 @@ function parseNumber(input, options) {
         schemaPath: `${options.schemaPath}/type`,
         message: `Error at ${options.instancePath}. Invalid number.`
       });
-      return void 0;
+      return undefined;
     }
     return result;
   }
@@ -969,10 +1042,41 @@ function parseNumber(input, options) {
     schemaPath: `${options.schemaPath}/type`,
     message: `Error at ${options.instancePath}. Invalid number.`
   });
-  return void 0;
+  return undefined;
 }
 function numberScalarType(type, opts, numTypeMatcher) {
-  return {
+  const validate = (input) => {
+    const isNum = validateNumber(input);
+    if (!isNum) {
+      return false;
+    }
+    return numTypeMatcher(input).success;
+  };
+  const parse = (input, context) => {
+    const result2 = parseNumber(input, context);
+    if (context.errors.length) {
+      return undefined;
+    }
+    if (typeof result2 !== "number") {
+      context?.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/type`,
+        message: `Error at ${context.instancePath}. Invalid number.`
+      });
+      return undefined;
+    }
+    const matchResult = numTypeMatcher(result2);
+    if (matchResult.success) {
+      return result2;
+    }
+    context?.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/type`,
+      message: `Error at ${context.instancePath}. ${matchResult.message}`
+    });
+    return undefined;
+  };
+  const result = {
     type,
     metadata: {
       id: opts.id,
@@ -980,62 +1084,36 @@ function numberScalarType(type, opts, numTypeMatcher) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: 0,
-        validate(input) {
-          const isNum = validateNumber(input);
-          if (!isNum) {
-            return false;
-          }
-          return numTypeMatcher(input).success;
-        },
-        parse(input, options) {
-          const result = parseNumber(input, options);
-          if (options.errors.length) {
-            return void 0;
-          }
-          if (typeof result !== "number") {
-            options?.errors.push({
-              instancePath: options.instancePath,
-              schemaPath: `${options.schemaPath}/type`,
-              message: `Error at ${options.instancePath}. Invalid number.`
-            });
-            return void 0;
-          }
-          const matchResult = numTypeMatcher(result);
-          if (matchResult.success) {
-            return result;
-          }
-          options?.errors.push({
-            instancePath: options.instancePath,
-            schemaPath: `${options.schemaPath}/type`,
-            message: `Error at ${options.instancePath}. ${matchResult.message}`
-          });
-          return void 0;
-        },
+        validate,
+        parse,
         serialize: serializeNumber,
         coerce(input, options) {
-          const result = coerceNumber(input, options);
-          if (typeof result !== "number") {
+          const result2 = coerceNumber(input, options);
+          if (typeof result2 !== "number") {
             options.errors.push({
               instancePath: options.instancePath,
               schemaPath: `${options.schemaPath}/type`,
               message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} to ${type}.`
             });
-            return void 0;
+            return undefined;
           }
-          const matchResult = numTypeMatcher(result);
+          const matchResult = numTypeMatcher(result2);
           if (matchResult.success) {
-            return result;
+            return result2;
           }
           options.errors.push({
             instancePath: options.instancePath,
             schemaPath: `${options.schemaPath}/type`,
             message: `Error at ${options.instancePath}. ${matchResult.message}`
           });
-          return void 0;
+          return undefined;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function object(propA, propB) {
@@ -1059,6 +1137,17 @@ function object(propA, propB) {
     }
     schema.properties[key] = prop;
   }
+  const validate = (input2) => {
+    return validateObjectSchema(schema, input2);
+  };
+  const parse = (input2, context) => {
+    return parseObjectSchema(
+      schema,
+      input2,
+      context,
+      false
+    );
+  };
   const result = {
     ...schema,
     metadata: {
@@ -1067,14 +1156,7 @@ function object(propA, propB) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse(input2, context) {
-          return parseObjectSchema(
-            schema,
-            input2,
-            context,
-            false
-          );
-        },
+        parse,
         coerce(input2, context) {
           return parseObjectSchema(
             schema,
@@ -1083,9 +1165,7 @@ function object(propA, propB) {
             true
           );
         },
-        validate(input2) {
-          return validateObjectSchema(schema, input2);
-        },
+        validate,
         serialize(input2, context) {
           return serializeObject(
             schema,
@@ -1094,8 +1174,10 @@ function object(propA, propB) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
   return result;
 }
 function parseObjectSchema(schema, input, data, coerce = false) {
@@ -1110,7 +1192,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
         schemaPath: `${data.schemaPath}/properties`,
         message: `Error at ${data.instancePath}. Invalid JSON.`
       });
-      return void 0;
+      return undefined;
     }
   }
   if (!isObject(parsedInput)) {
@@ -1119,7 +1201,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/properties`,
       message: `Error at ${data.instancePath}. Expected object`
     });
-    return void 0;
+    return undefined;
   }
   const result = {};
   const optionalProps = schema.optionalProperties ?? {};
@@ -1138,7 +1220,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   if (data.discriminatorKey) {
     result[data.discriminatorKey] = data.discriminatorValue;
@@ -1163,7 +1245,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
   for (const key of optionalKeys) {
     const val = parsedInput[key];
     const prop = optionalProps[key];
-    if (val === void 0) {
+    if (val === undefined) {
       continue;
     }
     if (coerce) {
@@ -1183,7 +1265,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1191,17 +1273,28 @@ function validateObjectSchema(schema, input) {
   if (!isObject(input)) {
     return false;
   }
-  const optionalProps = schema.optionalProperties ?? {};
-  for (const key of Object.keys(input)) {
-    const prop = schema.properties[key] ?? optionalProps[key];
-    if (!prop && schema.strict) {
-      return false;
+  const allowedKeys = schema.strict ? [] : undefined;
+  for (const key of Object.keys(schema.properties)) {
+    const propSchema = schema.properties[key];
+    const isValid = propSchema.metadata[SCHEMA_METADATA].validate(
+      input[key]
+    );
+    if (!isValid) return false;
+    allowedKeys?.push(key);
+  }
+  if (schema.optionalProperties) {
+    for (const key of Object.keys(schema.optionalProperties)) {
+      const propsSchema = schema.optionalProperties[key];
+      const isValid = propsSchema.metadata[SCHEMA_METADATA].validate(
+        input[key]
+      );
+      if (!isValid) return false;
+      allowedKeys?.push(key);
     }
-    if (prop) {
-      const isValid = prop.metadata[SCHEMA_METADATA].validate(input[key]);
-      if (!isValid) {
-        return false;
-      }
+  }
+  if (allowedKeys) {
+    for (const key of Object.keys(input)) {
+      if (!allowedKeys.includes(key)) return false;
     }
   }
   return true;
@@ -1233,7 +1326,13 @@ function pick(inputSchema, keys, options = {}) {
       }
     });
   }
-  return {
+  const parse = (input, context) => {
+    return parseObjectSchema(schema, input, context, false);
+  };
+  const validate = (input) => {
+    return validateObjectSchema(schema, input);
+  };
+  const result = {
     ...schema,
     metadata: {
       id: options.id,
@@ -1241,14 +1340,7 @@ function pick(inputSchema, keys, options = {}) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse: (input, context) => {
-          return parseObjectSchema(
-            schema,
-            input,
-            context,
-            true
-          );
-        },
+        parse,
         coerce(input, context) {
           return parseObjectSchema(
             schema,
@@ -1257,15 +1349,16 @@ function pick(inputSchema, keys, options = {}) {
             false
           );
         },
-        validate(input) {
-          return validateObjectSchema(schema, input);
-        },
+        validate,
         serialize(input, context) {
           return serializeObject(schema, input, context);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function omit(inputSchema, keys, options = {}) {
   const schema = {
@@ -1295,7 +1388,9 @@ function omit(inputSchema, keys, options = {}) {
       }
     });
   }
-  return {
+  const validate = (input) => validateObjectSchema(schema, input);
+  const parse = (input, context) => parseObjectSchema(schema, input, context, false);
+  const result = {
     ...schema,
     metadata: {
       id: options.id,
@@ -1303,12 +1398,8 @@ function omit(inputSchema, keys, options = {}) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        validate(input) {
-          return validateObjectSchema(schema, input);
-        },
-        parse(input, data) {
-          return parseObjectSchema(schema, input, data, false);
-        },
+        validate,
+        parse,
         serialize(input, context) {
           return serializeObject(schema, input, context);
         },
@@ -1321,8 +1412,11 @@ function omit(inputSchema, keys, options = {}) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function serializeObject(schema, input, data) {
   const strParts = [];
@@ -1419,23 +1513,20 @@ function partial(schema, options = {}) {
       }
     }
   }
+  const validate = (input) => {
+    return validateObjectSchema(newSchema, input);
+  };
+  const parse = (input, context) => {
+    return parseObjectSchema(newSchema, input, context, false);
+  };
   const meta = {
     id: options.id,
     description: options.description,
     [SCHEMA_METADATA]: {
       output: {},
       optional: schema.metadata[SCHEMA_METADATA].optional,
-      validate(input) {
-        return validateObjectSchema(newSchema, input);
-      },
-      parse(input, context) {
-        return parseObjectSchema(
-          newSchema,
-          input,
-          context,
-          false
-        );
-      },
+      validate,
+      parse,
       coerce(input, context) {
         return parseObjectSchema(
           newSchema,
@@ -1450,11 +1541,118 @@ function partial(schema, options = {}) {
     }
   };
   newSchema.metadata = meta;
+  newSchema["~standard"] = createStandardSchemaProperty(
+    validate,
+    parse
+  );
+  hideInvalidProperties(newSchema);
   return newSchema;
 }
 
+function string(opts = {}) {
+  const result = {
+    type: "string",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: "",
+        parse: parse$2,
+        coerce: coerce$1,
+        validate: validate$1,
+        serialize(input, context) {
+          if (context.instancePath.length === 0) {
+            return input;
+          }
+          if (input.length < 42) {
+            return serializeSmallString(input);
+          }
+          if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
+            return `"${input}"`;
+          }
+          return JSON.stringify(input);
+        }
+      }
+    },
+    "~standard": createStandardSchemaProperty(validate$1, parse$2)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function serializeString(input) {
+  if (input.length < 42) {
+    return serializeSmallString(input);
+  }
+  if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
+    return `"${input}"`;
+  }
+  return JSON.stringify(input);
+}
+function validate$1(input) {
+  return typeof input === "string";
+}
+function parse$2(input, context) {
+  if (validate$1(input)) {
+    return input;
+  }
+  context.errors.push({
+    instancePath: context.instancePath,
+    schemaPath: `${context.schemaPath}/type`,
+    message: `Error at ${context.instancePath}. Expected 'string' got ${typeof input}.`
+  });
+  return undefined;
+}
+function coerce$1(input, context) {
+  return parse$2(input, context);
+}
+const STR_ESCAPE = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
+);
+function serializeSmallString(input) {
+  const len = input.length;
+  let result = "";
+  let last = -1;
+  let point = 255;
+  for (let i = 0; i < len; i++) {
+    point = input.charCodeAt(i);
+    if (point < 32 || point >= 55296 && point <= 57343) {
+      return JSON.stringify(input);
+    }
+    if (point === 34 || // '"'
+    point === 92) {
+      if (last === -1) {
+        last = 0;
+      }
+      result += input.slice(last, i) + "\\";
+      last = i;
+    }
+  }
+  if (last === -1) {
+    return `"${input}"`;
+  }
+  return `"${result}${input.slice(last)}"`;
+}
+
 function record(schema, opts = {}) {
-  return {
+  const validateFn = (input) => {
+    if (!isObject(input)) {
+      return false;
+    }
+    for (const key of Object.keys(input)) {
+      const val = input[key];
+      const isValid = schema.metadata[SCHEMA_METADATA].validate(val);
+      if (!isValid) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const parseFn = (input, ctx) => {
+    return parse$1(schema, input, ctx, false);
+  };
+  const result = {
     values: schema,
     metadata: {
       id: opts.id,
@@ -1462,48 +1660,40 @@ function record(schema, opts = {}) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        validate(input) {
-          if (!isObject(input)) {
-            return false;
-          }
-          for (const key of Object.keys(input)) {
-            const val = input[key];
-            const isValid = schema.metadata[SCHEMA_METADATA].validate(val);
-            if (!isValid) {
-              return false;
-            }
-          }
-          return true;
-        },
-        parse(input, context) {
-          return parse$2(schema, input, context, false);
-        },
+        validate: validateFn,
+        parse: parseFn,
         coerce(input, data) {
-          return parse$2(schema, input, data, true);
+          return parse$1(schema, input, data, true);
         },
         serialize(input, context) {
-          const strParts = [];
-          for (const key of Object.keys(input)) {
+          let result2 = "{";
+          const keys = Object.keys(input);
+          for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             const val = input[key];
-            strParts.push(
-              `${JSON.stringify(key)}:${schema.metadata[SCHEMA_METADATA].serialize(val, {
+            if (i > 0) result2 += ",";
+            result2 += serializeString(key);
+            result2 += ":";
+            result2 += schema.metadata[SCHEMA_METADATA].serialize(
+              val,
+              {
                 instancePath: `${context.instancePath}/${key}`,
                 schemaPath: `${context.schemaPath}/values`,
                 errors: context.errors
-              })}`
+              }
             );
           }
-          const result = `{${strParts.join(",")}}`;
-          if (context.instancePath.length === 0) {
-            return sanitizeJson(result);
-          }
-          return result;
+          result2 += "}";
+          return result2;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validateFn, parseFn)
   };
+  hideInvalidProperties(result);
+  return result;
 }
-function parse$2(schema, input, data, coerce = false) {
+function parse$1(schema, input, data, coerce = false) {
   let parsedInput = input;
   if (data.instancePath.length === 0 && typeof input === "string") {
     parsedInput = JSON.parse(input);
@@ -1514,7 +1704,7 @@ function parse$2(schema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/values`,
       message: `Error at ${data.instancePath} Expected object`
     });
-    return void 0;
+    return undefined;
   }
   const result = {};
   for (const key of Object.keys(parsedInput)) {
@@ -1534,7 +1724,7 @@ function parse$2(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1552,36 +1742,43 @@ function recursive(propA, propB) {
     );
   }
   const id = options.id ?? `TypeRef${recursiveTypeCount}`;
-  const mainSchema = callback({
-    ref: id,
-    metadata: {
-      [SCHEMA_METADATA]: {
-        output: "",
-        parse(input, context) {
-          if (recursiveFns[id]) {
-            return recursiveFns[id].parse(input, context);
-          }
-        },
-        serialize(input, context) {
-          if (recursiveFns[id]) {
-            return recursiveFns[id].serialize(input, context);
-          }
-          return "";
-        },
-        validate(input) {
-          if (recursiveFns[id]) {
-            return recursiveFns[id].validate(input);
-          }
-          return false;
-        },
-        coerce(input, context) {
-          if (recursiveFns[id]) {
-            return recursiveFns[id].coerce(input, context);
-          }
+  const metadata = {
+    [SCHEMA_METADATA]: {
+      output: "",
+      parse(input, context) {
+        if (recursiveFns[id]) {
+          return recursiveFns[id].parse(input, context);
+        }
+      },
+      serialize(input, context) {
+        if (recursiveFns[id]) {
+          return recursiveFns[id].serialize(input, context);
+        }
+        return "";
+      },
+      validate(input) {
+        if (recursiveFns[id]) {
+          return recursiveFns[id].validate(input);
+        }
+        return false;
+      },
+      coerce(input, context) {
+        if (recursiveFns[id]) {
+          return recursiveFns[id].coerce(input, context);
         }
       }
     }
-  });
+  };
+  const schema = {
+    ref: id,
+    metadata,
+    "~standard": createStandardSchemaProperty(
+      metadata[SCHEMA_METADATA].validate,
+      metadata[SCHEMA_METADATA].parse
+    )
+  };
+  hideInvalidProperties(schema);
+  const mainSchema = callback(schema);
   mainSchema.metadata.id = id;
   mainSchema.metadata.description = options?.description ?? mainSchema.metadata.description;
   mainSchema.metadata.isDeprecated = options?.isDeprecated ?? mainSchema.metadata.isDeprecated;
@@ -1594,82 +1791,8 @@ function recursive(propA, propB) {
   return mainSchema;
 }
 
-function string(opts = {}) {
-  return {
-    type: "string",
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: "",
-        parse: parse$1,
-        coerce: coerce$1,
-        validate: validate$1,
-        serialize(input, context) {
-          if (context.instancePath.length === 0) {
-            return input;
-          }
-          if (input.length < 42) {
-            return serializeSmallString(input);
-          }
-          if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
-            return `"${input}"`;
-          }
-          return JSON.stringify(input);
-        }
-      }
-    }
-  };
-}
-function validate$1(input) {
-  return typeof input === "string";
-}
-function parse$1(input, context) {
-  if (validate$1(input)) {
-    return input;
-  }
-  context.errors.push({
-    instancePath: context.instancePath,
-    schemaPath: `${context.schemaPath}/type`,
-    message: `Error at ${context.instancePath}. Expected 'string' got ${typeof input}.`
-  });
-  return void 0;
-}
-function coerce$1(input, context) {
-  return parse$1(input, context);
-}
-const STR_ESCAPE = (
-  // eslint-disable-next-line no-control-regex
-  /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
-);
-function serializeSmallString(input) {
-  const len = input.length;
-  let result = "";
-  let last = -1;
-  let point = 255;
-  for (let i = 0; i < len; i++) {
-    point = input.charCodeAt(i);
-    if (point < 32 || point >= 55296 && point <= 57343) {
-      return JSON.stringify(input);
-    }
-    if (point === 34 || // '"'
-    point === 92) {
-      if (last === -1) {
-        last = 0;
-      }
-      result += input.slice(last, i) + "\\";
-      last = i;
-    }
-  }
-  if (last === -1) {
-    return `"${input}"`;
-  }
-  return `"${result}${input.slice(last)}"`;
-}
-
 function timestamp(opts = {}) {
-  return {
+  const result = {
     type: "timestamp",
     metadata: {
       id: opts.id,
@@ -1682,8 +1805,11 @@ function timestamp(opts = {}) {
         coerce,
         serialize
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate(input) {
   return typeof input === "object" && input instanceof Date;
@@ -1700,7 +1826,7 @@ function parse(input, data) {
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/type`
       });
-      return void 0;
+      return undefined;
     }
     return new Date(result);
   }
@@ -1709,7 +1835,7 @@ function parse(input, data) {
     instancePath: data.instancePath,
     schemaPath: `${data.schemaPath}/type`
   });
-  return void 0;
+  return undefined;
 }
 function coerce(input, options) {
   if (typeof input === "number") {
@@ -1726,18 +1852,21 @@ function serialize(input, data) {
 
 exports.NumberTypeValues = NumberTypeValues;
 exports.SCHEMA_METADATA = SCHEMA_METADATA;
+exports.STR_ESCAPE = STR_ESCAPE;
 exports.ValidationError = ValidationError;
 exports.any = any;
 exports.array = array;
 exports.boolean = boolean;
 exports.clone = clone;
 exports.coerce = coerce$2;
+exports.createStandardSchemaProperty = createStandardSchemaProperty;
 exports.discriminator = discriminator;
 exports.enumerator = enumerator;
 exports.errors = errors;
 exports.extend = extend;
 exports.float32 = float32;
 exports.float64 = float64;
+exports.hideInvalidProperties = hideInvalidProperties;
 exports.int16 = int16;
 exports.int16Max = int16Max;
 exports.int16Min = int16Min;
@@ -1777,6 +1906,7 @@ exports.sanitizeJson = sanitizeJson;
 exports.serialize = serialize$1;
 exports.serializeObject = serializeObject;
 exports.serializeSmallString = serializeSmallString;
+exports.serializeString = serializeString;
 exports.string = string;
 exports.stringEnum = stringEnum;
 exports.timestamp = timestamp;