@schema-ts/core 0.1.4 → 0.1.5

package/dist/index.cjs

@@ -146,6 +146,10 @@ function setJsonPointer(obj, jsonPointer, value) {
   }
   return true;
 }
+function getJsonPointerParent(path) {
+  const lastSlash = path.lastIndexOf("/");
+  return lastSlash <= 0 ? "" : path.substring(0, lastSlash);
+}
 function get(obj, path) {
   let current = obj;
   for (const segment of path) {
@@ -465,6 +469,11 @@ function detectSchemaDraft(schema) {
 }
 
 // src/normalize.ts
+var DraftNormalizer = class {
+  normalize(schema) {
+    return normalizeSchema(schema);
+  }
+};
 function normalizeSchema(schema, options = {}) {
   if (typeof schema === "boolean") {
     return schema ? {} : { not: {} };
@@ -548,8 +557,6 @@ function normalizeDraft07(schema) {
     } else {
       delete legacy.items;
     }
-  } else if ("additionalItems" in legacy) {
-    delete legacy.additionalItems;
   }
   if ("dependencies" in legacy) {
     const deps = legacy.dependencies;
@@ -625,18 +632,16 @@ function normalizeNestedSchemas(schema, options) {
   }
   if (schema.properties) {
     schema.properties = Object.fromEntries(
-      Object.entries(schema.properties).map(([key, subSchema]) => [
-        key,
-        normalizeSchema(subSchema, options)
-      ])
+      Object.entries(schema.properties).filter(
+        ([_, subSchema]) => subSchema !== null && subSchema !== void 0
+      ).map(([key, subSchema]) => [key, normalizeSchema(subSchema, options)])
     );
   }
   if (schema.patternProperties) {
     schema.patternProperties = Object.fromEntries(
-      Object.entries(schema.patternProperties).map(([key, subSchema]) => [
-        key,
-        normalizeSchema(subSchema, options)
-      ])
+      Object.entries(schema.patternProperties).filter(
+        ([_, subSchema]) => subSchema !== null && subSchema !== void 0
+      ).map(([key, subSchema]) => [key, normalizeSchema(subSchema, options)])
     );
   }
   if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
@@ -679,10 +684,9 @@ function normalizeNestedSchemas(schema, options) {
   }
   if (schema.dependentSchemas) {
     schema.dependentSchemas = Object.fromEntries(
-      Object.entries(schema.dependentSchemas).map(([key, subSchema]) => [
-        key,
-        normalizeSchema(subSchema, options)
-      ])
+      Object.entries(schema.dependentSchemas).filter(
+        ([_, subSchema]) => subSchema !== null && subSchema !== void 0
+      ).map(([key, subSchema]) => [key, normalizeSchema(subSchema, options)])
     );
   }
   if (schema.unevaluatedItems) {
@@ -701,6 +705,120 @@ function normalizeNestedSchemas(schema, options) {
     schema.contentSchema = normalizeSchema(schema.contentSchema, options);
   }
 }
+var BetterNormalizer = class {
+  /**
+   * Performs the normalization process:
+   * 1. Base draft normalization (DraftNormalizer)
+   * 2. Enhanced default value completion (Better logic)
+   */
+  normalize(schema) {
+    const normalized = normalizeSchema(schema);
+    this.defaultSchema(normalized);
+    return normalized;
+  }
+  /**
+   * Recursively processes all sub-nodes of the schema, applying default rules.
+   */
+  default(schema, forceRequired = false) {
+    this.defaultSchema(schema.if, true);
+    this.defaultSchema(schema.then);
+    this.defaultSchema(schema.else);
+    schema.anyOf?.forEach((s) => this.defaultSchema(s));
+    schema.oneOf?.forEach((s) => this.defaultSchema(s));
+    schema.allOf?.forEach((s) => this.defaultSchema(s));
+    this.defaultSchemaMap(schema.properties, forceRequired);
+    this.defaultSchemaMap(schema.patternProperties, forceRequired);
+    this.defaultSchema(schema.additionalProperties, forceRequired);
+    this.defaultSchema(schema.propertyNames);
+    this.defaultSchemaMap(schema.dependentSchemas, true);
+    this.defaultSchema(schema.items);
+    schema.prefixItems?.forEach((s) => this.defaultSchema(s));
+    this.defaultSchema(schema.contains);
+    this.defaultSchema(schema.unevaluatedItems);
+    this.defaultSchema(schema.unevaluatedProperties);
+    this.defaultSchema(schema.contentSchema);
+    return schema;
+  }
+  /**
+   * Batch processes Record-type sub-schemas.
+   */
+  defaultSchemaMap(kvs, forceRequired = false) {
+    if (!kvs) {
+      return;
+    }
+    Object.entries(kvs).forEach(([_, value]) => {
+      this.defaultSchema(value, forceRequired);
+    });
+  }
+  /**
+   * Applies inference and heuristic rules to a single schema object.
+   * Includes:
+   * - `type` inference based on properties (object/array)
+   * - Automatically setting properties with `const`/`default`/`enum` as `required`
+   * - Handling `required` fields from OpenAPI `discriminator`
+   * - Handling `x-required` and `x-kubernetes-patch-merge-key`
+   */
+  defaultSchema(schema, forceRequired = false) {
+    if (!schema || typeof schema === "boolean") {
+      return;
+    }
+    if (!schema.type) {
+      if (schema.properties || schema.patternProperties || schema.additionalProperties) {
+        schema.type = "object";
+      } else if (schema.items || schema.prefixItems || schema.additionalItems) {
+        schema.type = "array";
+      }
+    }
+    if (schema.patternProperties && schema.minProperties === void 0) {
+      schema.minProperties = 1;
+    }
+    if (schema.required === void 0) {
+      const required = [];
+      for (const [key, value] of Object.entries(schema.properties || {})) {
+        if (forceRequired || value.const !== void 0 || Array.isArray(value.enum) && value.enum.length > 0) {
+          required.push(key);
+        }
+      }
+      if (required.length > 0) {
+        schema.required = required;
+      }
+    }
+    const discriminator = toObject(schema.discriminator);
+    if (discriminator.propertyName) {
+      if (typeof discriminator.propertyName === "string") {
+        if (schema.required === void 0) {
+          schema.required = [discriminator.propertyName];
+        } else if (!schema.required.includes(discriminator.propertyName)) {
+          schema.required.push(discriminator.propertyName);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(schema.properties || {})) {
+      if (value["x-required"] === true) {
+        if (schema.required === void 0) {
+          schema.required = [key];
+        } else if (!schema.required.includes(key)) {
+          schema.required.push(key);
+        }
+      }
+    }
+    const mergeKey = schema["x-kubernetes-patch-merge-key"];
+    if (typeof mergeKey === "string" && typeof schema.items === "object" && schema.items !== null) {
+      const items = schema.items;
+      if (!items.required) items.required = [];
+      if (!items.required.includes(mergeKey)) {
+        items.required.push(mergeKey);
+      }
+    }
+    this.default(schema, forceRequired);
+  }
+};
+function toObject(val) {
+  if (typeof val === "object" && val !== null) {
+    return val;
+  }
+  return {};
+}
 
 // src/validate.ts
 var Validator = class {
@@ -1334,14 +1452,15 @@ function validateSchema(schema, value, instancePath = "", schemaPath = "#", fast
 }
 
 // src/effective.ts
-function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation, isRequired = true) {
+function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation, validate = false) {
   let effective = schema;
   if (effective.if) {
     const output = validator.validate(
       effective.if,
       value,
       `${keywordLocation}/if`,
-      instanceLocation
+      instanceLocation,
+      { fastFail: true }
     );
     if (output.valid) {
       if (effective.then) {
@@ -1350,9 +1469,14 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
           effective.then,
           value,
           `${keywordLocation}/then`,
-          instanceLocation
+          instanceLocation,
+          validate
+        );
+        effective = mergeSchema(
+          effective,
+          res.effectiveSchema,
+          `${keywordLocation}/then`
         );
-        effective = mergeSchema(effective, res.effectiveSchema);
       }
     } else {
       if (effective.else) {
@@ -1361,9 +1485,14 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
           effective.else,
           value,
           `${keywordLocation}/else`,
-          instanceLocation
+          instanceLocation,
+          validate
+        );
+        effective = mergeSchema(
+          effective,
+          res.effectiveSchema,
+          `${keywordLocation}/else`
         );
-        effective = mergeSchema(effective, res.effectiveSchema);
       }
     }
     const { if: _, then: __, else: ___, ...rest } = effective;
@@ -1371,24 +1500,31 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
   }
   if (effective.allOf) {
     for (const [index, subschema] of effective.allOf.entries()) {
+      const subKeywordLocation = `${keywordLocation}/allOf/${index}`;
       const res = resolveEffectiveSchema(
         validator,
         subschema,
         value,
-        `${keywordLocation}/allOf/${index}`,
-        instanceLocation
+        subKeywordLocation,
+        instanceLocation,
+        validate
+      );
+      effective = mergeSchema(
+        effective,
+        res.effectiveSchema,
+        subKeywordLocation
       );
-      effective = mergeSchema(effective, res.effectiveSchema);
     }
     const { allOf: _, ...rest } = effective;
     effective = rest;
   }
   if (effective.anyOf) {
     for (const [index, subschema] of effective.anyOf.entries()) {
+      const subKeywordLocation = `${keywordLocation}/anyOf/${index}`;
       const output = validator.validate(
         subschema,
         value,
-        keywordLocation + `/anyOf/` + index,
+        subKeywordLocation,
         instanceLocation
       );
       if (output.valid) {
@@ -1396,10 +1532,15 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
           validator,
           subschema,
           value,
-          keywordLocation + `/anyOf/` + index,
-          instanceLocation
+          subKeywordLocation,
+          instanceLocation,
+          validate
+        );
+        effective = mergeSchema(
+          effective,
+          res.effectiveSchema,
+          subKeywordLocation
         );
-        effective = mergeSchema(effective, res.effectiveSchema);
       }
     }
     const { anyOf: _, ...rest } = effective;
@@ -1408,6 +1549,7 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
   if (effective.oneOf) {
     let validCount = 0;
     let lastValidSchema = null;
+    let lastValidIndex = -1;
     for (const [index, subschema] of effective.oneOf.entries()) {
       const output = validator.validate(
         subschema,
@@ -1418,10 +1560,15 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
       if (output.valid) {
         validCount++;
         lastValidSchema = subschema;
+        lastValidIndex = index;
       }
     }
     if (validCount === 1 && lastValidSchema) {
-      effective = mergeSchema(effective, lastValidSchema);
+      effective = mergeSchema(
+        effective,
+        lastValidSchema,
+        `${keywordLocation}/oneOf/${lastValidIndex}`
+      );
     }
     const { oneOf: _, ...rest } = effective;
     effective = rest;
@@ -1438,7 +1585,7 @@ function resolveEffectiveSchema(validator, schema, value, keywordLocation, insta
   } else {
     type = detectSchemaType(value);
   }
-  if (!isRequired && value === void 0) {
+  if (!validate) {
     return {
       effectiveSchema: effective,
       type,
@@ -1478,25 +1625,42 @@ function mergeSchemaArrays(a, b) {
   if (b === void 0) return a;
   return [...a, ...b];
 }
-function mergeSchemaMap(base, override) {
-  if (base === void 0) return override;
+function mergeSchemaMap(base, override, overrideOrigin) {
+  if (base === void 0) {
+    if (override === void 0) return void 0;
+    if (overrideOrigin) {
+      const result = {};
+      for (const [key, schema] of Object.entries(override)) {
+        result[key] = {
+          ...schema,
+          "x-origin-keyword": `${overrideOrigin}/${key}`
+        };
+      }
+      return result;
+    }
+    return override;
+  }
   if (override === void 0) return base;
   const merged = { ...base };
   for (const [key, schema] of Object.entries(override)) {
+    const childOrigin = overrideOrigin ? `${overrideOrigin}/${key}` : void 0;
     if (merged[key]) {
-      merged[key] = mergeSchema(merged[key], schema);
+      merged[key] = mergeSchema(merged[key], schema, childOrigin);
     } else {
-      merged[key] = schema;
+      merged[key] = childOrigin ? { ...schema, "x-origin-keyword": childOrigin } : schema;
     }
   }
   return merged;
 }
-function mergeSchema(base, override) {
+function mergeSchema(base, override, overrideOrigin) {
   if (!override) return base;
   const merged = {
     ...base,
     ...override
   };
+  if (overrideOrigin) {
+    merged["x-origin-keyword"] = overrideOrigin;
+  }
   if (base.$defs || override.$defs) {
     merged.$defs = {
       ...base.$defs,
@@ -1517,23 +1681,31 @@ function mergeSchema(base, override) {
       ...override.dependentRequired
     };
   }
-  const mergedProperties = mergeSchemaMap(base.properties, override.properties);
+  const propertiesOrigin = overrideOrigin ? `${overrideOrigin}/properties` : void 0;
+  const mergedProperties = mergeSchemaMap(
+    base.properties,
+    override.properties,
+    propertiesOrigin
+  );
   if (mergedProperties !== void 0) {
     merged.properties = mergedProperties;
   }
+  const patternPropertiesOrigin = overrideOrigin ? `${overrideOrigin}/patternProperties` : void 0;
   const mergedPatternProperties = mergeSchemaMap(
     base.patternProperties,
-    override.patternProperties
+    override.patternProperties,
+    patternPropertiesOrigin
   );
   if (mergedPatternProperties !== void 0) {
     merged.patternProperties = mergedPatternProperties;
   }
+  const itemsOrigin = overrideOrigin ? `${overrideOrigin}/items` : void 0;
   if (base.items && override.items) {
-    merged.items = mergeSchema(base.items, override.items);
+    merged.items = mergeSchema(base.items, override.items, itemsOrigin);
   } else if (base.items) {
     merged.items = base.items;
   } else if (override.items) {
-    merged.items = override.items;
+    merged.items = itemsOrigin ? { ...override.items, "x-origin-keyword": itemsOrigin } : override.items;
   }
   if (base.prefixItems || override.prefixItems) {
     merged.prefixItems = [];
@@ -1544,13 +1716,17 @@ function mergeSchema(base, override) {
     for (let i = 0; i < len; i++) {
       const baseSchema = base.prefixItems?.[i];
       const overrideSchema = override.prefixItems?.[i];
+      const prefixItemOrigin = overrideOrigin ? `${overrideOrigin}/prefixItems/${i}` : void 0;
       if (baseSchema && overrideSchema) {
-        merged.prefixItems.push(mergeSchema(baseSchema, overrideSchema));
-      } else {
-        const schema = baseSchema || overrideSchema;
-        if (schema) {
-          merged.prefixItems.push(schema);
-        }
+        merged.prefixItems.push(
+          mergeSchema(baseSchema, overrideSchema, prefixItemOrigin)
+        );
+      } else if (overrideSchema) {
+        merged.prefixItems.push(
+          prefixItemOrigin ? { ...overrideSchema, "x-origin-keyword": prefixItemOrigin } : overrideSchema
+        );
+      } else if (baseSchema) {
+        merged.prefixItems.push(baseSchema);
       }
     }
   }
@@ -1561,9 +1737,11 @@ function mergeSchema(base, override) {
       merged[keyword] = mergedArray;
     }
   }
+  const dependentSchemasOrigin = overrideOrigin ? `${overrideOrigin}/dependentSchemas` : void 0;
   const mergedDependentSchemas = mergeSchemaMap(
     base.dependentSchemas,
-    override.dependentSchemas
+    override.dependentSchemas,
+    dependentSchemasOrigin
   );
   if (mergedDependentSchemas !== void 0) {
     merged.dependentSchemas = mergedDependentSchemas;
@@ -1742,7 +1920,8 @@ function getSubSchema(schema, key) {
   if (schema.properties && schema.properties[key]) {
     return {
       schema: schema.properties[key],
-      keywordLocationToken: `properties/${key}`
+      keywordLocationToken: `properties/${key}`,
+      required: schema.required?.includes(key) || false
     };
   }
   if (schema.patternProperties) {
@@ -1752,7 +1931,8 @@ function getSubSchema(schema, key) {
       if (safeRegexTest(pattern, key)) {
         return {
           schema: subschema,
-          keywordLocationToken: `patternProperties/${pattern}`
+          keywordLocationToken: `patternProperties/${pattern}`,
+          required: false
         };
       }
     }
@@ -1760,7 +1940,8 @@ function getSubSchema(schema, key) {
   if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
     return {
       schema: typeof schema.additionalProperties === "object" ? schema.additionalProperties : {},
-      keywordLocationToken: "additionalProperties"
+      keywordLocationToken: "additionalProperties",
+      required: false
     };
   }
   if (schema.items || schema.prefixItems) {
@@ -1769,102 +1950,124 @@ function getSubSchema(schema, key) {
       if (schema.prefixItems && index < schema.prefixItems.length) {
         return {
           schema: schema.prefixItems[index],
-          keywordLocationToken: `prefixItems/${index}`
+          keywordLocationToken: `prefixItems/${index}`,
+          required: true
+          // prefixItems are always required
         };
       }
       if (schema.items) {
         return {
           schema: schema.items,
-          keywordLocationToken: "items"
+          keywordLocationToken: "items",
+          // items beyond prefixItems are not required by default
+          // but usually new item is considered required to hold the place
+          required: true
         };
       }
     }
   }
   return {
     schema: {},
-    keywordLocationToken: ""
+    keywordLocationToken: "",
+    required: false
   };
 }
 
 // src/default.ts
-function getDefaultValue(schema, options = {}) {
-  const { value, strategy = "explicit" } = options;
-  if (value === void 0) {
-    if (schema.const !== void 0) return schema.const;
-    if (schema.default !== void 0) return schema.default;
-  }
-  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-  if (type === "object" || !type && schema.properties) {
-    let obj;
-    if (value === void 0) {
-      if (strategy === "explicit") return void 0;
-      obj = {};
-    } else if (typeof value === "object" && value !== null) {
-      obj = value;
-    } else {
-      return value;
-    }
-    if (schema.properties) {
-      for (const [key, subschema] of Object.entries(schema.properties)) {
-        if (obj[key] !== void 0) {
-          obj[key] = getDefaultValue(subschema, { value: obj[key], strategy });
-        } else if (schema.required?.includes(key)) {
-          obj[key] = getDefaultValue(subschema, { strategy });
+function typeNullable(schema) {
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  const nullable = types.includes("null");
+  const type = types.find((t) => t !== "null");
+  return [type, nullable];
+}
+function getDefaultValue(schema, required = false) {
+  if (schema.const !== void 0) return schema.const;
+  if (schema.default !== void 0) return schema.default;
+  const [type, nullable] = typeNullable(schema);
+  switch (type) {
+    case "object": {
+      const obj = {};
+      for (const [key, subschema] of Object.entries(schema.properties || {})) {
+        if (schema.required?.includes(key)) {
+          obj[key] = getDefaultValue(subschema, true);
         }
       }
+      if (Object.keys(obj).length === 0) {
+        return required ? nullable ? null : {} : void 0;
+      }
+      return obj;
     }
-    return obj;
-  }
-  if (type === "array") {
-    let arr;
-    if (value === void 0) {
-      if (strategy === "explicit") return void 0;
-      arr = [];
-    } else if (Array.isArray(value)) {
-      arr = value;
-    } else {
-      return value;
-    }
-    if (schema.prefixItems) {
-      schema.prefixItems.forEach((subschema, index) => {
-        if (index < arr.length) {
-          arr[index] = getDefaultValue(subschema, {
-            value: arr[index],
-            strategy
-          });
-        } else if (value === void 0) {
-          arr.push(getDefaultValue(subschema, { strategy }));
-        }
+    case "array": {
+      const arr = [];
+      schema.prefixItems?.forEach((subschema) => {
+        arr.push(getDefaultValue(subschema, true));
       });
-    }
-    if (value !== void 0 && schema.items) {
-      const startIndex = schema.prefixItems ? schema.prefixItems.length : 0;
-      for (let i = startIndex; i < arr.length; i++) {
-        arr[i] = getDefaultValue(schema.items, { value: arr[i], strategy });
+      if (arr.length === 0) {
+        return required ? nullable ? null : [] : void 0;
       }
+      return arr;
     }
-    return arr;
-  }
-  if (value !== void 0) {
-    return value;
-  }
-  if (strategy === "explicit") {
-    return void 0;
-  }
-  switch (type) {
     case "string":
-      return "";
+      return required ? nullable ? null : "" : void 0;
     case "number":
+      return required ? nullable ? null : 0 : void 0;
     case "integer":
-      return 0;
+      return required ? nullable ? null : 0 : void 0;
     case "boolean":
-      return false;
+      return required ? nullable ? null : false : void 0;
     case "null":
       return null;
     default:
       return void 0;
   }
 }
+function applyDefaults(type, value, schema, required = false) {
+  if (value === void 0) {
+    if (!required) {
+      return [value, false];
+    }
+    const defaultValue = getDefaultValue(schema, required);
+    return [defaultValue, defaultValue !== void 0];
+  }
+  const [_, nullable] = typeNullable(schema);
+  if (nullable && value === null) {
+    return [null, false];
+  }
+  let changed = false;
+  if (type === "object") {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return [value, false];
+    }
+    const obj = value;
+    for (const [key, subschema] of Object.entries(schema.properties || {})) {
+      if (obj[key] !== void 0) continue;
+      if (schema.required?.includes(key) || subschema.default) {
+        const defaultValue = getDefaultValue(subschema, required);
+        if (defaultValue !== void 0) {
+          obj[key] = defaultValue;
+          changed = true;
+        }
+      }
+    }
+    return [obj, changed];
+  }
+  if (type === "array") {
+    if (!Array.isArray(value)) {
+      return [value, false];
+    }
+    const arr = value;
+    schema.prefixItems?.forEach((subschema, index) => {
+      if (arr[index] !== void 0) return;
+      const defaultValue = getDefaultValue(subschema, true);
+      if (defaultValue !== void 0) {
+        arr[index] = defaultValue;
+        changed = true;
+      }
+    });
+    return [arr, changed];
+  }
+  return [value, false];
+}
 
 // src/dependency.ts
 function collectDependencies(schema, instanceLocation) {
@@ -2026,12 +2229,8 @@ function extractReferencedPaths(conditionSchema, basePath = "", depth = 0) {
       }
     }
   }
-  if (schema.dependentSchemas) {
-    for (const [key, subSchema] of Object.entries(schema.dependentSchemas)) {
-      const keyPath = basePath ? `${basePath}/${key}` : `/${key}`;
-      paths.push(keyPath);
-      paths.push(...extractReferencedPaths(subSchema, basePath, depth + 1));
-    }
+  if (schema.not) {
+    paths.push(...extractReferencedPaths(schema.not, basePath, depth + 1));
   }
   if (schema.contains) {
     paths.push(basePath || "/");
@@ -2041,12 +2240,9 @@ function extractReferencedPaths(conditionSchema, basePath = "", depth = 0) {
 }
 
 // src/render.ts
-var ROOT_PATH = "";
-function normalizeRootPath(path) {
-  return path === "#" ? ROOT_PATH : path;
-}
 var SchemaRuntime = class {
   validator;
+  normalizer;
   watchers = {};
   globalWatchers = /* @__PURE__ */ new Set();
   // Reverse dependency index: path -> nodes that depend on this path's value
@@ -2073,17 +2269,30 @@ var SchemaRuntime = class {
    */
   constructor(validator, schema, value, options = {}) {
     this.validator = validator;
-    this.value = value;
     this.options = {
-      autoFillDefaults: "explicit",
+      fillDefaults: "auto",
       removeEmptyContainers: "auto",
       ...options
     };
-    const normalized = normalizeSchema(schema);
-    this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
+    this.normalizer = options.schemaNormalizer || new DraftNormalizer();
+    this.value = value;
+    this.rootSchema = this.resolveSchema(schema);
+    this.root = this.createEmptyNode("", "#");
+    this.buildNode(this.root, this.rootSchema);
+  }
+  resolveSchema(schema) {
+    const normalized = this.normalizer.normalize(schema);
+    const dereferenced = dereferenceSchemaDeep(normalized, normalized);
+    return dereferenced;
+  }
+  /**
+   * Update the entire schema.
+   * This triggers a full rebuild of the node tree while preserving the current value.
+   */
+  setSchema(schema) {
+    this.rootSchema = this.resolveSchema(schema);
     this.root = this.createEmptyNode("", "#");
     this.buildNode(this.root, this.rootSchema);
-    this.notify({ type: "schema", path: ROOT_PATH });
   }
   /**
    * Register a node as dependent on a path
@@ -2140,8 +2349,9 @@ var SchemaRuntime = class {
       originalSchema: {},
       canRemove: false,
       canAdd: false,
-      isRequired: false,
-      children: []
+      required: false,
+      children: [],
+      activated: false
     };
   }
   /**
@@ -2149,13 +2359,12 @@ var SchemaRuntime = class {
    * Uses findNearestExistingNode to find the target node (or parent if path doesn't exist).
    * Only rebuilds the affected subtree, not the entire tree.
    */
-  reconcile(path) {
-    const normalizedPath = normalizeRootPath(path);
-    const targetNode = this.findNearestExistingNode(normalizedPath);
+  reconcile(path, config = {}) {
+    const targetNode = this.findNearestExistingNode(path);
     if (!targetNode) {
       return;
     }
-    this.buildNode(targetNode, targetNode.originalSchema);
+    this.buildNode(targetNode, targetNode.originalSchema, config);
   }
   /**
    * Get the current version number.
@@ -2182,17 +2391,16 @@ var SchemaRuntime = class {
    * // Later: unsubscribe();
    */
   subscribe(path, cb) {
-    const normalizedPath = normalizeRootPath(path);
-    if (!this.watchers[normalizedPath]) {
-      this.watchers[normalizedPath] = /* @__PURE__ */ new Set();
+    if (!this.watchers[path]) {
+      this.watchers[path] = /* @__PURE__ */ new Set();
     }
-    this.watchers[normalizedPath].add(cb);
+    this.watchers[path].add(cb);
     return () => {
-      const watcherSet = this.watchers[normalizedPath];
+      const watcherSet = this.watchers[path];
       if (watcherSet) {
         watcherSet.delete(cb);
         if (watcherSet.size === 0) {
-          delete this.watchers[normalizedPath];
+          delete this.watchers[path];
         }
       }
     };
@@ -2218,8 +2426,7 @@ var SchemaRuntime = class {
    */
   notify(event) {
     this.version++;
-    const normalizedPath = normalizeRootPath(event.path);
-    const watchers = this.watchers[normalizedPath];
+    const watchers = this.watchers[event.path];
     if (watchers) {
       for (const cb of watchers) {
         try {
@@ -2237,17 +2444,6 @@ var SchemaRuntime = class {
       }
     }
   }
-  /**
-   * Update the entire schema.
-   * This triggers a full rebuild of the node tree while preserving the current value.
-   */
-  setSchema(schema) {
-    const normalized = normalizeSchema(schema);
-    this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
-    this.root = this.createEmptyNode("", "#");
-    this.buildNode(this.root, this.rootSchema);
-    this.notify({ type: "schema", path: ROOT_PATH });
-  }
   /**
    * Get the value at a specific path.
    *
@@ -2259,24 +2455,28 @@ var SchemaRuntime = class {
    * runtime.getValue("/name"); // returns value at /name
    */
   getValue(path) {
-    const normalizedPath = normalizeRootPath(path);
-    if (normalizedPath === ROOT_PATH) return this.value;
-    return getJsonPointer(this.value, normalizedPath);
+    if (path === "" || path === "#") {
+      return this.value;
+    }
+    return getJsonPointer(this.value, path);
   }
   /**
    * Internal helper to set a value at a normalized path.
    * Handles both root and non-root paths.
    *
-   * @param normalizedPath - The normalized JSON Pointer path
+   * @param path - The JSON Pointer path
    * @param value - The value to set
    * @returns true if successful, false if the path cannot be set
    */
-  setValueAtPath(normalizedPath, value) {
-    if (normalizedPath === ROOT_PATH) {
+  setJsonPointer(path, value) {
+    if (path === "" || path === "#") {
       this.value = value;
       return true;
     }
-    return setJsonPointer(this.value, normalizedPath, value);
+    if (!this.value) {
+      this.value = {};
+    }
+    return setJsonPointer(this.value, path, value);
   }
   /**
    * Internal method to remove a value at a path.
@@ -2290,9 +2490,9 @@ var SchemaRuntime = class {
     if (!success) {
       return false;
     }
-    const lastSlash = path.lastIndexOf("/");
-    const parentPath = lastSlash <= 0 ? ROOT_PATH : path.substring(0, lastSlash);
-    const reconcilePath = this.cleanupEmptyContainers(parentPath);
+    const reconcilePath = this.cleanupEmptyContainers(
+      getJsonPointerParent(path)
+    );
     this.reconcile(reconcilePath);
     this.notify({ type: "value", path: reconcilePath });
     return true;
@@ -2305,37 +2505,29 @@ var SchemaRuntime = class {
    * @returns true if successful, false if the path cannot be removed
    */
   removeValue(path) {
-    const normalizedPath = normalizeRootPath(path);
-    if (normalizedPath === ROOT_PATH) {
-      return false;
-    }
-    const node = this.findNode(normalizedPath);
-    if (!node || !node.canRemove) {
-      return false;
-    }
-    return this.removeValueInternal(normalizedPath);
+    return this.removeValueInternal(path);
   }
   /**
    * Clean up empty parent containers after element removal.
    * Recursively removes empty arrays/objects based on removeEmptyContainers option.
    * @param path - The path to check for empty container
-   * @returns The topmost parent path for reconciliation
+   * @returns The topmost parent path changed
    */
   cleanupEmptyContainers(path) {
     const strategy = this.options.removeEmptyContainers;
-    if (strategy === "never" || path === ROOT_PATH) {
-      return path;
+    if (strategy === "never") {
+      return "";
     }
-    const node = this.findNode(path);
+    const node = this.getNode(path);
     if (!node) {
       return path;
     }
     const value = this.getValue(path);
-    const isEmpty = Array.isArray(value) && value.length === 0 || value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+    const isEmpty = value === null || typeof value === "object" && Object.keys(value).length === 0;
     if (!isEmpty) {
       return path;
     }
-    const shouldRemove = strategy === "always" || strategy === "auto" && !node.isRequired;
+    const shouldRemove = strategy === "auto" && !node.required;
     if (!shouldRemove) {
       return path;
     }
@@ -2343,24 +2535,70 @@ var SchemaRuntime = class {
     if (!success) {
       return path;
     }
-    const lastSlash = path.lastIndexOf("/");
-    const parentPath = lastSlash <= 0 ? ROOT_PATH : path.substring(0, lastSlash);
-    return this.cleanupEmptyContainers(parentPath);
+    return this.cleanupEmptyContainers(getJsonPointerParent(path));
   }
   /**
    * Get default value for a schema, respecting autoFillDefaults option.
    * Falls back to 'always' strategy if configured strategy returns undefined.
+   * If still undefined (e.g., schema has no type), falls back to null as a valid JSON value.
    */
-  getDefaultValueForAdd(schema) {
-    const strategy = this.options.autoFillDefaults;
-    let defaultValue;
-    if (strategy && strategy !== "never") {
-      defaultValue = getDefaultValue(schema, { strategy });
+  newDefaultValue(schema, required) {
+    const strategy = this.options.fillDefaults;
+    if (strategy === "never") {
+      return void 0;
     }
-    if (defaultValue === void 0) {
-      defaultValue = getDefaultValue(schema, { strategy: "always" });
+    return getDefaultValue(schema, required);
+  }
+  addObjectProperty(parent, parentValue, propertyName, propertyValue) {
+    if (!propertyName) {
+      return false;
+    }
+    if (parentValue === void 0 || parentValue === null) {
+      parentValue = {};
+      this.setJsonPointer(parent.instanceLocation, parentValue);
+    }
+    if (typeof parentValue !== "object") {
+      return false;
+    }
+    const { schema, keywordLocationToken, required } = getSubSchema(
+      parent.schema,
+      propertyName
+    );
+    if (!keywordLocationToken) {
+      return false;
     }
-    return defaultValue;
+    const defaultValue = propertyValue !== void 0 ? propertyValue : this.newDefaultValue(schema, required);
+    const propertyPath = jsonPointerJoin(parent.instanceLocation, propertyName);
+    const success = setJsonPointer(this.value, propertyPath, defaultValue);
+    if (!success) return false;
+    this.reconcile(parent.instanceLocation);
+    this.notify({ type: "value", path: parent.instanceLocation });
+    return true;
+  }
+  addArrayItem(parent, parentValue, initialValue) {
+    if (parentValue === void 0 || parentValue === null) {
+      parentValue = [];
+      this.setJsonPointer(parent.instanceLocation, parentValue);
+    }
+    if (!Array.isArray(parentValue)) {
+      return false;
+    }
+    const newItemIndex = String(parentValue.length);
+    const {
+      schema: subschema,
+      keywordLocationToken,
+      required
+    } = getSubSchema(parent.schema, newItemIndex);
+    if (!keywordLocationToken) {
+      return false;
+    }
+    const defaultValue = initialValue !== void 0 ? initialValue : this.newDefaultValue(subschema, required);
+    const itemPath = jsonPointerJoin(parent.instanceLocation, newItemIndex);
+    const success = setJsonPointer(this.value, itemPath, defaultValue);
+    if (!success) return false;
+    this.reconcile(parent.instanceLocation);
+    this.notify({ type: "value", path: parent.instanceLocation });
+    return true;
   }
   /**
    * Add a new child to an array or object at the specified parent path.
@@ -2371,63 +2609,19 @@ var SchemaRuntime = class {
    * @param initialValue - Optional initial value to set. If not provided, uses default from schema.
    * @returns true if successful, false if cannot add
    */
-  addValue(parentPath, key, initialValue) {
-    const normalizedPath = normalizeRootPath(parentPath);
-    const parentNode = this.findNode(normalizedPath);
+  addChild(parentPath, key, initialValue) {
+    const parentNode = this.getNode(parentPath);
     if (!parentNode || !parentNode.canAdd) {
       return false;
     }
-    let parentValue = this.getValue(normalizedPath);
-    const parentSchema = parentNode.schema;
+    const parentValue = this.getValue(parentPath);
     if (parentNode.type === "array") {
-      if (Array.isArray(parentValue)) ; else if (parentValue === void 0 || parentValue === null) {
-        parentValue = [];
-        this.setValueAtPath(normalizedPath, parentValue);
-      } else {
-        return false;
-      }
+      return this.addArrayItem(parentNode, parentValue, initialValue);
     } else if (parentNode.type === "object") {
-      if (parentValue && typeof parentValue === "object") ; else if (parentValue === void 0 || parentValue === null) {
-        parentValue = {};
-        this.setValueAtPath(normalizedPath, parentValue);
-      } else {
-        return false;
-      }
-    }
-    if (parentNode.type === "array" && Array.isArray(parentValue)) {
-      const newIndex = parentValue.length;
-      const { schema: subschema, keywordLocationToken } = getSubSchema(
-        parentSchema,
-        String(newIndex)
-      );
-      if (!keywordLocationToken) {
-        return false;
-      }
-      const defaultValue = initialValue !== void 0 ? initialValue : this.getDefaultValueForAdd(subschema);
-      const itemPath = jsonPointerJoin(normalizedPath, String(newIndex));
-      const success = setJsonPointer(this.value, itemPath, defaultValue);
-      if (!success) return false;
-      this.reconcile(normalizedPath);
-      this.notify({ type: "value", path: normalizedPath });
-      return true;
-    } else if (parentNode.type === "object" && typeof parentValue === "object") {
       if (!key) {
         return false;
       }
-      const { schema: subschema, keywordLocationToken } = getSubSchema(
-        parentSchema,
-        key
-      );
-      if (!keywordLocationToken) {
-        return false;
-      }
-      const defaultValue = initialValue !== void 0 ? initialValue : this.getDefaultValueForAdd(subschema);
-      const propertyPath = jsonPointerJoin(normalizedPath, key);
-      const success = setJsonPointer(this.value, propertyPath, defaultValue);
-      if (!success) return false;
-      this.reconcile(normalizedPath);
-      this.notify({ type: "value", path: normalizedPath });
-      return true;
+      return this.addObjectProperty(parentNode, parentValue, key, initialValue);
     }
     return false;
   }
@@ -2449,34 +2643,29 @@ var SchemaRuntime = class {
    * runtime.setValue("/optional", undefined); // remove optional field
    */
   setValue(path, value) {
-    const normalizedPath = normalizeRootPath(path);
-    if (value === void 0 && normalizedPath !== ROOT_PATH) {
-      const node = this.findNode(normalizedPath);
-      if (node && !node.isRequired) {
-        return this.removeValueInternal(normalizedPath);
-      }
+    if (value === void 0) {
+      return this.removeValueInternal(path);
     }
-    const success = this.setValueAtPath(normalizedPath, value);
+    const success = this.setJsonPointer(path, value);
     if (!success) return false;
-    this.reconcile(normalizedPath);
-    this.notify({ type: "value", path: normalizedPath });
+    this.reconcile(path);
+    this.notify({ type: "value", path });
     return true;
   }
   /**
-   * Find the FieldNode at a specific path.
+   * Get the FieldNode at a specific path.
    * Returns the node tree representation that includes schema, type, error, and children.
    *
    * @param path - The JSON Pointer path (e.g., "/user/name", "" for root)
    * @returns The FieldNode at the path, or undefined if not found
    *
    * @example
-   * const node = runtime.findNode("/name");
+   * const node = runtime.getNode("/name");
    * console.log(node?.schema, node?.type, node?.error);
    */
-  findNode(path) {
-    const normalizedPath = normalizeRootPath(path);
-    if (normalizedPath === ROOT_PATH) return this.root;
-    const segments = parseJsonPointer(normalizedPath);
+  getNode(path) {
+    if (path === "") return this.root;
+    const segments = parseJsonPointer(path);
     let current = this.root;
     for (const segment of segments) {
       if (!current?.children) return void 0;
@@ -2490,23 +2679,28 @@ var SchemaRuntime = class {
     return current;
   }
   findNearestExistingNode(path) {
-    const normalizedPath = normalizeRootPath(path);
-    let currentPath = normalizedPath;
-    while (currentPath !== ROOT_PATH) {
-      const node = this.findNode(currentPath);
+    let currentPath = path;
+    while (currentPath) {
+      const node = this.getNode(currentPath);
       if (node) return node;
-      const lastSlash = currentPath.lastIndexOf("/");
-      currentPath = lastSlash <= 0 ? ROOT_PATH : currentPath.substring(0, lastSlash);
+      currentPath = getJsonPointerParent(currentPath);
     }
     return this.root;
   }
+  validate(path) {
+    const node = this.getNode(path);
+    if (node) {
+      this.buildNode(node, void 0, { setActivated: true });
+    }
+    this.reconcile(path);
+    this.notify({ type: "value", path });
+  }
   /**
    * Update node dependencies when schema changes.
    * Unregisters old dependencies and registers new ones.
    */
   updateNodeDependencies(node, schema) {
     const { instanceLocation } = node;
-    node.originalSchema = schema;
     const dependencies = collectDependencies(schema, instanceLocation);
     for (const depPath of node.dependencies || []) {
       this.unregisterDependent(depPath, node);
@@ -2522,75 +2716,37 @@ var SchemaRuntime = class {
    * may appear when conditions change.
    *
    * Container initialization rules:
-   * - Root node is always considered required and will be initialized if it has defaults or required properties
+   * - Required containers will be initialized if it has defaults or required properties
    * - Nested containers are initialized only if they are in parent's required array
    *
    * @param instanceLocation - The path to the node
    * @param newSchema - The new effective schema
    * @param type - The schema type
-   * @param isRequired - Whether this node is required by its parent
+   * @param required - Whether this node is required by its parent
    */
-  applySchemaDefaults(instanceLocation, newSchema, type, isRequired = true) {
-    const strategy = this.options.autoFillDefaults;
+  applySchemaDefaults(instanceLocation, newSchema, type, required = true) {
+    const strategy = this.options.fillDefaults;
     if (strategy === "never") {
       return;
     }
-    let value = this.getValue(instanceLocation);
-    const isRoot = instanceLocation === ROOT_PATH;
-    if (type === "object" && newSchema.properties) {
-      const requiredSet = new Set(newSchema.required || []);
-      const hasAnyDefaults = Object.entries(newSchema.properties).some(
-        ([key, subschema]) => {
-          const defaultValue = getDefaultValue(subschema, { strategy });
-          if (defaultValue !== void 0) return true;
-          const isChildRequired = requiredSet.has(key);
-          if (isChildRequired && (subschema.type === "object" || subschema.type === "array")) {
-            return true;
-          }
-          return false;
-        }
-      );
-      const shouldInitialize = (value === void 0 || value === null) && hasAnyDefaults && (isRoot || isRequired);
-      if (shouldInitialize) {
-        value = {};
-        this.setValueAtPath(normalizeRootPath(instanceLocation), value);
-      }
-      const obj = value && typeof value === "object" ? value : null;
-      if (!obj) return;
-      for (const [key, subschema] of Object.entries(newSchema.properties)) {
-        const hasValue = obj[key] !== void 0;
-        const isChildRequired = requiredSet.has(key);
-        if (!hasValue) {
-          const defaultValue = getDefaultValue(subschema, { strategy });
-          if (defaultValue !== void 0) {
-            const propertyPath = jsonPointerJoin(instanceLocation, key);
-            setJsonPointer(this.value, propertyPath, defaultValue);
-          } else if (isChildRequired && subschema.type === "object") {
-            const propertyPath = jsonPointerJoin(instanceLocation, key);
-            setJsonPointer(this.value, propertyPath, {});
-          } else if (isChildRequired && subschema.type === "array") {
-            const propertyPath = jsonPointerJoin(instanceLocation, key);
-            setJsonPointer(this.value, propertyPath, []);
-          }
-        }
-      }
-      return;
-    }
-    if (type === "array" && newSchema.prefixItems) {
-      const arr = Array.isArray(value) ? value : null;
-      if (!arr) return;
-      for (let i = 0; i < newSchema.prefixItems.length; i++) {
-        if (arr[i] === void 0) {
-          const itemSchema = newSchema.prefixItems[i];
-          const defaultValue = getDefaultValue(itemSchema, { strategy });
-          if (defaultValue !== void 0) {
-            const itemPath = jsonPointerJoin(instanceLocation, String(i));
-            setJsonPointer(this.value, itemPath, defaultValue);
-          }
-        }
-      }
+    const value = this.getValue(instanceLocation);
+    const [newValue, changed] = applyDefaults(type, value, newSchema, required);
+    if (changed) {
+      this.setJsonPointer(instanceLocation, newValue);
     }
   }
+  /**
+   * Sort property entries by x-order.
+   * Properties with lower x-order values come first.
+   * Properties without x-order are placed at the end.
+   */
+  sortPropertiesByOrder(entries) {
+    return entries.sort(([, schemaA], [, schemaB]) => {
+      const orderA = typeof schemaA["x-order"] === "number" ? schemaA["x-order"] : Infinity;
+      const orderB = typeof schemaB["x-order"] === "number" ? schemaB["x-order"] : Infinity;
+      return orderA - orderB;
+    });
+  }
   /**
    * Build children for object and array nodes.
    * Reuses existing child nodes where possible.
@@ -2599,40 +2755,41 @@ var SchemaRuntime = class {
     const { keywordLocation, instanceLocation } = node;
     const effectiveSchema = node.schema;
     const type = node.type;
+    const processedKeys = /* @__PURE__ */ new Set();
+    const newChildren = [];
     const oldChildrenMap = /* @__PURE__ */ new Map();
-    if (node.children) {
-      for (const child of node.children) {
-        oldChildrenMap.set(child.instanceLocation, child);
-      }
+    for (const child of node.children || []) {
+      oldChildrenMap.set(child.instanceLocation, child);
     }
-    const newChildren = [];
     const processChild = (childKey, childSchema, childkeywordLocation, canRemove = false, isRequired = false) => {
       const childinstanceLocation = jsonPointerJoin(instanceLocation, childKey);
+      if (processedKeys.has(childinstanceLocation)) {
+        return;
+      }
+      processedKeys.add(childinstanceLocation);
       let childNode = oldChildrenMap.get(childinstanceLocation);
-      if (childNode) {
-        oldChildrenMap.delete(childinstanceLocation);
-        childNode.keywordLocation = childkeywordLocation;
-      } else {
+      if (!childNode) {
         childNode = this.createEmptyNode(
           childinstanceLocation,
           childkeywordLocation
         );
       }
+      childNode.keywordLocation = childkeywordLocation;
+      childNode.originKeywordLocation = typeof childSchema["x-origin-keyword"] === "string" ? childSchema["x-origin-keyword"] : childkeywordLocation;
       childNode.canRemove = canRemove;
-      childNode.isRequired = isRequired;
-      this.buildNode(childNode, childSchema, { ...options, isRequired });
+      childNode.required = isRequired;
+      this.buildNode(childNode, childSchema, { ...options });
       newChildren.push(childNode);
     };
     switch (type) {
       case "object": {
         const valueKeys = value && typeof value === "object" ? Object.keys(value) : [];
-        const processedKeys = /* @__PURE__ */ new Set();
-        node.canAdd = !!effectiveSchema.additionalProperties;
+        node.canAdd = !!effectiveSchema.additionalProperties || !!effectiveSchema.patternProperties;
         if (effectiveSchema.properties) {
-          for (const [key, subschema] of Object.entries(
-            effectiveSchema.properties
-          )) {
-            processedKeys.add(key);
+          const propertyEntries = this.sortPropertiesByOrder(
+            Object.entries(effectiveSchema.properties)
+          );
+          for (const [key, subschema] of propertyEntries) {
             const isChildRequired = effectiveSchema.required?.includes(key) ?? false;
             processChild(
               key,
@@ -2648,8 +2805,7 @@ var SchemaRuntime = class {
             effectiveSchema.patternProperties
           )) {
             for (const key of valueKeys) {
-              if (safeRegexTest(pattern, key) && !processedKeys.has(key)) {
-                processedKeys.add(key);
+              if (safeRegexTest(pattern, key)) {
                 processChild(
                   key,
                   subschema,
@@ -2665,16 +2821,14 @@ var SchemaRuntime = class {
         if (effectiveSchema.additionalProperties) {
           const subschema = typeof effectiveSchema.additionalProperties === "object" ? effectiveSchema.additionalProperties : {};
           for (const key of valueKeys) {
-            if (!processedKeys.has(key)) {
-              processChild(
-                key,
-                subschema,
-                `${keywordLocation}/additionalProperties`,
-                true,
-                false
-                // additionalProperties are never required
-              );
-            }
+            processChild(
+              key,
+              subschema,
+              `${keywordLocation}/additionalProperties`,
+              true,
+              false
+              // additionalProperties are never required
+            );
           }
         }
         break;
@@ -2692,7 +2846,7 @@ var SchemaRuntime = class {
                 `${keywordLocation}/prefixItems/${i}`,
                 false,
                 true
-                // array items are always considered required
+                // array prefix items are always considered required
               );
             }
           }
@@ -2712,8 +2866,10 @@ var SchemaRuntime = class {
         break;
       }
     }
-    for (const oldChild of oldChildrenMap.values()) {
-      this.unregisterNodeDependencies(oldChild);
+    for (const [location, child] of oldChildrenMap) {
+      if (!processedKeys.has(location)) {
+        this.unregisterNodeDependencies(child);
+      }
     }
     node.children = newChildren;
   }
@@ -2726,6 +2882,9 @@ var SchemaRuntime = class {
   buildNode(node, schema, options = {}) {
     const { keywordLocation, instanceLocation } = node;
     const value = this.getValue(instanceLocation);
+    if (options.setActivated) {
+      node.activated = true;
+    }
     if (this.updatingNodes.has(instanceLocation)) {
       return;
     }
@@ -2737,26 +2896,25 @@ var SchemaRuntime = class {
     try {
       const schemaChanged = schema !== void 0 && !deepEqual(schema, node.originalSchema);
       if (schemaChanged) {
+        node.originalSchema = schema;
         this.updateNodeDependencies(node, schema);
       }
-      const isRequired = options.isRequired ?? true;
       const { type, effectiveSchema, error } = resolveEffectiveSchema(
         this.validator,
         node.originalSchema,
         value,
         keywordLocation,
         instanceLocation,
-        isRequired
+        node.activated
       );
-      const isInitialBuild = node.version === -1;
-      const effectiveSchemaChanged = isInitialBuild || !deepEqual(effectiveSchema, node.schema) || type !== node.type;
-      const errorChanged = isInitialBuild || !deepEqual(error, node.error);
+      const effectiveSchemaChanged = !deepEqual(effectiveSchema, node.schema) || type !== node.type;
+      const errorChanged = !deepEqual(error, node.error);
       if (effectiveSchemaChanged) {
         this.applySchemaDefaults(
           instanceLocation,
           effectiveSchema,
           type,
-          isRequired
+          node.required
         );
       }
       node.schema = effectiveSchema;
@@ -2764,34 +2922,42 @@ var SchemaRuntime = class {
       node.error = error;
       node.version++;
       const currentValue = this.getValue(instanceLocation);
-      this.buildNodeChildren(node, currentValue, { ...options, updatedNodes });
-      if (effectiveSchemaChanged) {
-        this.notify({ type: "schema", path: instanceLocation });
-      }
-      if (errorChanged) {
-        this.notify({ type: "error", path: instanceLocation });
-      }
+      this.buildNodeChildren(node, currentValue, {
+        setActivated: options.setActivated || void 0,
+        // propagate activation
+        updatedNodes
+      });
       updatedNodes.add(instanceLocation);
       const dependentNodes = this.dependentsMap.get(instanceLocation);
       if (dependentNodes) {
         for (const dependentNode of dependentNodes) {
           this.buildNode(dependentNode, void 0, {
-            ...options,
+            setActivated: void 0,
+            // do not change dependent node activation state
             updatedNodes
           });
         }
       }
+      if (effectiveSchemaChanged) {
+        this.notify({ type: "schema", path: instanceLocation });
+      }
+      if (errorChanged) {
+        this.notify({ type: "error", path: instanceLocation });
+      }
     } finally {
       this.updatingNodes.delete(instanceLocation);
     }
   }
 };
 
+exports.BetterNormalizer = BetterNormalizer;
 exports.DRAFT_URIS = DRAFT_URIS;
+exports.DraftNormalizer = DraftNormalizer;
 exports.MESSAGES = MESSAGES;
 exports.SchemaRuntime = SchemaRuntime;
 exports.StringFormatValidator = StringFormatValidator;
 exports.Validator = Validator;
+exports.applyDefaults = applyDefaults;
 exports.collectDependencies = collectDependencies;
 exports.deepEqual = deepEqual;
 exports.defaultErrorFormatter = defaultErrorFormatter;
@@ -2801,6 +2967,7 @@ exports.extractReferencedPaths = extractReferencedPaths;
 exports.get = get;
 exports.getDefaultValue = getDefaultValue;
 exports.getJsonPointer = getJsonPointer;
+exports.getJsonPointerParent = getJsonPointerParent;
 exports.jsonPointerEscape = jsonPointerEscape;
 exports.jsonPointerJoin = jsonPointerJoin;
 exports.jsonPointerUnescape = jsonPointerUnescape;
@@ -2812,6 +2979,7 @@ exports.resolveAbsolutePath = resolveAbsolutePath;
 exports.safeRegexTest = safeRegexTest;
 exports.setJsonPointer = setJsonPointer;
 exports.stringFormatValidator = stringFormatValidator;
+exports.typeNullable = typeNullable;
 exports.validateSchema = validateSchema;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map