@schema-ts/core 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -1333,6 +1333,225 @@ function validateSchema(schema, value, instancePath = "", schemaPath = "#", fast
   });
 }
 
+// src/effective.ts
+function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation) {
+  let effective = schema;
+  if (effective.if) {
+    const output = validator.validate(
+      effective.if,
+      value,
+      `${keywordLocation}/if`,
+      instanceLocation
+    );
+    if (output.valid) {
+      if (effective.then) {
+        const res = resolveEffectiveSchema(
+          validator,
+          effective.then,
+          value,
+          `${keywordLocation}/then`,
+          instanceLocation
+        );
+        effective = mergeSchema(effective, res.effectiveSchema);
+      }
+    } else {
+      if (effective.else) {
+        const res = resolveEffectiveSchema(
+          validator,
+          effective.else,
+          value,
+          `${keywordLocation}/else`,
+          instanceLocation
+        );
+        effective = mergeSchema(effective, res.effectiveSchema);
+      }
+    }
+    const { if: _, then: __, else: ___, ...rest } = effective;
+    effective = rest;
+  }
+  if (effective.allOf) {
+    for (const [index, subschema] of effective.allOf.entries()) {
+      const res = resolveEffectiveSchema(
+        validator,
+        subschema,
+        value,
+        `${keywordLocation}/allOf/${index}`,
+        instanceLocation
+      );
+      effective = mergeSchema(effective, res.effectiveSchema);
+    }
+    const { allOf: _, ...rest } = effective;
+    effective = rest;
+  }
+  if (effective.anyOf) {
+    for (const [index, subschema] of effective.anyOf.entries()) {
+      const output = validator.validate(
+        subschema,
+        value,
+        keywordLocation + `/anyOf/` + index,
+        instanceLocation
+      );
+      if (output.valid) {
+        const res = resolveEffectiveSchema(
+          validator,
+          subschema,
+          value,
+          keywordLocation + `/anyOf/` + index,
+          instanceLocation
+        );
+        effective = mergeSchema(effective, res.effectiveSchema);
+        break;
+      }
+    }
+    const { anyOf: _, ...rest } = effective;
+    effective = rest;
+  }
+  if (effective.oneOf) {
+    let validCount = 0;
+    let lastValidSchema = null;
+    for (const [index, subschema] of effective.oneOf.entries()) {
+      const output = validator.validate(
+        subschema,
+        value,
+        `${keywordLocation}/oneOf/${index}`,
+        instanceLocation
+      );
+      if (output.valid) {
+        validCount++;
+        lastValidSchema = subschema;
+      }
+    }
+    if (validCount === 1 && lastValidSchema) {
+      effective = mergeSchema(effective, lastValidSchema);
+    }
+    const { oneOf: _, ...rest } = effective;
+    effective = rest;
+  }
+  let type = "unknown";
+  if (effective.type) {
+    const allowedTypes = Array.isArray(effective.type) ? effective.type : [effective.type];
+    const matched = allowedTypes.find((t) => matchSchemaType(value, t));
+    if (matched) {
+      type = matched;
+    } else {
+      type = allowedTypes[0];
+    }
+  } else {
+    type = detectSchemaType(value);
+  }
+  const validationOutput = validator.validate(
+    effective,
+    value,
+    keywordLocation,
+    instanceLocation,
+    { shallow: true }
+  );
+  return {
+    effectiveSchema: effective,
+    type,
+    error: validationOutput.valid ? void 0 : validationOutput
+  };
+}
+function mergeStrings(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  const merged = Array.from(/* @__PURE__ */ new Set([...a, ...b]));
+  return merged.length === 0 ? void 0 : merged;
+}
+function mergeType(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  const arrayA = Array.isArray(a) ? a : [a];
+  const arrayB = Array.isArray(b) ? b : [b];
+  const merged = arrayA.filter((t) => arrayB.includes(t));
+  if (merged.length === 0) return void 0;
+  return merged.length === 1 ? merged[0] : merged;
+}
+function mergeSchemaArrays(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return [...a, ...b];
+}
+function mergeSchema(base, override) {
+  if (!override) return base;
+  const merged = {
+    ...base,
+    ...override
+  };
+  if (base.$defs || override.$defs) {
+    merged.$defs = {
+      ...base.$defs,
+      ...override.$defs
+    };
+  }
+  const mergedRequired = mergeStrings(base.required, override.required);
+  if (mergedRequired !== void 0) {
+    merged.required = mergedRequired;
+  }
+  const mergedType = mergeType(base.type, override.type);
+  if (mergedType !== void 0) {
+    merged.type = mergedType;
+  }
+  if (base.dependentRequired || override.dependentRequired) {
+    merged.dependentRequired = {
+      ...base.dependentRequired,
+      ...override.dependentRequired
+    };
+  }
+  if (base.properties || override.properties) {
+    merged.properties = {
+      ...base.properties,
+      ...override.properties
+    };
+  }
+  if (base.patternProperties || override.patternProperties) {
+    merged.patternProperties = {
+      ...base.patternProperties,
+      ...override.patternProperties
+    };
+  }
+  if (base.items && override.items) {
+    merged.items = mergeSchema(base.items, override.items);
+  } else if (base.items) {
+    merged.items = base.items;
+  } else if (override.items) {
+    merged.items = override.items;
+  }
+  if (base.prefixItems || override.prefixItems) {
+    merged.prefixItems = [];
+    const len = Math.max(
+      base.prefixItems?.length || 0,
+      override.prefixItems?.length || 0
+    );
+    for (let i = 0; i < len; i++) {
+      const baseSchema = base.prefixItems?.[i];
+      const overrideSchema = override.prefixItems?.[i];
+      if (baseSchema && overrideSchema) {
+        merged.prefixItems.push(mergeSchema(baseSchema, overrideSchema));
+      } else {
+        const schema = baseSchema || overrideSchema;
+        if (schema) {
+          merged.prefixItems.push(schema);
+        }
+      }
+    }
+  }
+  const combinatorKeywords = ["allOf", "anyOf", "oneOf"];
+  for (const keyword of combinatorKeywords) {
+    const mergedArray = mergeSchemaArrays(base[keyword], override[keyword]);
+    if (mergedArray !== void 0) {
+      merged[keyword] = mergedArray;
+    }
+  }
+  if (base.dependentSchemas || override.dependentSchemas) {
+    merged.dependentSchemas = {
+      ...base.dependentSchemas,
+      ...override.dependentSchemas
+    };
+  }
+  return merged;
+}
+
 // src/schema-util.ts
 var schemaUtilLogger = {
   warn: (message) => console.warn(message)
@@ -1500,411 +1719,297 @@ function dereferenceSchemaDeep(schema, rootSchema, processed = /* @__PURE__ */ n
   processed.set(schema, result);
   return result;
 }
-var MAX_EXTRACT_DEPTH = 100;
-function extractReferencedPaths(conditionSchema, basePath = "", depth = 0) {
-  if (depth > MAX_EXTRACT_DEPTH) {
-    console.warn(
-      `extractReferencedPaths: max depth (${MAX_EXTRACT_DEPTH}) exceeded at path: ${basePath}`
-    );
-    return [];
+function getSubSchema(schema, key) {
+  if (schema.properties && schema.properties[key]) {
+    return {
+      schema: schema.properties[key],
+      keywordLocationToken: `properties/${key}`
+    };
   }
-  const paths = [];
-  const schema = conditionSchema;
-  if (schema.properties) {
-    for (const key of Object.keys(schema.properties)) {
-      const childPath = basePath ? `${basePath}/${key}` : `/${key}`;
-      paths.push(childPath);
-      paths.push(
-        ...extractReferencedPaths(schema.properties[key], childPath, depth + 1)
-      );
+  if (schema.patternProperties) {
+    for (const [pattern, subschema] of Object.entries(
+      schema.patternProperties
+    )) {
+      if (safeRegexTest(pattern, key)) {
+        return {
+          schema: subschema,
+          keywordLocationToken: `patternProperties/${pattern}`
+        };
+      }
     }
   }
-  if (schema.items && typeof schema.items === "object") {
-    paths.push(basePath || "/");
-    paths.push(...extractReferencedPaths(schema.items, basePath, depth + 1));
-  }
-  if (schema.prefixItems) {
-    schema.prefixItems.forEach((itemSchema, index) => {
-      const indexPath = basePath ? `${basePath}/${index}` : `/${index}`;
-      paths.push(indexPath);
-      paths.push(...extractReferencedPaths(itemSchema, indexPath, depth + 1));
-    });
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+    return {
+      schema: typeof schema.additionalProperties === "object" ? schema.additionalProperties : {},
+      keywordLocationToken: "additionalProperties"
+    };
   }
-  if (schema.const !== void 0 || schema.enum) {
-    if (basePath) {
-      paths.push(basePath);
+  if (schema.items || schema.prefixItems) {
+    const index = parseInt(key, 10);
+    if (!isNaN(index)) {
+      if (schema.prefixItems && index < schema.prefixItems.length) {
+        return {
+          schema: schema.prefixItems[index],
+          keywordLocationToken: `prefixItems/${index}`
+        };
+      }
+      if (schema.items) {
+        return {
+          schema: schema.items,
+          keywordLocationToken: "items"
+        };
+      }
     }
   }
-  if (schema.type && basePath) {
-    paths.push(basePath);
+  return {
+    schema: {},
+    keywordLocationToken: ""
+  };
+}
+
+// src/default.ts
+function getDefaultValue(schema, value) {
+  if (value === void 0) {
+    if (schema.const !== void 0) return schema.const;
+    if (schema.default !== void 0) return schema.default;
   }
-  const valueConstraints = [
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "minLength",
-    "maxLength",
-    "pattern",
-    "format",
-    "minItems",
-    "maxItems",
-    "uniqueItems",
-    "minProperties",
-    "maxProperties"
-  ];
-  for (const constraint of valueConstraints) {
-    if (schema[constraint] !== void 0 && basePath) {
-      paths.push(basePath);
-      break;
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type === "object" || !type && schema.properties) {
+    let obj;
+    if (value === 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, obj[key]);
+        } else if (schema.required?.includes(key)) {
+          obj[key] = getDefaultValue(subschema);
+        }
+      }
     }
+    return obj;
   }
+  if (type === "array") {
+    let arr;
+    if (value === 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, arr[index]);
+        } else if (value === void 0) {
+          arr.push(getDefaultValue(subschema));
+        }
+      });
+    }
+    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, arr[i]);
+      }
+    }
+    return arr;
+  }
+  if (value !== void 0) {
+    return value;
+  }
+  switch (type) {
+    case "string":
+      return "";
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    case "null":
+      return null;
+    default:
+      return void 0;
+  }
+}
+
+// src/dependency.ts
+function collectDependencies(schema, instanceLocation) {
+  const deps = /* @__PURE__ */ new Set();
   if (schema.required) {
     for (const req of schema.required) {
-      paths.push(basePath ? `${basePath}/${req}` : `/${req}`);
+      deps.add(resolveAbsolutePath(instanceLocation, `/${req}`));
     }
   }
   if (schema.dependentRequired) {
     for (const [prop, reqs] of Object.entries(schema.dependentRequired)) {
-      paths.push(basePath ? `${basePath}/${prop}` : `/${prop}`);
+      deps.add(resolveAbsolutePath(instanceLocation, `/${prop}`));
       for (const req of reqs) {
-        paths.push(basePath ? `${basePath}/${req}` : `/${req}`);
+        deps.add(resolveAbsolutePath(instanceLocation, `/${req}`));
       }
     }
   }
   if (schema.dependentSchemas) {
     for (const [prop, subSchema] of Object.entries(schema.dependentSchemas)) {
-      paths.push(basePath ? `${basePath}/${prop}` : `/${prop}`);
-      paths.push(...extractReferencedPaths(subSchema, basePath, depth + 1));
+      deps.add(resolveAbsolutePath(instanceLocation, `/${prop}`));
+      const subDeps = collectDependencies(subSchema, instanceLocation);
+      subDeps.forEach((d) => deps.add(d));
     }
   }
   if (schema.if) {
-    paths.push(...extractReferencedPaths(schema.if, basePath, depth + 1));
-  }
-  if (schema.then) {
-    paths.push(...extractReferencedPaths(schema.then, basePath, depth + 1));
-  }
-  if (schema.else) {
-    paths.push(...extractReferencedPaths(schema.else, basePath, depth + 1));
-  }
-  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-    const subSchemas = schema[keyword];
-    if (subSchemas) {
-      for (const subSchema of subSchemas) {
-        paths.push(...extractReferencedPaths(subSchema, basePath, depth + 1));
-      }
+    const relativePaths = extractReferencedPaths(schema.if, "");
+    for (const relPath of relativePaths) {
+      deps.add(resolveAbsolutePath(instanceLocation, relPath));
     }
-  }
-  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.then) {
+      const thenDeps = collectDependencies(schema.then, instanceLocation);
+      thenDeps.forEach((d) => deps.add(d));
     }
