schema-shield 1.0.4 → 1.1.0

package/dist/index.js

@@ -26,7 +26,21 @@ __export(lib_exports, {
 module.exports = __toCommonJS(lib_exports);
 
 // lib/utils/main-utils.ts
+var hasOwnPropertyIntrinsic = Object.prototype.hasOwnProperty;
+var hasOwnPropertyCall = Function.prototype.call.bind(
+  hasOwnPropertyIntrinsic
+);
+function definePropertyOrThrow(target, key, descriptor) {
+  if (!Reflect.defineProperty(target, key, descriptor)) {
+    throw new TypeError(`Cannot define property "${String(key)}"`);
+  }
+  return target;
+}
+function hasOwn(target, key) {
+  return hasOwnPropertyCall(target, key);
+}
 var ValidationError = class extends Error {
+  code;
   message;
   item;
   keyword;
@@ -35,42 +49,61 @@ var ValidationError = class extends Error {
   instancePath = "";
   data;
   schema;
-  _getCause(pointer = "#", instancePointer = "#") {
-    let schemaPath = `${pointer}/${this.keyword}`;
-    let instancePath = `${instancePointer}`;
-    if (typeof this.item !== "undefined") {
-      if (typeof this.item === "string" && this.item in this.schema) {
-        schemaPath += `/${this.item}`;
-      }
-      instancePath += `/${this.item}`;
-    }
-    this.instancePath = instancePath;
-    this.schemaPath = schemaPath;
-    if (!this.cause || !(this.cause instanceof ValidationError)) {
-      return this;
-    }
-    return this.cause._getCause(schemaPath, instancePath);
+  constructor(message) {
+    super(message);
+    this.message = message;
   }
   getCause() {
-    return this._getCause();
-  }
-  _getTree() {
-    const tree = {
-      message: this.message,
-      keyword: this.keyword,
-      item: this.item,
-      schemaPath: this.schemaPath,
-      instancePath: this.instancePath,
-      data: this.data
-    };
-    if (this.cause) {
-      tree.cause = this.cause._getTree();
+    let current = this;
+    let schemaPointer = "#";
+    let instancePointer = "#";
+    const seen = /* @__PURE__ */ new Set();
+    while (!seen.has(current)) {
+      seen.add(current);
+      let schemaPath = `${schemaPointer}/${current.keyword}`;
+      let instancePath = instancePointer;
+      if (typeof current.item !== "undefined") {
+        if (typeof current.item === "string" && current.schema && typeof current.schema === "object" && current.item in current.schema) {
+          schemaPath += `/${escapeJsonPointerToken(current.item)}`;
+        }
+        instancePath += `/${escapeJsonPointerToken(current.item)}`;
+      }
+      current.schemaPath = schemaPath;
+      current.instancePath = instancePath;
+      if (!(current.cause instanceof ValidationError) || seen.has(current.cause)) {
+        return current;
+      }
+      schemaPointer = schemaPath;
+      instancePointer = instancePath;
+      current = current.cause;
     }
-    return tree;
+    return current;
   }
   getTree() {
     this.getCause();
-    return this._getTree();
+    let current = this;
+    let root;
+    let target;
+    const seen = /* @__PURE__ */ new Set();
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const node = {
+        message: current.message,
+        keyword: current.keyword,
+        item: current.item,
+        schemaPath: current.schemaPath,
+        instancePath: current.instancePath,
+        data: current.data
+      };
+      if (!root) {
+        root = node;
+      } else if (target) {
+        target.cause = node;
+      }
+      target = node;
+      current = current.cause instanceof ValidationError ? current.cause : void 0;
+    }
+    return root;
   }
   getPath() {
     const cause = this.getCause();
@@ -90,8 +123,11 @@ function getDefinedErrorFunctionForKey(key, schema, failFast) {
   KeywordError.schema = schema;
   const defineError = (message, options = {}) => {
     KeywordError.message = message;
+    KeywordError.code = options.code;
     KeywordError.item = options.item;
-    KeywordError.cause = options.cause && options.cause !== true ? options.cause : void 0;
+    if (options.cause !== KeywordError) {
+      KeywordError.cause = options.cause && options.cause !== true ? options.cause : void 0;
+    }
     KeywordError.data = options.data;
     return KeywordError;
   };
@@ -100,11 +136,14 @@ function getDefinedErrorFunctionForKey(key, schema, failFast) {
     defineError
   );
 }
+function escapeJsonPointerToken(value) {
+  return String(value).replace(/~/g, "~0").replace(/\//g, "~1");
+}
 function isCompiledSchema(subSchema) {
   return !!subSchema && typeof subSchema === "object" && !Array.isArray(subSchema) && "$validate" in subSchema;
 }
 function getNamedFunction(name, fn) {
-  return Object.defineProperty(fn, "name", { value: name });
+  return definePropertyOrThrow(fn, "name", { value: name });
 }
 function resolvePath(root, path) {
   if (!path || path === "#") {
@@ -149,7 +188,6 @@ var DURATION_REGEX = /^P(?!$)((\d+Y)?(\d+M)?(\d+W)?(\d+D)?)(T(?=\d)(\d+H)?(\d+M)
 var URI_REGEX = /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/;
 var EMAIL_REGEX = /^(?!\.)(?!.*\.$)[a-z0-9!#$%&'*+/=?^_`{|}~-]{1,20}(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]{1,21}){0,2}@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,60}[a-z0-9])?){0,3}$/i;
 var HOSTNAME_REGEX = /^[a-z0-9][a-z0-9-]{0,62}(?:\.[a-z0-9][a-z0-9-]{0,62})*[a-z0-9]$/i;
-var DATE_REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;
 var TIME_REGEX = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(\.\d+)?(Z|([+-])([01]\d|2[0-3]):([0-5]\d))$/;
 var URI_REFERENCE_REGEX = /^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#((?![^#]*\\)[^#]*))?/i;
 var IRI_REGEX = /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/;
@@ -214,6 +252,22 @@ function isValidIpv4(data) {
 function isHexCharCode(code) {
   return code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
 }
+function hasValidPercentEncoding(data) {
+  for (let index = 0; index < data.length; index++) {
+    const code = data.charCodeAt(index);
+    if (code === 92) {
+      return false;
+    }
+    if (code !== 37) {
+      continue;
+    }
+    if (index + 2 >= data.length || !isHexCharCode(data.charCodeAt(index + 1)) || !isHexCharCode(data.charCodeAt(index + 2))) {
+      return false;
+    }
+    index += 2;
+  }
+  return true;
+}
 function isValidIpv6(data) {
   const length = data.length;
   if (length === 0) {
@@ -318,7 +372,7 @@ function isValidJsonPointer(data) {
 }
 function isValidRelativeJsonPointer(data) {
   if (data.length === 0) {
-    return true;
+    return false;
   }
   let i = 0;
   while (i < data.length) {
@@ -331,6 +385,9 @@ function isValidRelativeJsonPointer(data) {
   if (i === 0) {
     return false;
   }
+  if (i > 1 && data.charCodeAt(0) === 48) {
+    return false;
+  }
   if (i === data.length) {
     return true;
   }
@@ -457,7 +514,7 @@ var Formats = {
     return true;
   },
   uri(data) {
-    return URI_REGEX.test(data);
+    return URI_REGEX.test(data) && hasValidPercentEncoding(data);
   },
   email(data) {
     return EMAIL_REGEX.test(data);
@@ -472,15 +529,13 @@ var Formats = {
     return HOSTNAME_REGEX.test(data);
   },
   date(data) {
-    const match = DATE_REGEX.exec(data);
-    if (!match) {
+    if (data.length !== 10 || data.charCodeAt(4) !== 45 || data.charCodeAt(7) !== 45) {
       return false;
     }
-    const [, yearStr, monthStr, dayStr] = match;
-    const year = Number(yearStr);
-    const month = Number(monthStr);
-    const day = Number(dayStr);
-    if (month < 1 || month > 12) {
+    const year = parseFourDigits(data, 0);
+    const month = parseTwoDigits(data, 5);
+    const day = parseTwoDigits(data, 8);
+    if (year < 0 || month < 1 || month > 12) {
       return false;
     }
     if (day < 1) {
@@ -552,10 +607,10 @@ var Types = {
     return typeof data === "string";
   },
   number(data) {
-    return typeof data === "number";
+    return typeof data === "number" && Number.isFinite(data);
   },
   integer(data) {
-    return typeof data === "number" && data % 1 === 0;
+    return typeof data === "number" && Number.isFinite(data) && data % 1 === 0;
   },
   boolean(data) {
     return typeof data === "boolean";
@@ -780,7 +835,7 @@ var ArrayKeywords = {
     let tupleLength = schema._tupleItemsLength;
     if (tupleLength === void 0) {
       tupleLength = schema.items.length;
-      Object.defineProperty(schema, "_tupleItemsLength", {
+      definePropertyOrThrow(schema, "_tupleItemsLength", {
         value: tupleLength,
         enumerable: false,
         configurable: false,
@@ -837,13 +892,23 @@ var ArrayKeywords = {
       }
       return;
     }
-    const primitiveSeen = /* @__PURE__ */ new Set();
+    let hasFirstPrimitive = false;
+    let firstPrimitive;
+    let primitiveSeen;
     let primitiveArraySignatures;
     let arrayBuckets;
     let objectBuckets;
     for (let i = 0; i < len; i++) {
       const item = data[i];
       if (isUniquePrimitive(item)) {
+        if (!hasFirstPrimitive) {
+          hasFirstPrimitive = true;
+          firstPrimitive = item;
+          continue;
+        }
+        if (!primitiveSeen) {
+          primitiveSeen = /* @__PURE__ */ new Set([firstPrimitive]);
+        }
         if (primitiveSeen.has(item)) {
           return defineError("Array items are not unique", { data: item });
         }
@@ -929,7 +994,7 @@ function isPlainObject(value) {
   if (!value || typeof value !== "object") {
     return false;
   }
-  const proto = Object.getPrototypeOf(value);
+  const proto = Reflect.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
 function canUseStructuredClone(value) {
@@ -1024,7 +1089,7 @@ function deepCloneUnfreeze(obj, cloneClassInstances = false, seen = /* @__PURE__
         seen.set(source, clone);
         return clone;
       }
-      clone = Object.create(Object.getPrototypeOf(source));
+      clone = Object.create(Reflect.getPrototypeOf(source));
       seen.set(source, clone);
       break;
     }
@@ -1053,7 +1118,7 @@ function deepCloneUnfreeze(obj, cloneClassInstances = false, seen = /* @__PURE__
         seen
       );
     }
-    Object.defineProperty(clone, key, descriptor);
+    definePropertyOrThrow(clone, key, descriptor);
   }
   return clone;
 }
@@ -1064,6 +1129,9 @@ var NumberKeywords = {
     if (typeof data !== "number") {
       return;
     }
+    if (!Number.isFinite(data)) {
+      return defineError("Value must be finite", { data });
+    }
     let min = schema.minimum;
     if (typeof schema.exclusiveMinimum === "number") {
       min = schema.exclusiveMinimum + 1e-15;
@@ -1079,6 +1147,9 @@ var NumberKeywords = {
     if (typeof data !== "number") {
       return;
     }
+    if (!Number.isFinite(data)) {
+      return defineError("Value must be finite", { data });
+    }
     let max = schema.maximum;
     if (typeof schema.exclusiveMaximum === "number") {
       max = schema.exclusiveMaximum - 1e-15;
@@ -1094,11 +1165,14 @@ var NumberKeywords = {
     if (typeof data !== "number") {
       return;
     }
-    const quotient = data / schema.multipleOf;
-    if (!isFinite(quotient)) {
-      return;
+    if (!Number.isFinite(data) || !Number.isFinite(schema.multipleOf) || schema.multipleOf <= 0) {
+      return defineError("Value must use a finite positive multipleOf", {
+        data
+      });
     }
-    if (!areCloseEnough(quotient, Math.round(quotient))) {
+    const quotient = data / schema.multipleOf;
+    const valid = Number.isFinite(quotient) ? areCloseEnough(quotient, Math.round(quotient)) : data % schema.multipleOf === 0;
+    if (!valid) {
       return defineError("Value is not a multiple of the multipleOf", { data });
     }
     return;
@@ -1187,6 +1261,29 @@ function compilePatternMatcher(pattern) {
 
 // lib/keywords/object-keywords.ts
 var PATTERN_KEY_CACHE_LIMIT = 512;
+function createApplyPropertyDefaults(replaceEmpty) {
+  return function applyPropertyDefaults2(schema, data, instance) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return;
+    }
+    const defaultKeys = schema._defaultKeys;
+    for (let i = 0; i < defaultKeys.length; i++) {
+      const key = defaultKeys[i];
+      const hasOwnValue = hasOwn(data, key);
+      const value = hasOwnValue ? data[key] : void 0;
+      if (hasOwnValue && value !== void 0 && (!replaceEmpty || value !== null && value !== "")) {
+        continue;
+      }
+      instance.setDefault(
+        data,
+        key,
+        deepCloneUnfreeze(schema.properties[key].default)
+      );
+    }
+  };
+}
+var applyPropertyDefaults = createApplyPropertyDefaults(false);
+var applyEmptyPropertyDefaults = createApplyPropertyDefaults(true);
 function getPatternPropertyEntries(schema) {
   let entries = schema._patternPropertyEntries;
   if (entries) {
@@ -1206,7 +1303,7 @@ function getPatternPropertyEntries(schema) {
       match
     };
   }
-  Object.defineProperty(schema, "_patternPropertyEntries", {
+  definePropertyOrThrow(schema, "_patternPropertyEntries", {
     value: entries,
     enumerable: false,
     configurable: false,
@@ -1223,7 +1320,7 @@ function getPatternKeyMatchIndexes(schema, key, entries) {
     }
   } else {
     cache = /* @__PURE__ */ new Map();
-    Object.defineProperty(schema, "_patternKeyMatchIndexCache", {
+    definePropertyOrThrow(schema, "_patternKeyMatchIndexCache", {
       value: cache,
       enumerable: false,
       configurable: false,
@@ -1248,7 +1345,7 @@ var ObjectKeywords = {
     }
     for (let i = 0; i < schema.required.length; i++) {
       const key = schema.required[i];
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         return defineError("Required property is missing", {
           item: key,
           data: data[key]
@@ -1257,45 +1354,15 @@ var ObjectKeywords = {
     }
     return;
   },
-  properties(schema, data, defineError) {
+  properties(schema, data, defineError, instance) {
     if (!data || typeof data !== "object" || Array.isArray(data)) {
       return;
     }
-    let propKeys = schema._propKeys;
-    if (!propKeys) {
-      propKeys = Object.keys(schema.properties || {});
-      Object.defineProperty(schema, "_propKeys", {
-        value: propKeys,
-        enumerable: false,
-        configurable: false,
-        writable: false
-      });
-    }
-    let requiredSet = schema._requiredSet;
-    if (requiredSet === void 0) {
-      requiredSet = Array.isArray(schema.required) ? new Set(schema.required) : null;
-      Object.defineProperty(schema, "_requiredSet", {
-        value: requiredSet,
-        enumerable: false,
-        configurable: false,
-        writable: false
-      });
-    }
+    const propKeys = schema._propKeys;
     for (let i = 0; i < propKeys.length; i++) {
       const key = propKeys[i];
       const schemaProp = schema.properties[key];
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
-        if (requiredSet && requiredSet.has(key) && schemaProp && typeof schemaProp === "object" && !Array.isArray(schemaProp) && "default" in schemaProp) {
-          const error = schemaProp.$validate(schemaProp.default);
-          if (error) {
-            return defineError("Default property is invalid", {
-              item: key,
-              cause: error,
-              data: schemaProp.default
-            });
-          }
-          data[key] = deepCloneUnfreeze(schemaProp.default);
-        }
+      if (!hasOwn(data, key)) {
         continue;
       }
       if (typeof schemaProp === "boolean") {
@@ -1330,7 +1397,7 @@ var ObjectKeywords = {
       return;
     }
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       const error = validate(data[key]);
@@ -1349,7 +1416,7 @@ var ObjectKeywords = {
     }
     let count = 0;
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       count++;
@@ -1365,7 +1432,7 @@ var ObjectKeywords = {
     }
     let count = 0;
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       count++;
@@ -1382,7 +1449,7 @@ var ObjectKeywords = {
     let apValidate = schema._apValidate;
     if (apValidate === void 0) {
       apValidate = isCompiledSchema(schema.additionalProperties) ? schema.additionalProperties.$validate : null;
-      Object.defineProperty(schema, "_apValidate", {
+      definePropertyOrThrow(schema, "_apValidate", {
         value: apValidate,
         enumerable: false,
         configurable: false,
@@ -1391,10 +1458,10 @@ var ObjectKeywords = {
     }
     const patternEntries = getPatternPropertyEntries(schema);
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
-      if (schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, key)) {
+      if (schema.properties && hasOwn(schema.properties, key)) {
         continue;
       }
       if (patternEntries && patternEntries.length) {
@@ -1430,12 +1497,12 @@ var ObjectKeywords = {
       return;
     }
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       const matchingIndexes = getPatternKeyMatchIndexes(schema, key, patternEntries);
       if (matchingIndexes.length === 0) {
-        if (schema.additionalProperties === false && !(schema.properties && Object.prototype.hasOwnProperty.call(schema.properties, key))) {
+        if (schema.additionalProperties === false && !(schema.properties && hasOwn(schema.properties, key))) {
           return defineError("Additional properties are not allowed", {
             item: key,
             data: data[key]
@@ -1476,7 +1543,7 @@ var ObjectKeywords = {
     if (typeof pn === "boolean") {
       if (pn === false) {
         for (const key in data) {
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
+          if (hasOwn(data, key)) {
             return defineError("Properties are not allowed", { data });
           }
         }
@@ -1488,7 +1555,7 @@ var ObjectKeywords = {
       return;
     }
     for (const key in data) {
-      if (!Object.prototype.hasOwnProperty.call(data, key)) {
+      if (!hasOwn(data, key)) {
         continue;
       }
       const error = validate(key);
@@ -1587,7 +1654,7 @@ function getBranchEntries(schema, key) {
   for (let i = 0; i < source.length; i++) {
     entries.push(toBranchEntry(source[i]));
   }
-  Object.defineProperty(schema, cacheKey, {
+  definePropertyOrThrow(schema, cacheKey, {
     value: entries,
     enumerable: false,
     configurable: false,
@@ -1595,6 +1662,147 @@ function getBranchEntries(schema, key) {
   });
   return entries;
 }
+function evaluateAllOf(branches, data, defineError) {
+  for (let i = 0; i < branches.length; i++) {
+    const branch = branches[i];
+    if (branch.kind === "validate") {
+      const error = branch.validate(data);
+      if (error) {
+        return defineError("Value is not valid", { cause: error, data });
+      }
+      continue;
+    }
+    if (branch.kind === "alwaysValid") {
+      continue;
+    }
+    if (branch.kind === "alwaysInvalid" || data !== branch.value) {
+      return defineError("Value is not valid", { data });
+    }
+  }
+}
+function evaluateAnyOf(branches, data, defineError) {
+  for (let i = 0; i < branches.length; i++) {
+    const branch = branches[i];
+    if (branch.kind === "validate") {
+      if (!branch.validate(data)) {
+        return;
+      }
+      continue;
+    }
+    if (branch.kind === "alwaysValid") {
+      return;
+    }
+    if (branch.kind === "literal" && data === branch.value) {
+      return;
+    }
+  }
+  return defineError("Value is not valid", { data });
+}
+function evaluateOneOf(branches, data, defineError) {
+  let validCount = 0;
+  let winnerIndex = -1;
+  for (let i = 0; i < branches.length; i++) {
+    const branch = branches[i];
+    let isValid = false;
+    if (branch.kind === "validate") {
+      isValid = !branch.validate(data);
+    } else if (branch.kind === "alwaysValid") {
+      isValid = true;
+    } else if (branch.kind === "literal") {
+      isValid = data === branch.value;
+    }
+    if (isValid) {
+      validCount++;
+      winnerIndex = i;
+      if (validCount > 1) {
+        return {
+          error: defineError("Value is not valid", { data }),
+          winnerIndex: -1
+        };
+      }
+    }
+  }
+  return {
+    error: validCount === 1 ? void 0 : defineError("Value is not valid", { data }),
+    winnerIndex: validCount === 1 ? winnerIndex : -1
+  };
+}
+function createCombinatorValidator(key, schema, defineError, validateSubschema, transactions) {
+  const sourceBranches = getBranchEntries(schema, key);
+  const branches = validateSubschema ? sourceBranches.map(
+    (branch, index) => branch.kind === "validate" ? {
+      kind: "validate",
+      validate: (data) => validateSubschema(schema[key][index], data)
+    } : branch
+  ) : sourceBranches;
+  if (!transactions) {
+    if (key === "allOf") {
+      return (data) => evaluateAllOf(branches, data, defineError);
+    }
+    if (key === "anyOf") {
+      return (data) => evaluateAnyOf(branches, data, defineError);
+    }
+    return (data) => evaluateOneOf(branches, data, defineError).error;
+  }
+  if (key === "allOf") {
+    return (data) => {
+      const savepoint = transactions.savepoint();
+      try {
+        const error = evaluateAllOf(branches, data, defineError);
+        if (error) {
+          transactions.rollback(savepoint);
+        }
+        return error;
+      } catch (error) {
+        transactions.rollback(savepoint);
+        throw error;
+      }
+    };
+  }
+  if (key === "anyOf") {
+    return (data) => evaluateAnyOf(branches, data, defineError);
+  }
+  return (data) => {
+    const savepoint = transactions.savepoint();
+    const defaultsByBranch = [];
+    const isolatedBranches = branches.map(
+      (branch, index) => branch.kind === "validate" ? {
+        kind: "validate",
+        validate: (value) => {
+          const branchSavepoint = transactions.savepoint();
+          const error = branch.validate(value);
+          if (!error) {
+            defaultsByBranch[index] = transactions.capture(branchSavepoint);
+          }
+          return error;
+        }
+      } : branch
+    );
+    try {
+      const result = evaluateOneOf(isolatedBranches, data, defineError);
+      if (result.error) {
+        transactions.rollback(savepoint);
+        return result.error;
+      }
+      transactions.restore(defaultsByBranch[result.winnerIndex] || []);
+      return;
+    } catch (error) {
+      transactions.rollback(savepoint);
+      throw error;
+    }
+  };
+}
+function prepareCombinatorEntries(schema) {
+  if (Array.isArray(schema.allOf)) {
+    getBranchEntries(schema, "allOf");
+  }
+  if (Array.isArray(schema.anyOf)) {
+    getBranchEntries(schema, "anyOf");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    getBranchEntries(schema, "oneOf");
+  }
+}
 var OtherKeywords = {
   enum(schema, data, defineError) {
     let enumCache = schema._enumCache;
@@ -1611,7 +1819,7 @@ var OtherKeywords = {
         }
       }
       enumCache = { primitiveSet, objectValues };
-      Object.defineProperty(schema, "_enumCache", {
+      definePropertyOrThrow(schema, "_enumCache", {
         value: enumCache,
         enumerable: false,
         configurable: false,
@@ -1631,137 +1839,13 @@ var OtherKeywords = {
     return defineError("Value is not one of the allowed values", { data });
   },
   allOf(schema, data, defineError) {
-    const branches = getBranchEntries(schema, "allOf");
-    if (branches.length === 1) {
-      const onlyBranch = branches[0];
-      if (onlyBranch.kind === "validate") {
-        const error = onlyBranch.validate(data);
-        if (error) {
-          return defineError("Value is not valid", { cause: error, data });
-        }
-        return;
-      }
-      if (onlyBranch.kind === "alwaysValid") {
-        return;
-      }
-      if (onlyBranch.kind === "alwaysInvalid") {
-        return defineError("Value is not valid", { data });
-      }
-      if (data !== onlyBranch.value) {
-        return defineError("Value is not valid", { data });
-      }
-      return;
-    }
-    for (let i = 0; i < branches.length; i++) {
-      const branch = branches[i];
-      if (branch.kind === "validate") {
-        const error = branch.validate(data);
-        if (error) {
-          return defineError("Value is not valid", { cause: error, data });
-        }
-        continue;
-      }
-      if (branch.kind === "alwaysValid") {
-        continue;
-      }
-      if (branch.kind === "alwaysInvalid") {
-        return defineError("Value is not valid", { data });
-      }
-      if (data !== branch.value) {
-        return defineError("Value is not valid", { data });
-      }
-    }
-    return;
+    return createCombinatorValidator("allOf", schema, defineError)(data);
   },
   anyOf(schema, data, defineError) {
-    const branches = getBranchEntries(schema, "anyOf");
-    if (branches.length === 1) {
-      const onlyBranch = branches[0];
-      if (onlyBranch.kind === "validate") {
-        const error = onlyBranch.validate(data);
-        if (!error) {
-          return;
-        }
-        return defineError("Value is not valid", { data });
-      }
-      if (onlyBranch.kind === "alwaysValid") {
-        return;
-      }
-      if (onlyBranch.kind === "alwaysInvalid") {
-        return defineError("Value is not valid", { data });
-      }
-      if (data === onlyBranch.value) {
-        return;
-      }
-      return defineError("Value is not valid", { data });
-    }
-    for (let i = 0; i < branches.length; i++) {
-      const branch = branches[i];
-      if (branch.kind === "validate") {
-        const error = branch.validate(data);
-        if (!error) {
-          return;
-        }
-        continue;
-      }
-      if (branch.kind === "alwaysValid") {
-        return;
-      }
-      if (branch.kind === "alwaysInvalid") {
-        continue;
-      }
-      if (data === branch.value) {
-        return;
-      }
-    }
-    return defineError("Value is not valid", { data });
+    return createCombinatorValidator("anyOf", schema, defineError)(data);
   },
   oneOf(schema, data, defineError) {
-    const branches = getBranchEntries(schema, "oneOf");
-    if (branches.length === 1) {
-      const onlyBranch = branches[0];
-      if (onlyBranch.kind === "validate") {
-        const error = onlyBranch.validate(data);
-        if (!error) {
-          return;
-        }
-        return defineError("Value is not valid", { data });
-      }
-      if (onlyBranch.kind === "alwaysValid") {
-        return;
-      }
-      if (onlyBranch.kind === "alwaysInvalid") {
-        return defineError("Value is not valid", { data });
-      }
-      if (data === onlyBranch.value) {
-        return;
-      }
-      return defineError("Value is not valid", { data });
-    }
-    let validCount = 0;
-    for (let i = 0; i < branches.length; i++) {
-      const branch = branches[i];
-      let isValid = false;
-      if (branch.kind === "validate") {
-        isValid = !branch.validate(data);
-      } else if (branch.kind === "alwaysValid") {
-        isValid = true;
-      } else if (branch.kind === "alwaysInvalid") {
-        isValid = false;
-      } else {
-        isValid = data === branch.value;
-      }
-      if (isValid) {
-        validCount++;
-        if (validCount > 1) {
-          return defineError("Value is not valid", { data });
-        }
-      }
-    }
-    if (validCount === 1) {
-      return;
-    }
-    return defineError("Value is not valid", { data });
+    return createCombinatorValidator("oneOf", schema, defineError)(data);
   },
   const(schema, data, defineError) {
     if (data === schema.const) {
@@ -1821,45 +1905,62 @@ var OtherKeywords = {
     }
     return defineError("Value is not valid", { data });
   },
-  $ref(schema, data, defineError, instance) {
-    if (schema._resolvedRef) {
-      if (schema.$validate !== schema._resolvedRef) {
-        schema.$validate = schema._resolvedRef;
-      }
+  $ref(schema, data, defineError) {
+    if (typeof schema._resolvedRef === "function") {
       return schema._resolvedRef(data);
     }
-    const refPath = schema.$ref;
-    let targetSchema = instance.getSchemaRef(refPath);
-    if (!targetSchema) {
-      targetSchema = instance.getSchemaById(refPath);
-    }
-    if (!targetSchema) {
-      return defineError(`Missing reference: ${refPath}`);
-    }
-    if (!targetSchema.$validate) {
-      return;
-    }
-    schema._resolvedRef = targetSchema.$validate;
-    schema.$validate = schema._resolvedRef;
-    return schema._resolvedRef(data);
+    return defineError(`Missing reference: ${schema.$ref}`);
   }
 };
 
 // lib/keywords/string-keywords.ts
 var PATTERN_MATCH_CACHE_LIMIT = 512;
 var FORMAT_RESULT_CACHE_LIMIT = 512;
+function hasAtLeastCodePoints(value, limit) {
+  let count = 0;
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319 && index + 1 < value.length) {
+      const nextUnit = value.charCodeAt(index + 1);
+      if (nextUnit >= 56320 && nextUnit <= 57343) {
+        index++;
+      }
+    }
+    count++;
+    if (count >= limit) {
+      return true;
+    }
+  }
+  return count >= limit;
+}
 var StringKeywords = {
   minLength(schema, data, defineError) {
-    if (typeof data !== "string" || data.length >= schema.minLength) {
+    if (typeof data !== "string") {
+      return;
+    }
+    const units = data.length;
+    const limit = schema.minLength;
+    if (units < limit) {
+      return defineError("Value is shorter than the minimum length", { data });
+    }
+    if (units - limit >= limit || hasAtLeastCodePoints(data, limit)) {
       return;
     }
     return defineError("Value is shorter than the minimum length", { data });
   },
   maxLength(schema, data, defineError) {
-    if (typeof data !== "string" || data.length <= schema.maxLength) {
+    if (typeof data !== "string") {
+      return;
+    }
+    const units = data.length;
+    const limit = schema.maxLength;
+    if (units <= limit) {
       return;
     }
-    return defineError("Value is longer than the maximum length", { data });
+    if (units - limit > limit || hasAtLeastCodePoints(data, limit + 1)) {
+      return defineError("Value is longer than the maximum length", { data });
+    }
+    return;
   },
   pattern(schema, data, defineError) {
     if (typeof data !== "string") {
@@ -1871,7 +1972,7 @@ var StringKeywords = {
       try {
         const compiled = compilePatternMatcher(schema.pattern);
         patternMatch = compiled instanceof RegExp ? (value) => compiled.test(value) : compiled;
-        Object.defineProperty(schema, "_patternMatch", {
+        definePropertyOrThrow(schema, "_patternMatch", {
           value: patternMatch,
           enumerable: false,
           configurable: false,
@@ -1886,7 +1987,7 @@ var StringKeywords = {
     }
     if (!patternMatchCache) {
       patternMatchCache = /* @__PURE__ */ new Map();
-      Object.defineProperty(schema, "_patternMatchCache", {
+      definePropertyOrThrow(schema, "_patternMatchCache", {
         value: patternMatchCache,
         enumerable: false,
         configurable: false,
@@ -1918,7 +2019,7 @@ var StringKeywords = {
     let formatResultCache = schema._formatResultCache;
     if (formatValidate === void 0) {
       formatValidate = instance.getFormat(schema.format);
-      Object.defineProperty(schema, "_formatValidate", {
+      definePropertyOrThrow(schema, "_formatValidate", {
         value: formatValidate,
         enumerable: false,
         configurable: false,
@@ -1933,7 +2034,7 @@ var StringKeywords = {
         schema.format,
         formatValidate
       );
-      Object.defineProperty(schema, "_formatResultCacheEnabled", {
+      definePropertyOrThrow(schema, "_formatResultCacheEnabled", {
         value: formatResultCacheEnabled,
         enumerable: false,
         configurable: false,
@@ -1948,7 +2049,7 @@ var StringKeywords = {
     }
     if (!formatResultCache) {
       formatResultCache = /* @__PURE__ */ new Map();
-      Object.defineProperty(schema, "_formatResultCache", {
+      definePropertyOrThrow(schema, "_formatResultCache", {
         value: formatResultCache,
         enumerable: false,
         configurable: false,
@@ -1981,20 +2082,61 @@ var keywords = {
 };
 
 // lib/index.ts
+var MAX_COMPILE_DEPTH = 128;
+var LOCAL_SCHEMA_BASE = "schema-shield://local/root";
+var FAIL_FAST_TYPE_VALIDATORS = {
+  object: (data) => data !== null && typeof data === "object" && !Array.isArray(data) ? void 0 : true,
+  array: (data) => Array.isArray(data) ? void 0 : true,
+  string: (data) => typeof data === "string" ? void 0 : true,
+  number: (data) => typeof data === "number" && Number.isFinite(data) ? void 0 : true,
+  integer: (data) => typeof data === "number" && Number.isFinite(data) && Number.isInteger(data) ? void 0 : true,
+  boolean: (data) => typeof data === "boolean" ? void 0 : true,
+  null: (data) => data === null ? void 0 : true
+};
+function createBuiltinTypeValidator(_type, defineError, fallback) {
+  return (data) => {
+    if (!fallback(data)) {
+      return defineError("Invalid type", { data });
+    }
+  };
+}
 var SchemaShield = class {
   types = {};
   formats = {};
   keywords = {};
   immutable = false;
+  useDefaults = false;
   rootSchema = null;
-  idRegistry = /* @__PURE__ */ new Map();
   failFast = true;
+  maxDepth;
+  validationContexts = [];
+  compileCache = /* @__PURE__ */ new WeakMap();
+  compilingRequiresContext = false;
+  compilingMutableSchemas = /* @__PURE__ */ new WeakSet();
   constructor({
     immutable = false,
-    failFast = true
+    failFast = true,
+    maxDepth = 128,
+    useDefaults = false
   } = {}) {
+    if (!Number.isInteger(maxDepth) || maxDepth < 1 || maxDepth > 256) {
+      const error = new ValidationError("maxDepth must be an integer from 1 to 256");
+      error.code = "INVALID_MAX_DEPTH";
+      error.keyword = "maxDepth";
+      throw error;
+    }
+    if (useDefaults !== false && useDefaults !== true && useDefaults !== "empty") {
+      const error = new ValidationError(
+        'useDefaults must be false, true, or "empty"'
+      );
+      error.code = "INVALID_USE_DEFAULTS";
+      error.keyword = "useDefaults";
+      throw error;
+    }
     this.immutable = immutable;
     this.failFast = failFast;
+    this.maxDepth = maxDepth;
+    this.useDefaults = useDefaults;
     for (const [type, validator] of Object.entries(Types)) {
       if (validator) {
         this.addType(type, validator);
@@ -2009,6 +2151,50 @@ var SchemaShield = class {
       }
     }
   }
+  setDefault(target, key, value) {
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    if (context) {
+      context.defaults.push({
+        target,
+        key,
+        descriptor: Reflect.getOwnPropertyDescriptor(target, key)
+      });
+    }
+    definePropertyOrThrow(target, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  #defaultSavepoint() {
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    return context ? context.defaults.length : 0;
+  }
+  #rollbackDefaultSavepoint(savepoint) {
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    if (context) {
+      this.rollbackDefaults(context, savepoint);
+    }
+  }
+  #captureDefaultSavepoint(savepoint) {
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    if (!context || context.defaults.length === savepoint) {
+      return [];
+    }
+    const mutations = context.defaults.slice(savepoint).map((entry) => ({
+      ...entry,
+      value: entry.target[entry.key]
+    }));
+    this.rollbackDefaults(context, savepoint);
+    return mutations;
+  }
+  #restoreDefaults(mutations) {
+    for (let index = 0; index < mutations.length; index++) {
+      const mutation = mutations[index];
+      this.setDefault(mutation.target, mutation.key, mutation.value);
+    }
+  }
   addType(name, validator, overwrite = false) {
     if (this.types[name] && !overwrite) {
       throw new ValidationError(`Type "${name}" already exists`);
@@ -2046,14 +2232,465 @@ var SchemaShield = class {
     return resolvePath(this.rootSchema, path);
   }
   getSchemaById(id) {
-    return this.idRegistry.get(id);
+    if (!this.rootSchema) {
+      return;
+    }
+    const stack = [this.rootSchema];
+    const seen = /* @__PURE__ */ new WeakSet();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (seen.has(node)) {
+        continue;
+      }
+      seen.add(node);
+      if (node.$id === id) {
+        return node;
+      }
+      const children = this.schemaChildren(node);
+      for (let index = 0; index < children.length; index++) {
+        stack.push(children[index]);
+      }
+    }
+    return;
+  }
+  depthError(message = "Maximum schema depth exceeded") {
+    if (this.failFast) {
+      return true;
+    }
+    const error = new ValidationError(message);
+    error.code = "MAX_DEPTH_EXCEEDED";
+    error.keyword = "maxDepth";
+    return error;
+  }
+  schemaChildEntries(schema) {
+    const children = [];
+    const mapKeys = [
+      "properties",
+      "patternProperties",
+      "definitions",
+      "$defs",
+      "dependencies"
+    ];
+    const arrayKeys = ["allOf", "anyOf", "oneOf", "items"];
+    const singleKeys = [
+      "items",
+      "additionalItems",
+      "additionalProperties",
+      "contains",
+      "propertyNames",
+      "values",
+      "elements",
+      "not",
+      "if",
+      "then",
+      "else"
+    ];
+    for (const key of mapKeys) {
+      const value = schema[key];
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        continue;
+      }
+      for (const childKey of Object.keys(value)) {
+        const child = value[childKey];
+        if (child && typeof child === "object") {
+          children.push({
+            value: child,
+            pointer: `/${this.escapePointerToken(key)}/${this.escapePointerToken(
+              childKey
+            )}`
+          });
+        }
+      }
+    }
+    for (const key of arrayKeys) {
+      const value = schema[key];
+      if (!Array.isArray(value)) {
+        continue;
+      }
+      for (let index = 0; index < value.length; index++) {
+        const child = value[index];
+        if (child && typeof child === "object") {
+          children.push({
+            value: child,
+            pointer: `/${this.escapePointerToken(key)}/${index}`
+          });
+        }
+      }
+    }
+    for (const key of singleKeys) {
+      const value = schema[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        children.push({
+          value,
+          pointer: `/${this.escapePointerToken(key)}`
+        });
+      }
+    }
+    for (const key of Object.keys(schema)) {
+      if (key === "enum" || key === "const" || key === "default" || key === "examples" || mapKeys.includes(key) || arrayKeys.includes(key) || singleKeys.includes(key)) {
+        continue;
+      }
+      const keyword = this.getKeyword(key);
+      const value = schema[key];
+      if (keyword && keyword !== keywords[key] && value && typeof value === "object") {
+        children.push({
+          value,
+          pointer: `/${this.escapePointerToken(key)}`
+        });
+      }
+    }
+    return children;
+  }
+  schemaChildren(schema) {
+    return this.schemaChildEntries(schema).map((entry) => entry.value);
+  }
+  registrySubschemaEntries(schema) {
+    const children = [];
+    const mapKeys = ["properties", "patternProperties", "definitions"];
+    const arrayKeys = ["allOf", "anyOf", "oneOf", "items"];
+    const singleKeys = [
+      "items",
+      "additionalItems",
+      "additionalProperties",
+      "contains",
+      "propertyNames",
+      "not",
+      "if",
+      "then",
+      "else"
+    ];
+    for (const key of mapKeys) {
+      const value = schema[key];
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        continue;
+      }
+      for (const childKey of Object.keys(value)) {
+        const child = value[childKey];
+        if (child && typeof child === "object" && !Array.isArray(child)) {
+          children.push({
+            value: child,
+            pointer: `/${this.escapePointerToken(key)}/${this.escapePointerToken(
+              childKey
+            )}`
+          });
+        }
+      }
+    }
+    const dependencies = schema.dependencies;
+    if (dependencies && typeof dependencies === "object" && !Array.isArray(dependencies)) {
+      for (const dependencyKey of Object.keys(dependencies)) {
+        const child = dependencies[dependencyKey];
+        if (child && typeof child === "object" && !Array.isArray(child)) {
+          children.push({
+            value: child,
+            pointer: `/dependencies/${this.escapePointerToken(dependencyKey)}`
+          });
+        }
+      }
+    }
+    for (const key of arrayKeys) {
+      const value = schema[key];
+      if (!Array.isArray(value)) {
+        continue;
+      }
+      for (let index = 0; index < value.length; index++) {
+        const child = value[index];
+        if (child && typeof child === "object" && !Array.isArray(child)) {
+          children.push({
+            value: child,
+            pointer: `/${this.escapePointerToken(key)}/${index}`
+          });
+        }
+      }
+    }
+    for (const key of singleKeys) {
+      const value = schema[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        children.push({
+          value,
+          pointer: `/${this.escapePointerToken(key)}`
+        });
+      }
+    }
+    return children;
+  }
+  escapePointerToken(value) {
+    return value.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  resolveUri(reference, baseUri, keyword) {
+    try {
+      return new URL(reference, baseUri).href;
+    } catch {
+      const error = new ValidationError(`Invalid ${keyword} URI: ${reference}`);
+      error.code = keyword === "$id" ? "INVALID_SCHEMA_ID" : "REFERENCE_NOT_FOUND";
+      error.keyword = keyword;
+      throw error;
+    }
+  }
+  resourceUri(uri) {
+    const hashIndex = uri.indexOf("#");
+    return hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+  }
+  buildReferenceRegistry(schema) {
+    const aliases = /* @__PURE__ */ new Map();
+    const positions = [];
+    const positionsByNode = /* @__PURE__ */ new WeakMap();
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+      return Object.freeze({
+        aliases,
+        positions: Object.freeze(positions),
+        positionsByNode
+      });
+    }
+    const register = (uri, node) => {
+      const existing = aliases.get(uri);
+      if (existing && existing !== node) {
+        const error = new ValidationError(`Duplicate schema identity: ${uri}`);
+        error.code = "DUPLICATE_SCHEMA_ID";
+        error.keyword = "$id";
+        throw error;
+      }
+      aliases.set(uri, node);
+    };
+    register(LOCAL_SCHEMA_BASE, schema);
+    const visited = /* @__PURE__ */ new WeakSet();
+    const stack = [
+      {
+        node: schema,
+        inheritedBase: LOCAL_SCHEMA_BASE,
+        resourceRoot: schema,
+        pointer: "#"
+      }
+    ];
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (visited.has(entry.node)) {
+        continue;
+      }
+      visited.add(entry.node);
+      let baseUri = entry.inheritedBase;
+      let resourceRoot = entry.resourceRoot;
+      if (typeof entry.node.$id === "string" && !("$ref" in entry.node)) {
+        baseUri = this.resolveUri(entry.node.$id, entry.inheritedBase, "$id");
+        register(baseUri, entry.node);
+        if (baseUri.indexOf("#") === -1 || baseUri.endsWith("#")) {
+          resourceRoot = entry.node;
+          register(this.resourceUri(baseUri), entry.node);
+        }
+      }
+      const position = {
+        source: entry.node,
+        baseUri,
+        resourceRoot,
+        pointer: entry.pointer
+      };
+      positions.push(position);
+      positionsByNode.set(entry.node, position);
+      const children = this.registrySubschemaEntries(entry.node);
+      for (let index = children.length - 1; index >= 0; index--) {
+        const child = children[index];
+        if (Array.isArray(child.value)) {
+          continue;
+        }
+        stack.push({
+          node: child.value,
+          inheritedBase: baseUri,
+          resourceRoot,
+          pointer: `${entry.pointer}${child.pointer}`
+        });
+      }
+    }
+    return Object.freeze({
+      aliases,
+      positions: Object.freeze(positions),
+      positionsByNode
+    });
+  }
+  resolveReferenceSource(ref, position, registry) {
+    const resolvedUri = this.resolveUri(ref, position.baseUri, "$ref");
+    const exactTarget = registry.aliases.get(resolvedUri);
+    if (exactTarget) {
+      return exactTarget;
+    }
+    const resourceRoot = registry.aliases.get(this.resourceUri(resolvedUri));
+    if (!resourceRoot) {
+      return;
+    }
+    const hashIndex = resolvedUri.indexOf("#");
+    const fragment = hashIndex === -1 ? "" : resolvedUri.slice(hashIndex + 1);
+    if (fragment.length === 0) {
+      return resourceRoot;
+    }
+    if (fragment.startsWith("/")) {
+      return resolvePath(resourceRoot, `#${fragment}`);
+    }
+    return;
+  }
+  analyzeSchema(schema, registry) {
+    if (!schema || typeof schema !== "object") {
+      return {
+        requiresDepthGuard: false,
+        requiresMutationJournal: false,
+        mutableSchemas: /* @__PURE__ */ new WeakSet()
+      };
+    }
+    const visiting = /* @__PURE__ */ new WeakSet();
+    const visited = /* @__PURE__ */ new WeakSet();
+    const stack = [{ value: schema, depth: 0, exit: false }];
+    let requiresDepthGuard = false;
+    let requiresMutationJournal = false;
+    while (stack.length > 0) {
+      const entry = stack.pop();
+      if (entry.exit) {
+        visiting.delete(entry.value);
+        visited.add(entry.value);
+        continue;
+      }
+      if (visited.has(entry.value)) {
+        continue;
+      }
+      if (visiting.has(entry.value)) {
+        const error = new ValidationError("Cyclic schema graph is not supported");
+        error.code = "CYCLIC_SCHEMA_GRAPH";
+        error.keyword = "compile";
+        throw error;
+      }
+      if (entry.depth > MAX_COMPILE_DEPTH) {
+        const error = new ValidationError("Maximum compile depth exceeded");
+        error.code = "MAX_COMPILE_DEPTH_EXCEEDED";
+        error.keyword = "compile";
+        throw error;
+      }
+      if (entry.depth > this.maxDepth) {
+        requiresDepthGuard = true;
+      }
+      visiting.add(entry.value);
+      stack.push({ ...entry, exit: true });
+      if (this.useDefaults !== false && this.hasPropertyDefaults(entry.value)) {
+        requiresMutationJournal = true;
+      }
+      for (const key of Object.keys(entry.value)) {
+        const keyword = this.getKeyword(key);
+        if (keyword && keyword !== keywords[key]) {
+          requiresDepthGuard = true;
+          requiresMutationJournal = true;
+        }
+      }
+      const children = this.schemaChildren(entry.value);
+      for (let index = children.length - 1; index >= 0; index--) {
+        stack.push({
+          value: children[index],
+          depth: entry.depth + 1,
+          exit: false
+        });
+      }
+    }
+    const semanticState = /* @__PURE__ */ new WeakMap();
+    const semanticStack = [{ value: schema, exit: false }];
+    while (semanticStack.length > 0 && !requiresDepthGuard) {
+      const entry = semanticStack.pop();
+      if (entry.exit) {
+        semanticState.set(entry.value, 2);
+        continue;
+      }
+      const state = semanticState.get(entry.value);
+      if (state === 1) {
+        requiresDepthGuard = true;
+        break;
+      }
+      if (state === 2) {
+        continue;
+      }
+      semanticState.set(entry.value, 1);
+      semanticStack.push({ value: entry.value, exit: true });
+      const children = this.schemaChildren(entry.value);
+      if (typeof entry.value.$ref === "string" && this.getKeyword("$ref") === keywords.$ref) {
+        const position = registry.positionsByNode.get(entry.value);
+        const target = position ? this.resolveReferenceSource(entry.value.$ref, position, registry) : void 0;
+        if (target && typeof target === "object") {
+          children.push(target);
+        }
+      }
+      for (let index = children.length - 1; index >= 0; index--) {
+        semanticStack.push({
+          value: children[index],
+          exit: false
+        });
+      }
+    }
+    const mutableSchemas = /* @__PURE__ */ new WeakSet();
+    if (requiresMutationJournal) {
+      const mutationStack = [{ value: schema, exit: false }];
+      const mutationVisited = /* @__PURE__ */ new WeakSet();
+      while (mutationStack.length > 0) {
+        const entry = mutationStack.pop();
+        if (entry.exit) {
+          const children2 = this.schemaChildren(entry.value);
+          const hasCustomKeyword = Object.keys(entry.value).some((key) => {
+            const keyword = this.getKeyword(key);
+            return !!keyword && keyword !== keywords[key];
+          });
+          if (this.useDefaults !== false && this.hasPropertyDefaults(entry.value) || hasCustomKeyword || typeof entry.value.$ref === "string" || children2.some((child) => mutableSchemas.has(child))) {
+            mutableSchemas.add(entry.value);
+          }
+          continue;
+        }
+        if (mutationVisited.has(entry.value)) {
+          continue;
+        }
+        mutationVisited.add(entry.value);
+        mutationStack.push({ value: entry.value, exit: true });
+        const children = this.schemaChildren(entry.value);
+        for (let index = children.length - 1; index >= 0; index--) {
+          mutationStack.push({
+            value: children[index],
+            exit: false
+          });
+        }
+      }
+    }
+    return { requiresDepthGuard, requiresMutationJournal, mutableSchemas };
   }
   compile(schema) {
-    this.idRegistry.clear();
+    const prepared = this.prepareSchema(schema);
+    const compiledSchema = prepared.compiledSchema;
+    if (!prepared.requiresDepthGuard && !prepared.requiresMutationJournal) {
+      const directValidate = compiledSchema.$validate;
+      const validate = this.immutable ? (data) => {
+        const clonedData = deepCloneUnfreeze(data);
+        const error = directValidate(clonedData);
+        return error ? { data: clonedData, error, valid: false } : { data: clonedData, error: null, valid: true };
+      } : (data) => {
+        const error = directValidate(data);
+        return error ? { data, error, valid: false } : { data, error: null, valid: true };
+      };
+      validate.compiledSchema = compiledSchema;
+      return validate;
+    }
+    return this.createGuardedValidator(compiledSchema, prepared.depthGuardState);
+  }
+  prepareSchema(schema) {
+    const referenceRegistry = this.buildReferenceRegistry(schema);
+    const analysis = this.analyzeSchema(schema, referenceRegistry);
+    this.compileCache = /* @__PURE__ */ new WeakMap();
+    this.compilingRequiresContext = analysis.requiresDepthGuard || analysis.requiresMutationJournal;
+    this.compilingMutableSchemas = analysis.mutableSchemas;
     const compiledSchema = this.compileSchema(schema);
     this.rootSchema = compiledSchema;
+    let depthGuardState = null;
+    if (analysis.requiresDepthGuard) {
+      depthGuardState = this.installDepthGuards(compiledSchema);
+      definePropertyOrThrow(compiledSchema, "_requiresDepthGuard", {
+        value: true,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    } else if (analysis.requiresMutationJournal) {
+      depthGuardState = { context: null };
+    }
     if (compiledSchema._hasRef === true) {
-      this.linkReferences(compiledSchema);
+      this.linkReferences(referenceRegistry);
     }
     if (!compiledSchema.$validate) {
       if (schema === false) {
@@ -2082,14 +2719,53 @@ var SchemaShield = class {
         );
       }
     }
+    return {
+      compiledSchema,
+      requiresDepthGuard: analysis.requiresDepthGuard,
+      requiresMutationJournal: analysis.requiresMutationJournal,
+      depthGuardState
+    };
+  }
+  createGuardedValidator(compiledSchema, depthGuardState) {
+    const reusableContext = {
+      active: false,
+      depth: -1,
+      depthExceeded: false,
+      defaults: []
+    };
     const validate = (data) => {
       this.rootSchema = compiledSchema;
-      const clonedData = this.immutable ? deepCloneUnfreeze(data) : data;
-      const res = compiledSchema.$validate(clonedData);
-      if (res) {
-        return { data: clonedData, error: res, valid: false };
+      const context = reusableContext.active ? {
+        active: false,
+        depth: -1,
+        depthExceeded: false,
+        defaults: []
+      } : reusableContext;
+      context.active = true;
+      context.depth = -1;
+      context.depthExceeded = false;
+      delete context.depthError;
+      context.defaults.length = 0;
+      this.validationContexts.push(context);
+      const priorContext = depthGuardState.context;
+      depthGuardState.context = context;
+      let clonedData = data;
+      try {
+        clonedData = this.immutable ? deepCloneUnfreeze(data) : data;
+        let error = compiledSchema.$validate(clonedData);
+        if (this.isDepthError(error)) {
+          this.rollbackDefaults(context, 0);
+          error = context.depthError || this.depthError();
+        }
+        return error ? { data: clonedData, error, valid: false } : { data: clonedData, error: null, valid: true };
+      } catch (error) {
+        this.rollbackDefaults(context, 0);
+        throw error;
+      } finally {
+        depthGuardState.context = priorContext;
+        this.validationContexts.pop();
+        context.active = false;
       }
-      return { data: clonedData, error: null, valid: true };
     };
     validate.compiledSchema = compiledSchema;
     return validate;
@@ -2192,7 +2868,7 @@ var SchemaShield = class {
     if (schema._hasRef === true) {
       return;
     }
-    Object.defineProperty(schema, "_hasRef", {
+    definePropertyOrThrow(schema, "_hasRef", {
       value: true,
       enumerable: false,
       configurable: false,
@@ -2250,15 +2926,15 @@ var SchemaShield = class {
         return false;
     }
   }
-  hasRequiredDefaults(schema) {
+  hasPropertyDefaults(schema) {
     const properties = schema.properties;
     if (!this.isPlainObject(properties)) {
       return false;
     }
-    const keys = Object.keys(properties);
-    for (let i = 0; i < keys.length; i++) {
-      const subSchema = properties[keys[i]];
-      if (this.isPlainObject(subSchema) && "default" in subSchema) {
+    const propertyKeys = Object.keys(properties);
+    for (let i = 0; i < propertyKeys.length; i++) {
+      const subSchema = properties[propertyKeys[i]];
+      if (this.isPlainObject(subSchema) && hasOwn(subSchema, "default")) {
         return true;
       }
     }
@@ -2267,24 +2943,134 @@ var SchemaShield = class {
   isDefaultTypeValidator(type, validator) {
     return Types[type] === validator;
   }
-  compileSchema(schema) {
-    if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-      if (schema === true) {
-        schema = { anyOf: [{}] };
-      } else if (schema === false) {
-        schema = { oneOf: [] };
+  rollbackDefaults(context, start) {
+    for (let index = context.defaults.length - 1; index >= start; index--) {
+      const entry = context.defaults[index];
+      if (entry.descriptor) {
+        definePropertyOrThrow(entry.target, entry.key, entry.descriptor);
       } else {
-        schema = { oneOf: [schema] };
+        delete entry.target[entry.key];
+      }
+    }
+    context.defaults.length = start;
+  }
+  isDepthError(error) {
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    if (context?.depthExceeded) {
+      return true;
+    }
+    if (!(error instanceof ValidationError)) {
+      return false;
+    }
+    return error.getCause().code === "MAX_DEPTH_EXCEEDED";
+  }
+  validateSubschema(schema, data) {
+    if (!schema || typeof schema.$validate !== "function") {
+      return;
+    }
+    const context = this.validationContexts[this.validationContexts.length - 1];
+    const savepoint = context?.defaults.length || 0;
+    try {
+      const error = schema.$validate(data);
+      if (error && context) {
+        this.rollbackDefaults(context, savepoint);
+      }
+      return error;
+    } catch (error) {
+      if (context) {
+        this.rollbackDefaults(context, savepoint);
+      }
+      throw error;
+    }
+  }
+  installDepthGuards(root) {
+    const state = { context: null };
+    const stack = [root];
+    const seen = /* @__PURE__ */ new WeakSet();
+    while (stack.length > 0) {
+      const schema = stack.pop();
+      if (!schema || typeof schema !== "object" || seen.has(schema)) {
+        continue;
+      }
+      seen.add(schema);
+      if (typeof schema.$validate === "function") {
+        const directValidate = schema.$validate;
+        schema.$validate = getNamedFunction(directValidate.name, (data) => {
+          const context = state.context;
+          if (!context) {
+            return directValidate(data);
+          }
+          const nextDepth = context.depth + 1;
+          if (nextDepth > this.maxDepth) {
+            context.depthExceeded = true;
+            if (!context.depthError) {
+              context.depthError = this.depthError();
+            }
+            return context.depthError;
+          }
+          context.depth = nextDepth;
+          try {
+            return directValidate(data);
+          } finally {
+            context.depth--;
+          }
+        });
+      }
+      const children = this.schemaChildren(schema);
+      for (const child of children) {
+        stack.push(child);
       }
     }
+    return state;
+  }
+  compileSchema(schema) {
+    if (schema === true) {
+      return {
+        $validate: getNamedFunction("Validate_True", () => {
+        })
+      };
+    }
+    if (schema === false) {
+      const compiledFalse = {};
+      const defineError = getDefinedErrorFunctionForKey(
+        "oneOf",
+        compiledFalse,
+        this.failFast
+      );
+      compiledFalse.$validate = getNamedFunction(
+        "Validate_False",
+        (data) => defineError("Value is not valid", { data })
+      );
+      return compiledFalse;
+    }
+    const sourceSchema = schema && typeof schema === "object" && !Array.isArray(schema) ? schema : null;
+    const schemaCanApplyDefaults = sourceSchema !== null && this.compilingMutableSchemas.has(sourceSchema);
+    if (sourceSchema) {
+      const cached = this.compileCache.get(sourceSchema);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+      schema = { oneOf: [schema] };
+    }
     schema = this.normalizeSchemaForCompile(schema);
     const compiledSchema = deepCloneUnfreeze(
       schema
     );
-    let schemaHasRef = false;
-    if (typeof schema.$id === "string") {
-      this.idRegistry.set(schema.$id, compiledSchema);
+    if (sourceSchema) {
+      this.compileCache.set(sourceSchema, compiledSchema);
     }
+    if (schemaCanApplyDefaults) {
+      definePropertyOrThrow(compiledSchema, "_canApplyDefaults", {
+        value: true,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+    const validateSubschema = this.compilingRequiresContext ? this.validateSubschema.bind(this) : void 0;
+    let schemaHasRef = false;
     if ("$ref" in schema) {
       schemaHasRef = true;
       const refValidator = this.getKeyword("$ref");
@@ -2294,21 +3080,53 @@ var SchemaShield = class {
           schema["$ref"],
           this.failFast
         );
+        const isBuiltinRef = refValidator === keywords.$ref;
         compiledSchema.$validate = getNamedFunction(
-          "Validate_Reference",
+          isBuiltinRef ? "Validate_Reference" : refValidator.name || "$ref",
           (data) => refValidator(
             compiledSchema,
             data,
             defineError,
-            this
+            this,
+            validateSubschema
           )
         );
+        if (!isBuiltinRef) {
+          schemaHasRef = false;
+        }
+      }
+      for (const key of ["definitions", "$defs"]) {
+        const definitions = schema[key];
+        if (!definitions || typeof definitions !== "object") {
+          continue;
+        }
+        const compiledDefinitions = {};
+        for (const definitionKey of Object.keys(definitions)) {
+          compiledDefinitions[definitionKey] = this.compileSchema(
+            definitions[definitionKey]
+          );
+        }
+        compiledSchema[key] = compiledDefinitions;
+      }
+      if (schemaHasRef) {
+        this.markSchemaHasRef(compiledSchema);
       }
-      this.markSchemaHasRef(compiledSchema);
       return compiledSchema;
     }
     const validators = [];
     const activeNames = [];
+    const pendingCombinators = [];
+    if (this.useDefaults !== false && this.getKeyword("properties") === keywords.properties && this.hasPropertyDefaults(schema)) {
+      const applyDefaults = this.useDefaults === "empty" ? applyEmptyPropertyDefaults : applyPropertyDefaults;
+      validators.push({
+        name: applyDefaults.name,
+        validate: getNamedFunction(
+          applyDefaults.name,
+          (data) => applyDefaults(compiledSchema, data, this)
+        )
+      });
+      activeNames.push(applyDefaults.name);
+    }
     if ("type" in schema) {
       const defineTypeError = getDefinedErrorFunctionForKey(
         "type",
@@ -2344,65 +3162,11 @@ var SchemaShield = class {
       if (typeFunctions.length === 1 && allTypesDefault) {
         const singleTypeName = defaultTypeNames[0];
         typeMethodName = singleTypeName;
-        switch (singleTypeName) {
-          case "object":
-            combinedTypeValidator = (data) => {
-              if (data === null || typeof data !== "object" || Array.isArray(data)) {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "array":
-            combinedTypeValidator = (data) => {
-              if (!Array.isArray(data)) {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "string":
-            combinedTypeValidator = (data) => {
-              if (typeof data !== "string") {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "number":
-            combinedTypeValidator = (data) => {
-              if (typeof data !== "number") {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "integer":
-            combinedTypeValidator = (data) => {
-              if (typeof data !== "number" || !Number.isInteger(data)) {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "boolean":
-            combinedTypeValidator = (data) => {
-              if (typeof data !== "boolean") {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          case "null":
-            combinedTypeValidator = (data) => {
-              if (data !== null) {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-            break;
-          default: {
-            const singleTypeFn = typeFunctions[0];
-            combinedTypeValidator = (data) => {
-              if (!singleTypeFn(data)) {
-                return defineTypeError("Invalid type", { data });
-              }
-            };
-          }
-        }
+        combinedTypeValidator = this.failFast && FAIL_FAST_TYPE_VALIDATORS[singleTypeName] ? FAIL_FAST_TYPE_VALIDATORS[singleTypeName] : createBuiltinTypeValidator(
+          singleTypeName,
+          defineTypeError,
+          typeFunctions[0]
+        );
       } else if (typeFunctions.length > 1 && allTypesDefault) {
         typeMethodName = defaultTypeNames.join("_OR_");
         const allowsObject = defaultTypeNames.includes("object");
@@ -2415,6 +3179,9 @@ var SchemaShield = class {
         combinedTypeValidator = (data) => {
           const dataType = typeof data;
           if (dataType === "number") {
+            if (!Number.isFinite(data)) {
+              return defineTypeError("Invalid type", { data });
+            }
             if (allowsNumber || allowsInteger && Number.isInteger(data)) {
               return;
             }
@@ -2478,7 +3245,8 @@ var SchemaShield = class {
       activeNames.push(typeMethodName);
     }
     const { type, $id, $ref, $validate, required, ...otherKeys } = schema;
-    const keyOrder = required ? this.hasRequiredDefaults(schema) ? [...Object.keys(otherKeys), "required"] : ["required", ...Object.keys(otherKeys)] : Object.keys(otherKeys);
+    const otherKeyNames = Object.keys(otherKeys);
+    const keyOrder = required ? ["required", ...otherKeyNames] : otherKeyNames;
     for (const key of keyOrder) {
       const keywordFn = this.getKeyword(key);
       if (!keywordFn) {
@@ -2493,12 +3261,33 @@ var SchemaShield = class {
         this.failFast
       );
       const fnName = keywordFn.name || key;
+      if ((key === "allOf" || key === "anyOf" || key === "oneOf") && keywordFn === keywords[key]) {
+        const item = {
+          name: fnName,
+          validate: () => {
+            throw new ValidationError("Combinator validator was not prepared");
+          }
+        };
+        validators.push(item);
+        pendingCombinators.push({ item, key, defineError });
+        activeNames.push(fnName);
+        continue;
+      }
+      const keywordValidate = validateSubschema ? (data) => keywordFn(
+        compiledSchema,
+        data,
+        defineError,
+        this,
+        validateSubschema
+      ) : (data) => keywordFn(
+        compiledSchema,
+        data,
+        defineError,
+        this
+      );
       validators.push({
         name: fnName,
-        validate: getNamedFunction(
-          fnName,
-          (data) => keywordFn(compiledSchema, data, defineError, this)
-        )
+        validate: getNamedFunction(fnName, keywordValidate)
       });
       activeNames.push(fnName);
     }
@@ -2540,6 +3329,50 @@ var SchemaShield = class {
         continue;
       }
     }
+    if (this.isPlainObject(schema.properties)) {
+      definePropertyOrThrow(compiledSchema, "_propKeys", {
+        value: Object.keys(schema.properties),
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+    if (this.useDefaults !== false && this.isPlainObject(schema.properties) && this.hasPropertyDefaults(schema)) {
+      const defaultKeys = Object.keys(schema.properties).filter(
+        (key) => {
+          const property = schema.properties[key];
+          return property && typeof property === "object" && !Array.isArray(property) && hasOwn(property, "default");
+        }
+      );
+      if (defaultKeys.length > 0) {
+        definePropertyOrThrow(compiledSchema, "_defaultKeys", {
+          value: defaultKeys,
+          enumerable: false,
+          configurable: false,
+          writable: false
+        });
+      }
+    }
+    prepareCombinatorEntries(compiledSchema);
+    for (let index = 0; index < pendingCombinators.length; index++) {
+      const pending = pendingCombinators[index];
+      const transactions = compiledSchema._canApplyDefaults === true ? {
+        savepoint: () => this.#defaultSavepoint(),
+        rollback: (savepoint) => this.#rollbackDefaultSavepoint(savepoint),
+        capture: (savepoint) => this.#captureDefaultSavepoint(savepoint),
+        restore: (mutations) => this.#restoreDefaults(mutations)
+      } : void 0;
+      pending.item.validate = getNamedFunction(
+        pending.item.name,
+        createCombinatorValidator(
+          pending.key,
+          compiledSchema,
+          pending.defineError,
+          validateSubschema,
+          transactions
+        )
+      );
+    }
     if (schemaHasRef) {
       this.markSchemaHasRef(compiledSchema);
     }
@@ -2581,54 +3414,80 @@ var SchemaShield = class {
     }
     return false;
   }
-  linkReferences(root) {
-    const stack = [root];
-    while (stack.length > 0) {
-      const node = stack.pop();
-      if (!node || typeof node !== "object")
+  getCompiledReferenceTarget(ref, position, registry) {
+    const resolvedUri = this.resolveUri(ref, position.baseUri, "$ref");
+    const exactTarget = registry.aliases.get(resolvedUri);
+    if (exactTarget) {
+      return this.compileCache.get(exactTarget);
+    }
+    const resourceRoot = registry.aliases.get(this.resourceUri(resolvedUri));
+    if (!resourceRoot) {
+      return;
+    }
+    const compiledResource = this.compileCache.get(resourceRoot);
+    if (!compiledResource) {
+      return;
+    }
+    const hashIndex = resolvedUri.indexOf("#");
+    const fragment = hashIndex === -1 ? "" : resolvedUri.slice(hashIndex + 1);
+    if (fragment.length === 0) {
+      return compiledResource;
+    }
+    if (fragment.startsWith("/")) {
+      return resolvePath(compiledResource, `#${fragment}`);
+    }
+    return;
+  }
+  linkReferences(registry) {
+    for (let index = 0; index < registry.positions.length; index++) {
+      const position = registry.positions[index];
+      if (typeof position.source.$ref !== "string" || this.getKeyword("$ref") !== keywords.$ref) {
         continue;
-      if (typeof node.$ref === "string" && typeof node.$validate === "function" && node.$validate.name === "Validate_Reference") {
-        const refPath = node.$ref;
-        let target = this.getSchemaRef(refPath);
-        if (typeof target === "undefined") {
-          target = this.getSchemaById(refPath);
-        }
-        if (typeof target === "boolean") {
-          if (target === true) {
-            node.$validate = getNamedFunction("Validate_Ref_True", () => {
-            });
-          } else {
-            const defineError = getDefinedErrorFunctionForKey(
-              "$ref",
-              node,
-              this.failFast
-            );
-            node.$validate = getNamedFunction(
-              "Validate_Ref_False",
-              (_data) => defineError("Value is not valid")
-            );
-          }
-          continue;
-        }
-        if (target && typeof target.$validate === "function") {
-          node.$validate = target.$validate;
-        }
       }
-      for (const key in node) {
-        const value = node[key];
-        if (!value)
-          continue;
-        if (Array.isArray(value)) {
-          for (let i = 0; i < value.length; i++) {
-            const v = value[i];
-            if (v && typeof v === "object") {
-              stack.push(v);
+      const node = this.compileCache.get(position.source);
+      const target = this.getCompiledReferenceTarget(
+        position.source.$ref,
+        position,
+        registry
+      );
+      if (!node || typeof target === "undefined") {
+        const error = new ValidationError(
+          `Reference not found: ${position.source.$ref}`
+        );
+        error.code = "REFERENCE_NOT_FOUND";
+        error.keyword = "$ref";
+        throw error;
+      }
+      let targetValidate;
+      if (target === true) {
+        targetValidate = getNamedFunction("Validate_Ref_True", () => {
+        });
+      } else if (target === false) {
+        const defineError = getDefinedErrorFunctionForKey(
+          "$ref",
+          node,
+          this.failFast
+        );
+        targetValidate = getNamedFunction(
+          "Validate_Ref_False",
+          (data) => defineError("Value is not valid", { data })
+        );
+      } else {
+        if (typeof target.$validate !== "function") {
+          target.$validate = getNamedFunction(
+            "Validate_Ref_Any",
+            () => {
             }
-          }
-        } else if (typeof value === "object") {
-          stack.push(value);
+          );
         }
+        targetValidate = target.$validate;
       }
+      definePropertyOrThrow(node, "_resolvedRef", {
+        value: targetValidate,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
     }
   }
 };