-  }
-  if (schema.contains) {
-    paths.push(basePath || "/");
-    paths.push(...extractReferencedPaths(schema.contains, basePath, depth + 1));
-  }
-  return [...new Set(paths)];
-}
-function resolveEffectiveSchema(validator, schema, value, keywordLocation, instanceLocation) {
-  let effective = schema;
-  if (effective.if) {
-    const output = validator.validate(
-      effective.if,
-      value,
-      `${keywordLocation}/if`,
-      instanceLocation
-    );
-    if (output.valid) {
-      if (effective.then) {
-        const res = resolveEffectiveSchema(
-          validator,
-          effective.then,
-          value,
-          `${keywordLocation}/then`,
-          instanceLocation
-        );
-        effective = mergeSchema(effective, res.effectiveSchema);
-      }
-    } else {
-      if (effective.else) {
-        const res = resolveEffectiveSchema(
-          validator,
-          effective.else,
-          value,
-          `${keywordLocation}/else`,
-          instanceLocation
-        );
-        effective = mergeSchema(effective, res.effectiveSchema);
-      }
+    if (schema.else) {
+      const elseDeps = collectDependencies(schema.else, instanceLocation);
+      elseDeps.forEach((d) => deps.add(d));
     }
-    const { if: _, then: __, else: ___, ...rest } = effective;
-    effective = rest;
   }
-  if (effective.allOf) {
-    for (const [index, subschema] of effective.allOf.entries()) {
-      const res = resolveEffectiveSchema(
-        validator,
-        subschema,
-        value,
-        `${keywordLocation}/allOf/${index}`,
-        instanceLocation
-      );
-      effective = mergeSchema(effective, res.effectiveSchema);
-    }
-    const { allOf: _, ...rest } = effective;
-    effective = rest;
-  }
-  if (effective.anyOf) {
-    for (const [index, subschema] of effective.anyOf.entries()) {
-      const output = validator.validate(
-        subschema,
-        value,
-        keywordLocation + `/anyOf/` + index,
-        instanceLocation
-      );
-      if (output.valid) {
-        const res = resolveEffectiveSchema(
-          validator,
-          subschema,
-          value,
-          keywordLocation + `/anyOf/` + index,
-          instanceLocation
-        );
-        effective = mergeSchema(effective, res.effectiveSchema);
-        break;
+  if (schema.oneOf) {
+    for (const subSchema of schema.oneOf) {
+      const relativePaths = extractReferencedPaths(subSchema, "");
+      for (const relPath of relativePaths) {
+        deps.add(resolveAbsolutePath(instanceLocation, relPath));
       }
+      const subDeps = collectDependencies(subSchema, instanceLocation);
+      subDeps.forEach((d) => deps.add(d));
     }
-    const { anyOf: _, ...rest } = effective;
-    effective = rest;
   }
-  if (effective.oneOf) {
-    let validCount = 0;
-    let lastValidSchema = null;
-    for (const [index, subschema] of effective.oneOf.entries()) {
-      const output = validator.validate(
-        subschema,
-        value,
-        `${keywordLocation}/oneOf/${index}`,
-        instanceLocation
-      );
-      if (output.valid) {
-        validCount++;
-        lastValidSchema = subschema;
+  if (schema.anyOf) {
+    for (const subSchema of schema.anyOf) {
+      const relativePaths = extractReferencedPaths(subSchema, "");
+      for (const relPath of relativePaths) {
+        deps.add(resolveAbsolutePath(instanceLocation, relPath));
       }
+      const subDeps = collectDependencies(subSchema, instanceLocation);
+      subDeps.forEach((d) => deps.add(d));
     }
-    if (validCount === 1 && lastValidSchema) {
-      effective = mergeSchema(effective, lastValidSchema);
-    }
-    const { oneOf: _, ...rest } = effective;
-    effective = rest;
   }
-  let type = "unknown";
-  if (effective.type) {
-    const allowedTypes = Array.isArray(effective.type) ? effective.type : [effective.type];
-    const matched = allowedTypes.find((t) => matchSchemaType(value, t));
-    if (matched) {
-      type = matched;
-    } else {
-      type = allowedTypes[0];
+  if (schema.allOf) {
+    for (const subSchema of schema.allOf) {
+      const subDeps = collectDependencies(subSchema, instanceLocation);
+      subDeps.forEach((d) => deps.add(d));
     }
-  } else {
-    type = detectSchemaType(value);
   }
-  const validationOutput = validator.validate(
-    effective,
-    value,
-    keywordLocation,
-    instanceLocation,
-    { shallow: true }
-  );
-  return {
-    effectiveSchema: effective,
-    type,
-    error: validationOutput.valid ? void 0 : validationOutput
-  };
-}
-function mergeStrings(a, b) {
-  if (a === void 0) return b;
-  if (b === void 0) return a;
-  const merged = Array.from(/* @__PURE__ */ new Set([...a, ...b]));
-  return merged.length === 0 ? void 0 : merged;
-}
-function mergeType(a, b) {
-  if (a === void 0) return b;
-  if (b === void 0) return a;
-  const arrayA = Array.isArray(a) ? a : [a];
-  const arrayB = Array.isArray(b) ? b : [b];
-  const merged = arrayA.filter((t) => arrayB.includes(t));
-  if (merged.length === 0) return void 0;
-  return merged.length === 1 ? merged[0] : merged;
+  return deps;
 }
-function mergeSchemaArrays(a, b) {
-  if (a === void 0) return b;
-  if (b === void 0) return a;
-  return [...a, ...b];
-}
-function mergeSchema(base, override) {
-  if (!override) return base;
-  const merged = {
-    ...base,
-    ...override
-  };
-  if (base.$defs || override.$defs) {
-    merged.$defs = {
-      ...base.$defs,
-      ...override.$defs
-    };
-  }
-  const mergedRequired = mergeStrings(base.required, override.required);
-  if (mergedRequired !== void 0) {
-    merged.required = mergedRequired;
-  }
-  const mergedType = mergeType(base.type, override.type);
-  if (mergedType !== void 0) {
-    merged.type = mergedType;
-  }
-  if (base.dependentRequired || override.dependentRequired) {
-    merged.dependentRequired = {
-      ...base.dependentRequired,
-      ...override.dependentRequired
-    };
-  }
-  if (base.properties || override.properties) {
-    merged.properties = {
-      ...base.properties,
-      ...override.properties
-    };
-  }
-  if (base.patternProperties || override.patternProperties) {
-    merged.patternProperties = {
-      ...base.patternProperties,
-      ...override.patternProperties
-    };
-  }
-  if (base.items && override.items) {
-    merged.items = mergeSchema(base.items, override.items);
-  } else if (base.items) {
-    merged.items = base.items;
-  } else if (override.items) {
-    merged.items = override.items;
-  }
-  if (base.prefixItems || override.prefixItems) {
-    merged.prefixItems = [];
-    const len = Math.max(
-      base.prefixItems?.length || 0,
-      override.prefixItems?.length || 0
+var MAX_EXTRACT_DEPTH = 100;
+function extractReferencedPaths(conditionSchema, basePath = "", depth = 0) {
+  if (depth > MAX_EXTRACT_DEPTH) {
+    console.warn(
+      `extractReferencedPaths: max depth (${MAX_EXTRACT_DEPTH}) exceeded at path: ${basePath}`
     );
-    for (let i = 0; i < len; i++) {
-      const baseSchema = base.prefixItems?.[i];
-      const overrideSchema = override.prefixItems?.[i];
-      if (baseSchema && overrideSchema) {
-        merged.prefixItems.push(mergeSchema(baseSchema, overrideSchema));
-      } else {
-        const schema = baseSchema || overrideSchema;
-        if (schema) {
-          merged.prefixItems.push(schema);
-        }
-      }
+    return [];
+  }
+  const paths = [];
+  const schema = conditionSchema;
+  if (schema.properties) {
+    for (const key of Object.keys(schema.properties)) {
+      const childPath = basePath ? `${basePath}/${key}` : `/${key}`;
+      paths.push(childPath);
+      paths.push(
+        ...extractReferencedPaths(schema.properties[key], childPath, depth + 1)
+      );
     }
   }
-  const combinatorKeywords = ["allOf", "anyOf", "oneOf"];
-  for (const keyword of combinatorKeywords) {
-    const mergedArray = mergeSchemaArrays(base[keyword], override[keyword]);
-    if (mergedArray !== void 0) {
-      merged[keyword] = mergedArray;
+  if (schema.items && typeof schema.items === "object") {
+    paths.push(basePath || "/");
+    paths.push(...extractReferencedPaths(schema.items, basePath, depth + 1));
+  }
+  if (schema.prefixItems) {
+    schema.prefixItems.forEach((itemSchema, index) => {
+      const indexPath = basePath ? `${basePath}/${index}` : `/${index}`;
+      paths.push(indexPath);
+      paths.push(...extractReferencedPaths(itemSchema, indexPath, depth + 1));
+    });
+  }
+  if (schema.const !== void 0 || schema.enum) {
+    if (basePath) {
+      paths.push(basePath);
     }
   }
-  if (base.dependentSchemas || override.dependentSchemas) {
-    merged.dependentSchemas = {
-      ...base.dependentSchemas,
-      ...override.dependentSchemas
-    };
+  if (schema.type && basePath) {
+    paths.push(basePath);
   }
-  return merged;
-}
-function getSubSchema(schema, key) {
-  if (schema.properties && schema.properties[key]) {
-    return {
-      schema: schema.properties[key],
-      keywordLocationToken: `properties/${key}`
-    };
+  const valueConstraints = [
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "format",
+    "minItems",
+    "maxItems",
+    "uniqueItems",
+    "minProperties",
+    "maxProperties"
+  ];
+  for (const constraint of valueConstraints) {
+    if (schema[constraint] !== void 0 && basePath) {
+      paths.push(basePath);
+      break;
+    }
   }
-  if (schema.patternProperties) {
-    for (const [pattern, subschema] of Object.entries(
-      schema.patternProperties
-    )) {
-      if (safeRegexTest(pattern, key)) {
-        return {
-          schema: subschema,
-          keywordLocationToken: `patternProperties/${pattern}`
-        };
+  if (schema.required) {
+    for (const req of schema.required) {
+      paths.push(basePath ? `${basePath}/${req}` : `/${req}`);
+    }
+  }
+  if (schema.dependentRequired) {
+    for (const [prop, reqs] of Object.entries(schema.dependentRequired)) {
+      paths.push(basePath ? `${basePath}/${prop}` : `/${prop}`);
+      for (const req of reqs) {
+        paths.push(basePath ? `${basePath}/${req}` : `/${req}`);
       }
     }
   }
-  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
-    return {
-      schema: typeof schema.additionalProperties === "object" ? schema.additionalProperties : {},
-      keywordLocationToken: "additionalProperties"
-    };
+  if (schema.dependentSchemas) {
+    for (const [prop, subSchema] of Object.entries(schema.dependentSchemas)) {
+      paths.push(basePath ? `${basePath}/${prop}` : `/${prop}`);
+      paths.push(...extractReferencedPaths(subSchema, basePath, depth + 1));
+    }
   }
-  if (schema.items || schema.prefixItems) {
-    const index = parseInt(key, 10);
-    if (!isNaN(index)) {
-      if (schema.prefixItems && index < schema.prefixItems.length) {
-        return {
-          schema: schema.prefixItems[index],
-          keywordLocationToken: `prefixItems/${index}`
-        };
-      }
-      if (schema.items) {
-        return {
-          schema: schema.items,
-          keywordLocationToken: "items"
-        };
+  if (schema.if) {
+    paths.push(...extractReferencedPaths(schema.if, basePath, depth + 1));
+  }
+  if (schema.then) {
+    paths.push(...extractReferencedPaths(schema.then, basePath, depth + 1));
+  }
+  if (schema.else) {
+    paths.push(...extractReferencedPaths(schema.else, basePath, depth + 1));
+  }
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const subSchemas = schema[keyword];
+    if (subSchemas) {
+      for (const subSchema of subSchemas) {
+        paths.push(...extractReferencedPaths(subSchema, basePath, depth + 1));
       }
     }
   }
-  return {
-    schema: {},
-    keywordLocationToken: ""
-  };
-}
-function getDefaultValue(schema) {
-  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;
-  switch (type) {
-    case "string":
-      return "";
-    case "number":
-    case "integer":
-      return 0;
-    case "boolean":
-      return false;
-    case "null":
-      return null;
-    case "object": {
-      const obj = {};
-      if (schema.properties) {
-        for (const [key, subschema] of Object.entries(schema.properties)) {
-          if (schema.required?.includes(key)) {
-            obj[key] = getDefaultValue(subschema);
-          }
-        }
-      }
-      return obj;
+  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));
     }
-    case "array":
-      return [];
-    default:
-      if (schema.properties) {
-        return getDefaultValue({ ...schema, type: "object" });
-      }
-      return void 0;
   }
+  if (schema.contains) {
+    paths.push(basePath || "/");
+    paths.push(...extractReferencedPaths(schema.contains, basePath, depth + 1));
+  }
+  return [...new Set(paths)];
 }
 
 // src/render.ts
@@ -1937,90 +2042,13 @@ var SchemaRuntime = class {
    * const runtime = new SchemaRuntime(validator, schema, { name: "Alice" });
    */
   constructor(validator, schema, value) {
-    const normalized = normalizeSchema(schema);
-    this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
     this.validator = validator;
     this.value = value;
+    const normalized = normalizeSchema(schema);
+    this.rootSchema = dereferenceSchemaDeep(normalized, normalized);
     this.root = this.createEmptyNode("", "#");
     this.buildNode(this.root, this.rootSchema);
-  }
-  /**
-   * Collect all dependencies for a node's schema.
-   *
-   * Key insight: We extract paths from condition keywords (if, oneOf, anyOf)
-   * using extractReferencedPaths, but for then/else/allOf keywords, we recursively
-   * call collectDependencies to ensure proper dependency isolation between
-   * parent and child nodes.
-   */
-  collectDependencies(schema, instanceLocation) {
-    const deps = /* @__PURE__ */ new Set();
-    if (schema.required) {
-      for (const req of schema.required) {
-        deps.add(resolveAbsolutePath(instanceLocation, `/${req}`));
-      }
-    }
-    if (schema.dependentRequired) {
-      for (const [prop, reqs] of Object.entries(schema.dependentRequired)) {
-        deps.add(resolveAbsolutePath(instanceLocation, `/${prop}`));
-        for (const req of reqs) {
-          deps.add(resolveAbsolutePath(instanceLocation, `/${req}`));
-        }
-      }
-    }
-    if (schema.dependentSchemas) {
-      for (const [prop, subSchema] of Object.entries(schema.dependentSchemas)) {
-        deps.add(resolveAbsolutePath(instanceLocation, `/${prop}`));
-        const subDeps = this.collectDependencies(subSchema, instanceLocation);
-        subDeps.forEach((d) => deps.add(d));
-      }
-    }
-    if (schema.if) {
-      const relativePaths = extractReferencedPaths(schema.if, "");
-      for (const relPath of relativePaths) {
-        deps.add(resolveAbsolutePath(instanceLocation, relPath));
-      }
-      if (schema.then) {
-        const thenDeps = this.collectDependencies(
-          schema.then,
-          instanceLocation
-        );
-        thenDeps.forEach((d) => deps.add(d));
-      }
-      if (schema.else) {
-        const elseDeps = this.collectDependencies(
-          schema.else,
-          instanceLocation
-        );
-        elseDeps.forEach((d) => deps.add(d));
-      }
-    }
-    if (schema.oneOf) {
-      for (const subSchema of schema.oneOf) {
-        const relativePaths = extractReferencedPaths(subSchema, "");
-        for (const relPath of relativePaths) {
-          deps.add(resolveAbsolutePath(instanceLocation, relPath));
-        }
-        const subDeps = this.collectDependencies(subSchema, instanceLocation);
-        subDeps.forEach((d) => deps.add(d));
-      }
-    }
-    if (schema.anyOf) {
-      for (const subSchema of schema.anyOf) {
-        const relativePaths = extractReferencedPaths(subSchema, "");
-        for (const relPath of relativePaths) {
-          deps.add(resolveAbsolutePath(instanceLocation, relPath));
-        }
-        const subDeps = this.collectDependencies(subSchema, instanceLocation);
-        subDeps.forEach((d) => deps.add(d));
-      }
-    }
-    if (schema.allOf) {
-      for (const subSchema of schema.allOf) {
-        const subDeps = this.collectDependencies(subSchema, instanceLocation);
-        subDeps.forEach((d) => deps.add(d));
-      }
-    }
-    return deps;
+    this.notify({ type: "schema", path: ROOT_PATH });
   }
   /**
    * Register a node as dependent on a path
@@ -2241,10 +2269,13 @@ var SchemaRuntime = class {
     const parentSchema = parentNode.schema;
     if (parentNode.type === "array" && Array.isArray(parentValue)) {
       const newIndex = parentValue.length;
-      const { schema: subschema } = getSubSchema(
+      const { schema: subschema, keywordLocationToken } = getSubSchema(
         parentSchema,
         String(newIndex)
       );
+      if (!keywordLocationToken) {
+        return false;
+      }
       const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
       const itemPath = jsonPointerJoin(normalizedPath, String(newIndex));
       return this.setValue(itemPath, defaultValue);
@@ -2252,8 +2283,11 @@ var SchemaRuntime = class {
       if (!key) {
         return false;
       }
-      const { schema: subschema } = getSubSchema(parentSchema, key);
-      if (!parentSchema.additionalProperties) {
+      const { schema: subschema, keywordLocationToken } = getSubSchema(
+        parentSchema,
+        key
+      );
+      if (!keywordLocationToken) {
         return false;
       }
       const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
@@ -2326,56 +2360,69 @@ var SchemaRuntime = class {
     return this.root;
   }
   /**
-   * Build/update a FieldNode in place.
-   * Updates the node's schema, type, error, and children based on the current value.
-   * @param schema - Optional. If provided, updates node.originalSchema. Otherwise uses existing.
+   * Update node dependencies when schema changes.
+   * Unregisters old dependencies and registers new ones.
    */
-  buildNode(node, schema, options = {}) {
-    const { keywordLocation, instanceLocation } = node;
-    const value = this.getValue(instanceLocation);
-    if (value === void 0) {
-      const defaultValue = getDefaultValue(schema || node.originalSchema);
-      this.setValue(instanceLocation, defaultValue);
-      return;
+  updateNodeDependencies(node, schema) {
+    const { instanceLocation } = node;
+    node.originalSchema = schema;
+    const dependencies = collectDependencies(schema, instanceLocation);
+    for (const depPath of node.dependencies || []) {
+      this.unregisterDependent(depPath, node);
     }
-    if (this.updatingNodes.has(instanceLocation)) {
-      return;
+    node.dependencies = dependencies;
+    for (const depPath of dependencies) {
+      this.registerDependent(depPath, node);
     }
-    const updatedNodes = options.updatedNodes || /* @__PURE__ */ new Set();
-    if (updatedNodes.has(instanceLocation)) {
+  }
+  /**
+   * Apply default values when effective schema changes.
+   * This handles cases like if-then-else where new properties with defaults
+   * may appear when conditions change.
+   *
+   * @param instanceLocation - The path to the node
+   * @param newSchema - The new effective schema
+   * @param type - The schema type
+   */
+  applySchemaDefaults(instanceLocation, newSchema, type) {
+    const value = this.getValue(instanceLocation);
+    if (type === "object" && newSchema.properties) {
+      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;
+        if (!hasValue) {
+          const defaultValue = getDefaultValue(subschema);
+          if (defaultValue !== void 0) {
+            const propertyPath = jsonPointerJoin(instanceLocation, key);
+            setJsonPointer(this.value, propertyPath, defaultValue);
+          }
+        }
+      }
       return;
     }
-    this.updatingNodes.add(instanceLocation);
-    const schemaChanged = schema !== void 0 && !deepEqual(schema, node.originalSchema);
-    if (schemaChanged) {
-      node.originalSchema = schema;
-      const dependencies = this.collectDependencies(
-        node.originalSchema,
-        instanceLocation
-      );
-      for (const depPath of node.dependencies || []) {
-        this.unregisterDependent(depPath, node);
-      }
-      node.dependencies = dependencies;
-      if (!options.skipDependencyRegistration) {
-        for (const depPath of dependencies) {
-          this.registerDependent(depPath, node);
+    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 defaultValue = getDefaultValue(newSchema.prefixItems[i]);
+          if (defaultValue !== void 0) {
+            const itemPath = jsonPointerJoin(instanceLocation, String(i));
+            setJsonPointer(this.value, itemPath, defaultValue);
+          }
         }
       }
     }
-    const { type, effectiveSchema, error } = resolveEffectiveSchema(
-      this.validator,
-      node.originalSchema,
-      value,
-      keywordLocation,
-      instanceLocation
-    );
-    const effectiveSchemaChanged = !deepEqual(effectiveSchema, node.schema) || type !== node.type;
-    const errorChanged = !deepEqual(error, node.error);
-    node.schema = effectiveSchema;
-    node.type = type;
-    node.error = error;
-    node.version++;
+  }
+  /**
+   * Build children for object and array nodes.
+   * Reuses existing child nodes where possible.
+   */
+  buildNodeChildren(node, value, options) {
+    const { keywordLocation, instanceLocation } = node;
+    const effectiveSchema = node.schema;
+    const type = node.type;
     const oldChildrenMap = /* @__PURE__ */ new Map();
     if (node.children) {
       for (const child of node.children) {
@@ -2482,22 +2529,64 @@ var SchemaRuntime = class {
       this.unregisterNodeDependencies(oldChild);
     }
     node.children = newChildren;
-    if (effectiveSchemaChanged) {
-      this.notify({ type: "schema", path: node.instanceLocation });
-    }
-    if (errorChanged) {
-      this.notify({ type: "error", path: node.instanceLocation });
-    }
-    updatedNodes.add(instanceLocation);
-    this.updatingNodes.delete(instanceLocation);
-    const dependentNodes = this.dependentsMap.get(instanceLocation);
-    if (dependentNodes) {
-      for (const dependentNode of dependentNodes) {
-        this.buildNode(dependentNode, void 0, {
-          ...options,
-          updatedNodes
-        });
+  }
+  /**
+   * Build/update a FieldNode in place.
+   * Updates the node's schema, type, error, and children based on the current value.
+   * @param schema - Optional. If provided, updates node.originalSchema. Otherwise uses existing.
+   */
+  buildNode(node, schema, options = {}) {
+    const { keywordLocation, instanceLocation } = node;
+    const value = this.getValue(instanceLocation);
+    if (this.updatingNodes.has(instanceLocation)) {
+      return;
+    }
+    const updatedNodes = options.updatedNodes || /* @__PURE__ */ new Set();
+    if (updatedNodes.has(instanceLocation)) {
+      return;
+    }
+    this.updatingNodes.add(instanceLocation);
+    try {
+      const schemaChanged = schema !== void 0 && !deepEqual(schema, node.originalSchema);
+      if (schemaChanged) {
+        this.updateNodeDependencies(node, schema);
+      }
+      const { type, effectiveSchema, error } = resolveEffectiveSchema(
+        this.validator,
+        node.originalSchema,
+        value,
+        keywordLocation,
+        instanceLocation
+      );
+      const effectiveSchemaChanged = !deepEqual(effectiveSchema, node.schema) || type !== node.type;
+      const errorChanged = !deepEqual(error, node.error);
+      if (effectiveSchemaChanged) {
+        this.applySchemaDefaults(instanceLocation, effectiveSchema, type);
+      }
+      node.schema = effectiveSchema;
+      node.type = type;
+      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 });
+      }
+      updatedNodes.add(instanceLocation);
+      const dependentNodes = this.dependentsMap.get(instanceLocation);
+      if (dependentNodes) {
+        for (const dependentNode of dependentNodes) {
+          this.buildNode(dependentNode, void 0, {
+            ...options,
+            updatedNodes
+          });
+        }
       }
+    } finally {
+      this.updatingNodes.delete(instanceLocation);
     }
   }
 };
@@ -2507,11 +2596,14 @@ exports.MESSAGES = MESSAGES;
 exports.SchemaRuntime = SchemaRuntime;
 exports.StringFormatValidator = StringFormatValidator;
 exports.Validator = Validator;
+exports.collectDependencies = collectDependencies;
 exports.deepEqual = deepEqual;
 exports.defaultErrorFormatter = defaultErrorFormatter;
 exports.detectSchemaDraft = detectSchemaDraft;
 exports.detectSchemaType = detectSchemaType;
+exports.extractReferencedPaths = extractReferencedPaths;
 exports.get = get;
+exports.getDefaultValue = getDefaultValue;
 exports.getJsonPointer = getJsonPointer;
 exports.jsonPointerEscape = jsonPointerEscape;
 exports.jsonPointerJoin = jsonPointerJoin;