@schema-ts/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2529 @@
+'use strict';
+
+// src/util.ts
+function matchSchemaType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" || typeof value === "bigint";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    case "null":
+      return value === null || value === void 0;
+    default:
+      return false;
+  }
+}
+function detectSchemaType(value) {
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  const type = typeof value;
+  if (type === "string") {
+    return "string";
+  }
+  if (type === "boolean") {
+    return "boolean";
+  }
+  if (type === "number") {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  if (type === "bigint") {
+    return "number";
+  }
+  if (type === "object") {
+    return "object";
+  }
+  return "unknown";
+}
+function parseJsonPointer(jsonPointer) {
+  if (jsonPointer === "") return [];
+  const pointer = jsonPointer.charAt(0) === "/" ? jsonPointer.substring(1) : jsonPointer;
+  return pointer.split("/").map((t) => jsonPointerUnescape(decodeURIComponent(t)));
+}
+function getJsonPointer(obj, jsonPointer) {
+  return get(obj, parseJsonPointer(jsonPointer));
+}
+function removeJsonPointer(obj, jsonPointer) {
+  const path = parseJsonPointer(jsonPointer);
+  if (path.length === 0) {
+    return false;
+  }
+  if (obj === null || obj === void 0) {
+    return false;
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const segment = path[i];
+    if (Array.isArray(current)) {
+      const idx = Number(segment);
+      if (isNaN(idx) || idx < 0 || idx >= current.length) {
+        return false;
+      }
+      current = current[idx];
+    } else if (typeof current === "object" && current !== null) {
+      if (!Object.hasOwn(current, segment)) {
+        return false;
+      }
+      current = current[segment];
+    } else {
+      return false;
+    }
+    if (current === null || current === void 0) {
+      return false;
+    }
+  }
+  const lastSegment = path[path.length - 1];
+  if (Array.isArray(current)) {
+    const idx = Number(lastSegment);
+    if (isNaN(idx) || idx < 0 || idx >= current.length) {
+      return false;
+    }
+    current.splice(idx, 1);
+    return true;
+  } else if (typeof current === "object" && current !== null) {
+    if (Object.hasOwn(current, lastSegment)) {
+      delete current[lastSegment];
+      return true;
+    }
+  }
+  return false;
+}
+function setJsonPointer(obj, jsonPointer, value) {
+  const path = parseJsonPointer(jsonPointer);
+  if (path.length === 0) {
+    return false;
+  }
+  if (obj === null || obj === void 0) {
+    return false;
+  }
+  let current = obj;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    const isLast = i === path.length - 1;
+    if (Array.isArray(current)) {
+      const idx = Number(segment);
+      if (isNaN(idx) || idx < 0) {
+        return false;
+      }
+      if (idx >= current.length) {
+        for (let k = current.length; k <= idx; k++) current.push(void 0);
+      }
+      if (isLast) {
+        current[idx] = value;
+        return true;
+      }
+      if (current[idx] === null || current[idx] === void 0 || typeof current[idx] !== "object") {
+        const nextToken = path[i + 1];
+        const nextIdx = Number(nextToken);
+        current[idx] = !isNaN(nextIdx) ? [] : {};
+      }
+      current = current[idx];
+    } else if (typeof current === "object" && current !== null) {
+      if (isLast) {
+        current[segment] = value;
+        return true;
+      }
+      if (!Object.hasOwn(current, segment) || current[segment] === void 0) {
+        const nextToken = path[i + 1];
+        const nextIdx = Number(nextToken);
+        current[segment] = !isNaN(nextIdx) ? [] : {};
+      }
+      current = current[segment];
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+function get(obj, path) {
+  let current = obj;
+  for (const segment of path) {
+    if (Array.isArray(current)) {
+      const currentIndex = Number(segment);
+      if (isNaN(currentIndex) || currentIndex < 0 || currentIndex >= current.length) {
+        return void 0;
+      } else {
+        current = current[currentIndex];
+      }
+    } else if (typeof current === "object" && current !== null) {
+      if (!Object.hasOwn(current, segment)) {
+        return void 0;
+      } else {
+        current = current[segment];
+      }
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof Date || b instanceof Date) {
+    return false;
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (a instanceof RegExp || b instanceof RegExp) {
+    return false;
+  }
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [key, value] of a) {
+      if (!b.has(key) || !deepEqual(value, b.get(key))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (a instanceof Map || b instanceof Map) {
+    return false;
+  }
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const value of a) {
+      let found = false;
+      for (const bValue of b) {
+        if (deepEqual(value, bValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+    return true;
+  }
+  if (a instanceof Set || b instanceof Set) {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const arrA = a;
+    const arrB = b;
+    if (arrA.length !== arrB.length) return false;
+    for (let i = 0; i < arrA.length; i++) {
+      if (!deepEqual(arrA[i], arrB[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.hasOwn(b, key)) return false;
+    if (!deepEqual(
+      a[key],
+      b[key]
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+function jsonPointerEscape(str) {
+  return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function jsonPointerUnescape(str) {
+  return str.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function jsonPointerJoin(base, token) {
+  if (base === "") return "/" + jsonPointerEscape(token);
+  else return base + "/" + jsonPointerEscape(token);
+}
+function resolveAbsolutePath(nodePath, relativePath) {
+  if (relativePath.startsWith("/")) {
+    return nodePath === "" ? relativePath : nodePath + relativePath;
+  }
+  return relativePath;
+}
+var MAX_REGEX_CACHE_SIZE = 1e3;
+var regexCache = /* @__PURE__ */ new Map();
+function safeRegexTest(pattern, value) {
+  let regex = regexCache.get(pattern);
+  if (regex === void 0) {
+    try {
+      regex = new RegExp(pattern);
+      if (regexCache.size >= MAX_REGEX_CACHE_SIZE) {
+        const firstKey = regexCache.keys().next().value;
+        if (firstKey !== void 0) {
+          regexCache.delete(firstKey);
+        }
+      }
+      regexCache.set(pattern, regex);
+    } catch {
+      regexCache.set(pattern, null);
+      return false;
+    }
+  }
+  if (regex === null) {
+    return false;
+  }
+  return regex.test(value);
+}
+
+// src/stringformat.ts
+var DATE_RE = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/;
+var DURATION_RE = /^P(\d+Y)?(\d+M)?(\d+W)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/;
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var HOSTNAME_RE = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]*[A-Za-z0-9])$/;
+var IPV4_RE = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var IPV6_RE = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(([0-9a-fA-F]{1,4}:){1,7}:)|(([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4})|(([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2})|(([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3})|(([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4})|(([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5})|([0-9a-fA-F]{1,4}:)((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9]))$/;
+var RFC3339_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+var UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+var StringFormatValidator = class {
+  validate(format, value) {
+    switch (format) {
+      case "date-time":
+        return this.isDateTime(value);
+      case "date":
+        return this.isDate(value);
+      case "email":
+        return this.isEmail(value);
+      case "hostname":
+        return this.isHostname(value);
+      case "ipv4":
+        return this.isIPv4(value);
+      case "ipv6":
+        return this.isIPv6(value);
+      case "uri":
+        return this.isUri(value);
+      case "uuid":
+        return this.isUuid(value);
+      case "duration":
+        return this.isDuration(value);
+      default:
+        return true;
+    }
+  }
+  isDateTime(value) {
+    if (!RFC3339_RE.test(value)) return false;
+    return !isNaN(Date.parse(value));
+  }
+  isDate(value) {
+    const m = DATE_RE.exec(value);
+    if (!m) return false;
+    const year = Number(m[1]), month = Number(m[2]), day = Number(m[3]), daysInMonth = [
+      31,
+      year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+      31,
+      30,
+      31,
+      30,
+      31,
+      31,
+      30,
+      31,
+      30,
+      31
+    ];
+    return day <= daysInMonth[month - 1];
+  }
+  isEmail(value) {
+    return EMAIL_RE.test(value);
+  }
+  isHostname(value) {
+    return HOSTNAME_RE.test(value);
+  }
+  isIPv4(value) {
+    return IPV4_RE.test(value);
+  }
+  isIPv6(value) {
+    return IPV6_RE.test(value);
+  }
+  isUri(value) {
+    try {
+      const u = new URL(value);
+      return typeof u.protocol === "string" && u.protocol.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  isUuid(value) {
+    return UUID_RE.test(value);
+  }
+  isDuration(value) {
+    return DURATION_RE.test(value) && value !== "P";
+  }
+};
+var stringFormatValidator = new StringFormatValidator();
+
+// src/i18n.ts
+var MESSAGES = {
+  "validation.anyOf": "must match at least one schema",
+  "validation.oneOf": "must match exactly one schema, matched {count}",
+  "validation.not": "must not match schema",
+  "validation.const": "must be equal to {value}",
+  "validation.enum": "must be equal to one of the allowed values",
+  "validation.type": "must be {expected}",
+  "validation.maximum": "must be <= {value}",
+  "validation.exclusiveMaximum": "must be < {value}",
+  "validation.minimum": "must be >= {value}",
+  "validation.exclusiveMinimum": "must be > {value}",
+  "validation.multipleOf": "must be multiple of {value}",
+  "validation.maxLength": "must be shorter than or equal to {value} characters",
+  "validation.minLength": "must be longer than or equal to {value} characters",
+  "validation.pattern": 'must match pattern "{pattern}"',
+  "validation.format": 'must match format "{format}"',
+  "validation.maxItems": "must have at most {value} items",
+  "validation.minItems": "must have at least {value} items",
+  "validation.uniqueItems": "must not contain duplicate items",
+  "validation.contains": "must contain at least one valid item",
+  "validation.minContains": "must contain at least {value} valid items",
+  "validation.maxContains": "must contain at most {value} valid items",
+  "validation.maxProperties": "must have at most {value} properties",
+  "validation.minProperties": "must have at least {value} properties",
+  "validation.required": "must have required property '{property}'",
+  "validation.dependentRequired": "property '{source}' requires property '{target}'",
+  "validation.additionalProperties": "must not have additional properties: {properties}",
+  "validation.failed": "validation failed"
+};
+var defaultErrorFormatter = (msg) => {
+  const template = MESSAGES[msg.key] ?? msg.key;
+  if (!msg.params) return template;
+  let result = template;
+  for (const [k, v] of Object.entries(msg.params)) {
+    const value = typeof v === "object" && v !== null ? JSON.stringify(v) : String(v);
+    result = result.replace(`{${k}}`, value);
+  }
+  return result;
+};
+
+// src/version.ts
+var DRAFT_URIS = {
+  "draft-04": [
+    "http://json-schema.org/draft-04/schema#",
+    "http://json-schema.org/draft-04/schema"
+  ],
+  "draft-07": [
+    "http://json-schema.org/draft-07/schema#",
+    "http://json-schema.org/draft-07/schema"
+  ],
+  "draft-2019-09": [
+    "https://json-schema.org/draft/2019-09/schema",
+    "https://json-schema.org/draft/2019-09/schema#"
+  ],
+  "draft-2020-12": [
+    "https://json-schema.org/draft/2020-12/schema",
+    "https://json-schema.org/draft/2020-12/schema#"
+  ]
+};
+function detectSchemaDraft(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return "draft-2020-12";
+  }
+  const s = schema;
+  if (s.$schema && typeof s.$schema === "string") {
+    for (const [draft, uris] of Object.entries(DRAFT_URIS)) {
+      if (uris.some((uri) => s.$schema === uri)) {
+        return draft;
+      }
+    }
+  }
+  if ("prefixItems" in s) {
+    return "draft-2020-12";
+  }
+  if ("$recursiveRef" in s || "$recursiveAnchor" in s || "unevaluatedProperties" in s || "unevaluatedItems" in s) {
+    return "draft-2019-09";
+  }
+  if ("id" in s && !("$id" in s)) {
+    return "draft-04";
+  }
+  if (typeof s.exclusiveMaximum === "boolean" || typeof s.exclusiveMinimum === "boolean") {
+    return "draft-04";
+  }
+  if ("dependencies" in s) {
+    if ("$id" in s) {
+      return "draft-07";
+    }
+    return "draft-04";
+  }
+  if ("additionalItems" in s) {
+    if ("$id" in s) {
+      return "draft-07";
+    }
+    return "draft-04";
+  }
+  return "draft-2020-12";
+}
+
+// src/normalize.ts
+function normalizeSchema(schema, options = {}) {
+  if (typeof schema === "boolean") {
+    return schema ? {} : { not: {} };
+  }
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return {};
+  }
+  const schemaObj = schema;
+  const sourceDraft = options.sourceDraft ?? detectSchemaDraft(schemaObj);
+  const normalized = { ...schemaObj };
+  switch (sourceDraft) {
+    case "draft-04":
+      normalizeDraft04(normalized);
+      normalizeDraft07(normalized);
+      normalizeDraft201909(normalized);
+      break;
+    case "draft-07":
+      normalizeDraft07(normalized);
+      normalizeDraft201909(normalized);
+      break;
+    case "draft-2019-09":
+      normalizeDraft07(normalized);
+      normalizeDraft201909(normalized);
+      break;
+  }
+  normalizeGeneral(normalized);
+  normalizeNestedSchemas(normalized, options);
+  if (normalized.$schema) {
+    normalized.$schema = "https://json-schema.org/draft/2020-12/schema";
+  }
+  return normalized;
+}
+function normalizeDraft04(schema) {
+  const legacy = schema;
+  if ("id" in legacy && !("$id" in schema)) {
+    schema.$id = legacy.id;
+    delete legacy.id;
+  }
+  if ("$ref" in schema) {
+    for (const key of Object.keys(schema)) {
+      if (key !== "$ref" && key !== "$schema" && key !== "id" && key !== "$id" && key !== "$comment") {
+        delete legacy[key];
+      }
+    }
+  }
+  if (typeof legacy.exclusiveMaximum === "boolean" && legacy.exclusiveMaximum === true) {
+    if (schema.maximum !== void 0) {
+      schema.exclusiveMaximum = schema.maximum;
+      delete schema.maximum;
+    } else {
+      delete legacy.exclusiveMaximum;
+    }
+  }
+  if (typeof legacy.exclusiveMinimum === "boolean" && legacy.exclusiveMinimum === true) {
+    if (schema.minimum !== void 0) {
+      schema.exclusiveMinimum = schema.minimum;
+      delete schema.minimum;
+    } else {
+      delete legacy.exclusiveMinimum;
+    }
+  }
+  if (legacy.exclusiveMaximum === false) {
+    delete legacy.exclusiveMaximum;
+  }
+  if (legacy.exclusiveMinimum === false) {
+    delete legacy.exclusiveMinimum;
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length === 1 && schema.const === void 0) {
+    schema.const = schema.enum[0];
+  }
+}
+function normalizeDraft07(schema) {
+  const legacy = schema;
+  if (Array.isArray(legacy.items)) {
+    schema.prefixItems = legacy.items;
+    if ("additionalItems" in legacy) {
+      if (typeof legacy.additionalItems === "object" || typeof legacy.additionalItems === "boolean") {
+        schema.items = legacy.additionalItems;
+      }
+      delete legacy.additionalItems;
+    } else {
+      delete legacy.items;
+    }
+  } else if ("additionalItems" in legacy) {
+    delete legacy.additionalItems;
+  }
+  if ("dependencies" in legacy) {
+    const deps = legacy.dependencies;
+    for (const [prop, value] of Object.entries(deps)) {
+      if (Array.isArray(value)) {
+        if (!schema.dependentRequired) {
+          schema.dependentRequired = {};
+        }
+        schema.dependentRequired[prop] = value;
+      } else {
+        if (!schema.dependentSchemas) {
+          schema.dependentSchemas = {};
+        }
+        schema.dependentSchemas[prop] = value;
+      }
+    }
+    delete legacy.dependencies;
+  }
+}
+function normalizeGeneral(schema) {
+  const legacy = schema;
+  if (legacy.nullable === true) {
+    if (typeof schema.type === "string") {
+      schema.type = [schema.type, "null"];
+    } else if (Array.isArray(schema.type)) {
+      if (!schema.type.includes("null")) {
+        schema.type = [...schema.type, "null"];
+      }
+    }
+    delete legacy.nullable;
+  }
+  if ("example" in legacy) {
+    if (!("examples" in schema)) {
+      schema.examples = [legacy.example];
+    }
+    delete legacy.example;
+  }
+}
+function normalizeDraft201909(schema) {
+  if ("$recursiveRef" in schema) {
+    let ref = schema.$recursiveRef;
+    if (ref === "#") {
+      ref = "#recursiveAnchor";
+    }
+    schema.$dynamicRef = ref;
+    delete schema.$recursiveRef;
+  }
+  if ("$recursiveAnchor" in schema) {
+    if (schema.$recursiveAnchor === true) {
+      schema.$dynamicAnchor = schema.$dynamicAnchor ?? "recursiveAnchor";
+    }
+    delete schema.$recursiveAnchor;
+  }
+}
+function normalizeNestedSchemas(schema, options) {
+  if (schema.$defs) {
+    schema.$defs = Object.fromEntries(
+      Object.entries(schema.$defs).map(([key, subSchema]) => [
+        key,
+        normalizeSchema(subSchema, options)
+      ])
+    );
+  }
+  if ("definitions" in schema) {
+    const defs = schema.definitions;
+    if (!schema.$defs) {
+      schema.$defs = {};
+    }
+    for (const [key, subSchema] of Object.entries(defs)) {
+      schema.$defs[key] = normalizeSchema(subSchema, options);
+    }
+    delete schema.definitions;
+  }
+  if (schema.properties) {
+    schema.properties = Object.fromEntries(
+      Object.entries(schema.properties).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)
+      ])
+    );
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    schema.additionalProperties = normalizeSchema(
+      schema.additionalProperties,
+      options
+    );
+  }
+  if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+    schema.items = normalizeSchema(schema.items, options);
+  }
+  if (schema.prefixItems) {
+    schema.prefixItems = schema.prefixItems.map(
+      (s) => normalizeSchema(s, options)
+    );
+  }
+  if (schema.contains) {
+    schema.contains = normalizeSchema(schema.contains, options);
+  }
+  if (schema.allOf) {
+    schema.allOf = schema.allOf.map((s) => normalizeSchema(s, options));
+  }
+  if (schema.anyOf) {
+    schema.anyOf = schema.anyOf.map((s) => normalizeSchema(s, options));
+  }
+  if (schema.oneOf) {
+    schema.oneOf = schema.oneOf.map((s) => normalizeSchema(s, options));
+  }
+  if (schema.not) {
+    schema.not = normalizeSchema(schema.not, options);
+  }
+  if (schema.if) {
+    schema.if = normalizeSchema(schema.if, options);
+  }
+  if (schema.then) {
+    schema.then = normalizeSchema(schema.then, options);
+  }
+  if (schema.else) {
+    schema.else = normalizeSchema(schema.else, options);
+  }
+  if (schema.dependentSchemas) {
+    schema.dependentSchemas = Object.fromEntries(
+      Object.entries(schema.dependentSchemas).map(([key, subSchema]) => [
+        key,
+        normalizeSchema(subSchema, options)
+      ])
+    );
+  }
+  if (schema.unevaluatedItems) {
+    schema.unevaluatedItems = normalizeSchema(schema.unevaluatedItems, options);
+  }
+  if (schema.unevaluatedProperties) {
+    schema.unevaluatedProperties = normalizeSchema(
+      schema.unevaluatedProperties,
+      options
+    );
+  }
+  if (schema.propertyNames) {
+    schema.propertyNames = normalizeSchema(schema.propertyNames, options);
+  }
+  if (schema.contentSchema) {
+    schema.contentSchema = normalizeSchema(schema.contentSchema, options);
+  }
+}
+
+// src/validate.ts
+var Validator = class {
+  formatValidator;
+  errorFormatter;
+  constructor(config = {}) {
+    this.formatValidator = config.formatValidator ?? stringFormatValidator;
+    this.errorFormatter = config.errorFormatter ?? defaultErrorFormatter;
+  }
+  /**
+   * Format an ErrorMessage to a localized string.
+   */
+  formatError(msg) {
+    return this.errorFormatter(msg);
+  }
+  validate(schema, value, keywordLocation = "#", instanceLocation = "", options = {}) {
+    const { fastFail = false } = options;
+    const output = {
+      valid: false,
+      keywordLocation,
+      absoluteKeywordLocation: keywordLocation,
+      instanceLocation,
+      absoluteInstanceLocation: instanceLocation,
+      errors: []
+    };
+    if (schema.if) {
+      const ifResult = this.validate(
+        schema.if,
+        value,
+        keywordLocation + `/if`,
+        `${instanceLocation}`,
+        options
+      );
+      if (ifResult.valid) {
+        if (schema.then) {
+          const thenResult = this.validate(
+            schema.then,
+            value,
+            keywordLocation + `/then`,
+            instanceLocation,
+            options
+          );
+          if (!thenResult.valid) {
+            output.errors.push(...thenResult.errors || []);
+            if (fastFail) return output;
+          }
+        }
+      } else if (schema.else) {
+        const elseResult = this.validate(
+          schema.else,
+          value,
+          keywordLocation + `/else`,
+          instanceLocation,
+          options
+        );
+        if (!elseResult.valid) {
+          output.errors.push(...elseResult.errors || []);
+          if (fastFail) return output;
+        }
+      }
+    }
+    if (schema.allOf) {
+      for (let index = 0; index < schema.allOf.length; index++) {
+        const subSchema = schema.allOf[index];
+        const result = this.validate(
+          subSchema,
+          value,
+          keywordLocation + `/allOf/${index}`,
+          instanceLocation,
+          options
+        );
+        if (!result.valid) {
+          output.errors.push(...result.errors || []);
+          if (fastFail) return output;
+        }
+      }
+    }
+    if (schema.anyOf) {
+      let hasValid = false;
+      const errors = [];
+      for (let index = 0; index < schema.anyOf.length; index++) {
+        const subSchema = schema.anyOf[index];
+        const result = this.validate(
+          subSchema,
+          value,
+          keywordLocation + `/anyOf/${index}`,
+          instanceLocation,
+          options
+        );
+        if (result.valid) {
+          hasValid = true;
+          break;
+        } else {
+          errors.push(...result.errors || []);
+        }
+      }
+      if (!hasValid) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/anyOf`,
+          instanceLocation,
+          errors,
+          error: this.formatError({ key: "validation.anyOf" })
+        });
+        if (fastFail) return output;
+      }
+    }
+    if (schema.oneOf) {
+      const results = schema.oneOf.map(
+        (subSchema, index) => this.validate(
+          subSchema,
+          value,
+          keywordLocation + `/oneOf/${index}`,
+          instanceLocation,
+          options
+        )
+      ), validCount = results.filter((r) => r.valid).length;
+      if (validCount !== 1) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/oneOf`,
+          instanceLocation,
+          errors: [],
+          annotations: results,
+          error: this.formatError({
+            key: "validation.oneOf",
+            params: { count: validCount }
+          })
+        });
+        if (fastFail) return output;
+      }
+    }
+    if (schema.not) {
+      const result = this.validate(
+        schema.not,
+        value,
+        keywordLocation + `/not`,
+        instanceLocation,
+        options
+      );
+      if (result.valid) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/not`,
+          instanceLocation,
+          errors: [],
+          annotations: [result],
+          error: this.formatError({ key: "validation.not" })
+        });
+        if (fastFail) return output;
+      }
+    }
+    if (schema.const !== void 0) {
+      if (!deepEqual(value, schema.const)) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/const`,
+          instanceLocation,
+          errors: [],
+          error: this.formatError({
+            key: "validation.const",
+            params: { value: schema.const }
+          })
+        });
+        if (fastFail) return output;
+      }
+    }
+    if (schema.enum) {
+      if (!schema.enum.some((v) => deepEqual(value, v))) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/enum`,
+          instanceLocation,
+          errors: [],
+          error: this.formatError({ key: "validation.enum" })
+        });
+        if (fastFail) return output;
+      }
+    }
+    let instanceType = "";
+    if (schema.type) {
+      const allowedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+      for (const type of allowedTypes) {
+        if (this.checkType(value, type)) {
+          instanceType = type;
+          break;
+        }
+      }
+      if (!instanceType) {
+        output.errors.push({
+          valid: false,
+          keywordLocation: `${keywordLocation}/type`,
+          instanceLocation,
+          errors: [],
+          error: this.formatError({
+            key: "validation.type",
+            params: { expected: allowedTypes.join(" or ") }
+          })
+        });
+        if (fastFail) return output;
+      }
+    } else {
+      instanceType = this.detectType(value);
+    }
+    if (instanceType === "object") {
+      this.validateObject(
+        schema,
+        value,
+        instanceLocation,
+        keywordLocation,
+        output,
+        options
+      );
+    } else if (instanceType === "array") {
+      this.validateArray(
+        schema,
+        value,
+        keywordLocation,
+        instanceLocation,
+        output,
+        options
+      );
+    } else if (instanceType === "string") {
+      this.validateString(
+        schema,
+        value,
+        keywordLocation,
+        instanceLocation,
+        output,
+        options
+      );
+    } else if (instanceType === "number") {
+      this.validateNumber(
+        schema,
+        value,
+        keywordLocation,
+        instanceLocation,
+        output,
+        options
+      );
+    }
+    output.valid = output.errors.length == 0;
+    output.error = output.valid ? void 0 : this.formatError({ key: "validation.failed" });
+    return output;
+  }
+  validateNumber(schema, value, keywordLocation, instanceLocation, output, options) {
+    const { fastFail = false } = options;
+    const addError = (keyword, msg) => {
+      output.errors.push({
+        valid: false,
+        keywordLocation: `${keywordLocation}/${keyword}`,
+        instanceLocation,
+        errors: [],
+        error: this.formatError(msg)
+      });
+    };
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      addError("maximum", {
+        key: "validation.maximum",
+        params: { value: schema.maximum }
+      });
+      if (fastFail) return;
+    }
+    if (schema.exclusiveMaximum !== void 0 && value >= schema.exclusiveMaximum) {
+      addError("exclusiveMaximum", {
+        key: "validation.exclusiveMaximum",
+        params: { value: schema.exclusiveMaximum }
+      });
+      if (fastFail) return;
+    }
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      addError("minimum", {
+        key: "validation.minimum",
+        params: { value: schema.minimum }
+      });
+      if (fastFail) return;
+    }
+    if (schema.exclusiveMinimum !== void 0 && value <= schema.exclusiveMinimum) {
+      addError("exclusiveMinimum", {
+        key: "validation.exclusiveMinimum",
+        params: { value: schema.exclusiveMinimum }
+      });
+      if (fastFail) return;
+    }
+    if (schema.multipleOf !== void 0) {
+      const remainder = value % schema.multipleOf;
+      if (Math.abs(remainder) > 1e-5 && Math.abs(remainder - schema.multipleOf) > 1e-5) {
+        addError("multipleOf", {
+          key: "validation.multipleOf",
+          params: { value: schema.multipleOf }
+        });
+        if (fastFail) return;
+      }
+    }
+  }
+  validateString(schema, value, keywordLocation, instanceLocation, output, options) {
+    const { fastFail = false } = options;
+    const addError = (keyword, msg) => {
+      output.errors.push({
+        valid: false,
+        keywordLocation: `${keywordLocation}/${keyword}`,
+        instanceLocation,
+        errors: [],
+        error: this.formatError(msg)
+      });
+    }, { length } = [...value];
+    if (schema.maxLength !== void 0 && length > schema.maxLength) {
+      addError("maxLength", {
+        key: "validation.maxLength",
+        params: { value: schema.maxLength }
+      });
+      if (fastFail) return;
+    }
+    if (schema.minLength !== void 0 && length < schema.minLength) {
+      addError("minLength", {
+        key: "validation.minLength",
+        params: { value: schema.minLength }
+      });
+      if (fastFail) return;
+    }
+    if (schema.pattern !== void 0) {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(value)) {
+        addError("pattern", {
+          key: "validation.pattern",
+          params: { pattern: schema.pattern }
+        });
+        if (fastFail) return;
+      }
+    }
+    if (schema.format !== void 0) {
+      if (!this.validateFormat(schema.format, value)) {
+        addError("format", {
+          key: "validation.format",
+          params: { format: schema.format }
+        });
+        if (fastFail) return;
+      }
+    }
+  }
+  validateArray(schema, value, keywordLocation, instanceLocation, output, options) {
+    const { fastFail = false, shallow = false } = options;
+    const addError = (keyword, msg) => {
+      output.errors.push({
+        valid: false,
+        keywordLocation: `${keywordLocation}/${keyword}`,
+        instanceLocation,
+        errors: [],
+        error: this.formatError(msg)
+      });
+    };
+    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+      addError("maxItems", {
+        key: "validation.maxItems",
+        params: { value: schema.maxItems }
+      });
+      if (fastFail) return;
+    }
+    if (schema.minItems !== void 0 && value.length < schema.minItems) {
+      addError("minItems", {
+        key: "validation.minItems",
+        params: { value: schema.minItems }
+      });
+      if (fastFail) return;
+    }
+    if (schema.uniqueItems) {
+      for (let i = 0; i < value.length; i++) {
+        for (let j = i + 1; j < value.length; j++) {
+          if (deepEqual(value[i], value[j])) {
+            addError("uniqueItems", { key: "validation.uniqueItems" });
+            return;
+          }
+        }
+      }
+    }
+    let prefixItemsLength = 0;
+    if (schema.prefixItems) {
+      prefixItemsLength = schema.prefixItems.length;
+      for (let index = 0; index < schema.prefixItems.length; index++) {
+        const itemSchema = schema.prefixItems[index];
+        if (index < value.length) {
+          if (!shallow) {
+            const result = this.validate(
+              itemSchema,
+              value[index],
+              `${keywordLocation}/prefixItems/${index}`,
+              `${instanceLocation}/${index}`,
+              options
+            );
+            if (!result.valid) {
+              output.errors.push(result);
+              if (fastFail) return;
+            }
+          }
+        }
+      }
+    }
+    if (schema.items && value.length > prefixItemsLength) {
+      for (let i = prefixItemsLength; i < value.length; i++) {
+        if (!shallow) {
+          const result = this.validate(
+            schema.items,
+            value[i],
+            `${keywordLocation}/items`,
+            `${instanceLocation}/${i}`,
+            options
+          );
+          if (!result.valid) {
+            output.errors.push(result);
+            if (fastFail) return;
+          }
+        }
+      }
+    }
+    if (schema.contains) {
+      let containsCount = 0;
+      for (let i = 0; i < value.length; i++) {
+        const result = this.validate(
+          schema.contains,
+          value[i],
+          `${keywordLocation}/contains`,
+          `${instanceLocation}/${i}`,
+          options
+        );
+        if (result.valid) {
+          containsCount++;
+        }
+      }
+      if (schema.minContains !== void 0) {
+        if (containsCount < schema.minContains) {
+          addError("minContains", {
+            key: "validation.minContains",
+            params: { value: schema.minContains }
+          });
+          if (fastFail) return;
+        }
+      } else if (schema.minContains === void 0 && containsCount === 0) {
+        addError("contains", { key: "validation.contains" });
+        if (fastFail) return;
+      }
+      if (schema.maxContains !== void 0) {
+        if (containsCount > schema.maxContains) {
+          addError("maxContains", {
+            key: "validation.maxContains",
+            params: { value: schema.maxContains }
+          });
+          if (fastFail) return;
+        }
+      }
+    }
+  }
+  validateObject(schema, value, keywordLocation, instanceLocation, output, options) {
+    const { fastFail = false, shallow = false } = options;
+    const addError = (keyword, msg) => {
+      output.errors.push({
+        valid: false,
+        keywordLocation: `${keywordLocation}/${keyword}`,
+        instanceLocation,
+        errors: [],
+        error: this.formatError(msg)
+      });
+    }, keys = Object.keys(value);
+    if (schema.maxProperties !== void 0 && keys.length > schema.maxProperties) {
+      addError("maxProperties", {
+        key: "validation.maxProperties",
+        params: { value: schema.maxProperties }
+      });
+      if (fastFail) return;
+    }
+    if (schema.minProperties !== void 0 && keys.length < schema.minProperties) {
+      addError("minProperties", {
+        key: "validation.minProperties",
+        params: { value: schema.minProperties }
+      });
+      if (fastFail) return;
+    }
+    if (schema.required) {
+      for (const req of schema.required) {
+        if (!(req in value)) {
+          addError("required", {
+            key: "validation.required",
+            params: { property: req }
+          });
+          if (fastFail) return;
+        }
+      }
+    }
+    if (schema.dependentRequired) {
+      for (const [prop, requiredProps] of Object.entries(
+        schema.dependentRequired
+      )) {
+        if (prop in value) {
+          for (const req of requiredProps) {
+            if (!(req in value)) {
+              addError("dependentRequired", {
+                key: "validation.dependentRequired",
+                params: { source: prop, target: req }
+              });
+              if (fastFail) return;
+            }
+          }
+        }
+      }
+    }
+    const validatedKeys = /* @__PURE__ */ new Set();
+    if (schema.properties) {
+      for (const [prop, propSchema] of Object.entries(schema.properties)) {
+        if (prop in value) {
+          validatedKeys.add(prop);
+          if (!shallow) {
+            const result = this.validate(
+              propSchema,
+              value[prop],
+              `${keywordLocation}/properties/${prop}`,
+              `${instanceLocation}/${prop}`,
+              options
+            );
+            if (!result.valid) {
+              output.errors.push(result);
+              if (fastFail) return;
+            }
+          }
+        }
+      }
+    }
+    if (schema.patternProperties) {
+      for (const [pattern, propSchema] of Object.entries(
+        schema.patternProperties
+      )) {
+        const regex = new RegExp(pattern);
+        for (const key of keys) {
+          if (regex.test(key)) {
+            validatedKeys.add(key);
+            if (!shallow) {
+              const result = this.validate(
+                propSchema,
+                value[key],
+                `${keywordLocation}/patternProperties/${jsonPointerEscape(pattern)}`,
+                `${instanceLocation}/${jsonPointerEscape(key)}`,
+                options
+              );
+              if (!result.valid) {
+                output.errors.push(...result.errors || []);
+                if (fastFail) return;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (schema.additionalProperties !== void 0) {
+      const additionalKeys = keys.filter((k) => !validatedKeys.has(k));
+      if (typeof schema.additionalProperties === "boolean") {
+        if (!schema.additionalProperties && additionalKeys.length > 0) {
+          addError("additionalProperties", {
+            key: "validation.additionalProperties",
+            params: { properties: additionalKeys.join(", ") }
+          });
+          if (fastFail) return;
+        }
+      } else {
+        for (const key of additionalKeys) {
+          if (!shallow) {
+            const result = this.validate(
+              schema.additionalProperties,
+              value[key],
+              `${keywordLocation}/additionalProperties`,
+              `${instanceLocation}/${jsonPointerEscape(key)}`,
+              options
+            );
+            if (!result.valid) {
+              output.errors.push(result);
+              if (fastFail) return;
+            }
+          }
+        }
+      }
+    }
+    if (schema.propertyNames) {
+      for (const key of keys) {
+        const result = this.validate(
+          schema.propertyNames,
+          key,
+          `${keywordLocation}/propertyNames`,
+          `${instanceLocation}/${jsonPointerEscape(key)}`,
+          options
+        );
+        if (!result.valid) {
+          output.errors.push(result);
+          if (fastFail) return;
+        }
+      }
+    }
+    if (schema.dependentSchemas) {
+      for (const [prop, depSchema] of Object.entries(schema.dependentSchemas)) {
+        if (prop in value) {
+          const result = this.validate(
+            depSchema,
+            value,
+            `${keywordLocation}/dependentSchemas/${jsonPointerEscape(prop)}`,
+            instanceLocation,
+            options
+          );
+          if (!result.valid) {
+            output.errors.push(result);
+            if (fastFail) return;
+          }
+        }
+      }
+    }
+  }
+  detectType(value) {
+    if (value === null || value === void 0) return "null";
+    if (Array.isArray(value)) return "array";
+    if (Number.isInteger(value)) return "integer";
+    return typeof value;
+  }
+  checkType(value, type) {
+    return matchSchemaType(value, type);
+  }
+  validateFormat(format, value) {
+    return this.formatValidator.validate(format, value);
+  }
+};
+function validateSchema(schema, value, instancePath = "", schemaPath = "#", fastFail = false) {
+  const normalizedSchema = normalizeSchema(schema);
+  const validator = new Validator();
+  return validator.validate(normalizedSchema, value, schemaPath, instancePath, {
+    fastFail
+  });
+}
+
+// src/schema-util.ts
+var schemaUtilLogger = {
+  warn: (message) => console.warn(message)
+};
+function resolveRef(ref, rootSchema, visited = /* @__PURE__ */ new Set()) {
+  if (!ref.startsWith("#")) {
+    schemaUtilLogger?.warn(`External $ref not supported: ${ref}`);
+    return void 0;
+  }
+  if (visited.has(ref)) {
+    schemaUtilLogger?.warn(`Circular $ref detected: ${ref}`);
+    return void 0;
+  }
+  visited.add(ref);
+  const pointer = ref.slice(1);
+  if (pointer === "" || pointer === "/") {
+    return rootSchema;
+  }
+  const segments = parseJsonPointer(pointer);
+  let current = rootSchema;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  if (current === null || current === void 0) {
+    return void 0;
+  }
+  const resolved = current;
+  if (resolved.$ref) {
+    return resolveRef(resolved.$ref, rootSchema, visited);
+  }
+  return resolved;
+}
+function dereferenceSchema(schema, rootSchema) {
+  if (!schema.$ref) {
+    return schema;
+  }
+  const resolved = resolveRef(schema.$ref, rootSchema);
+  if (!resolved) {
+    const { $ref: _2, ...rest } = schema;
+    return rest;
+  }
+  const { $ref: _, ...siblings } = schema;
+  return mergeSchema(resolved, siblings);
+}
+function dereferenceSchemaDeep(schema, rootSchema, processed = /* @__PURE__ */ new WeakMap(), inProgress = /* @__PURE__ */ new WeakSet()) {
+  const cached = processed.get(schema);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (inProgress.has(schema)) {
+    return schema;
+  }
+  inProgress.add(schema);
+  let result = dereferenceSchema(schema, rootSchema);
+  if (result === schema) {
+    result = { ...schema };
+  }
+  if (result.properties) {
+    result.properties = Object.fromEntries(
+      Object.entries(result.properties).map(([key, subSchema]) => [
+        key,
+        dereferenceSchemaDeep(subSchema, rootSchema, processed, inProgress)
+      ])
+    );
+  }
+  if (result.patternProperties) {
+    result.patternProperties = Object.fromEntries(
+      Object.entries(result.patternProperties).map(([key, subSchema]) => [
+        key,
+        dereferenceSchemaDeep(subSchema, rootSchema, processed, inProgress)
+      ])
+    );
+  }
+  if (result.additionalProperties && typeof result.additionalProperties === "object") {
+    result.additionalProperties = dereferenceSchemaDeep(
+      result.additionalProperties,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.items) {
+    result.items = dereferenceSchemaDeep(
+      result.items,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.prefixItems) {
+    result.prefixItems = result.prefixItems.map(
+      (s) => dereferenceSchemaDeep(s, rootSchema, processed, inProgress)
+    );
+  }
+  if (result.contains) {
+    result.contains = dereferenceSchemaDeep(
+      result.contains,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
+    const subSchemas = result[keyword];
+    if (subSchemas) {
+      result[keyword] = subSchemas.map(
+        (s) => dereferenceSchemaDeep(s, rootSchema, processed, inProgress)
+      );
+    }
+  }
+  if (result.not) {
+    result.not = dereferenceSchemaDeep(
+      result.not,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.if) {
+    result.if = dereferenceSchemaDeep(
+      result.if,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.then) {
+    result.then = dereferenceSchemaDeep(
+      result.then,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.else) {
+    result.else = dereferenceSchemaDeep(
+      result.else,
+      rootSchema,
+      processed,
+      inProgress
+    );
+  }
+  if (result.dependentSchemas) {
+    result.dependentSchemas = Object.fromEntries(
+      Object.entries(result.dependentSchemas).map(([key, subSchema]) => [
+        key,
+        dereferenceSchemaDeep(subSchema, rootSchema, processed, inProgress)
+      ])
+    );
+  }
+  if (result.$defs) {
+    result.$defs = Object.fromEntries(
+      Object.entries(result.$defs).map(([key, subSchema]) => [
+        key,
+        dereferenceSchemaDeep(subSchema, rootSchema, processed, inProgress)
+      ])
+    );
+  }
+  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 [];
+  }
+  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.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 (schema.type && basePath) {
+    paths.push(basePath);
+  }
+  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.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.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.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));
+      }
+    }
+  }
+  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.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);
+      }
+    }
+    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;
+}
+function getSubSchema(schema, key) {
+  if (schema.properties && schema.properties[key]) {
+    return {
+      schema: schema.properties[key],
+      keywordLocationToken: `properties/${key}`
+    };
+  }
+  if (schema.patternProperties) {
+    for (const [pattern, subschema] of Object.entries(
+      schema.patternProperties
+    )) {
+      if (safeRegexTest(pattern, key)) {
+        return {
+          schema: subschema,
+          keywordLocationToken: `patternProperties/${pattern}`
+        };
+      }
+    }
+  }
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+    return {
+      schema: typeof schema.additionalProperties === "object" ? schema.additionalProperties : {},
+      keywordLocationToken: "additionalProperties"
+    };
+  }
+  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"
+        };
+      }
+    }
+  }
+  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;
+    }
+    case "array":
+      return [];
+    default:
+      if (schema.properties) {
+        return getDefaultValue({ ...schema, type: "object" });
+      }
+      return void 0;
+  }
+}
+
+// src/render.ts
+var ROOT_PATH = "";
+function normalizeRootPath(path) {
+  return path === "#" ? ROOT_PATH : path;
+}
+var SchemaRuntime = class {
+  validator;
+  watchers = {};
+  globalWatchers = /* @__PURE__ */ new Set();
+  // Reverse dependency index: path -> nodes that depend on this path's value
+  dependentsMap = /* @__PURE__ */ new Map();
+  // Track nodes currently being updated to prevent circular updates
+  updatingNodes = /* @__PURE__ */ new Set();
+  root;
+  value;
+  version = 0;
+  rootSchema = {};
+  /**
+   * Create a new SchemaRuntime instance.
+   *
+   * @param validator - The validator instance for schema validation
+   * @param schema - The JSON Schema definition (will be normalized and dereferenced)
+   * @param value - The initial data value to manage
+   *
+   * @example
+   * const validator = new Validator();
+   * const schema = { type: "object", properties: { name: { type: "string" } } };
+   * 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;
+    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;
+  }
+  /**
+   * Register a node as dependent on a path
+   */
+  registerDependent(path, node) {
+    let dependents = this.dependentsMap.get(path);
+    if (!dependents) {
+      dependents = /* @__PURE__ */ new Set();
+      this.dependentsMap.set(path, dependents);
+    }
+    dependents.add(node);
+  }
+  /**
+   * Unregister a node from a dependency path
+   */
+  unregisterDependent(path, node) {
+    const dependents = this.dependentsMap.get(path);
+    if (dependents) {
+      dependents.delete(node);
+      if (dependents.size === 0) {
+        this.dependentsMap.delete(path);
+      }
+    }
+  }
+  /**
+   * Unregister all dependencies for a node and its children.
+   * Note: Does NOT clean up external watchers - callers are responsible
+   * for calling unsubscribe() when they no longer need updates.
+   */
+  unregisterNodeDependencies(node) {
+    if (node.dependencies) {
+      for (const depPath of node.dependencies) {
+        this.unregisterDependent(depPath, node);
+      }
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        this.unregisterNodeDependencies(child);
+      }
+    }
+  }
+  /**
+   * Create an empty FieldNode with default values.
+   */
+  createEmptyNode(instanceLocation, keywordLocation) {
+    return {
+      type: "null",
+      schema: {},
+      version: -1,
+      instanceLocation,
+      keywordLocation,
+      originalSchema: {},
+      canRemove: false,
+      canAdd: false,
+      children: []
+    };
+  }
+  /**
+   * Reconcile the tree starting from the specified path.
+   * 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);
+    if (!targetNode) {
+      return;
+    }
+    this.buildNode(targetNode, targetNode.originalSchema);
+  }
+  /**
+   * Get the current version number.
+   * The version increments on every notify call (value, schema, or error changes).
+   * Useful for detecting if the runtime state has changed.
+   *
+   * @returns The current version number
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Subscribe to changes at a specific path.
+   * The callback is invoked when the value, schema, or error at the path changes.
+   *
+   * @param path - The JSON Pointer path to watch (e.g., "/user/name", "" for root)
+   * @param cb - Callback function invoked with the change event
+   * @returns Unsubscribe function to remove the listener
+   *
+   * @example
+   * const unsubscribe = runtime.subscribe("/name", (event) => {
+   *   console.log(`${event.type} changed at ${event.path}`);
+   * });
+   * // Later: unsubscribe();
+   */
+  subscribe(path, cb) {
+    const normalizedPath = normalizeRootPath(path);
+    if (!this.watchers[normalizedPath]) {
+      this.watchers[normalizedPath] = /* @__PURE__ */ new Set();
+    }
+    this.watchers[normalizedPath].add(cb);
+    return () => {
+      const watcherSet = this.watchers[normalizedPath];
+      if (watcherSet) {
+        watcherSet.delete(cb);
+        if (watcherSet.size === 0) {
+          delete this.watchers[normalizedPath];
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe to all events in the runtime.
+   * The callback is invoked for any change at any path.
+   *
+   * @param cb - Callback function invoked with every change event
+   * @returns Unsubscribe function to remove the listener
+   */
+  subscribeAll(cb) {
+    this.globalWatchers.add(cb);
+    return () => {
+      this.globalWatchers.delete(cb);
+    };
+  }
+  /**
+   * Emit a change event to all relevant subscribers.
+   * Increments the version number and notifies both path-specific and global watchers.
+   *
+   * @param event - The change event containing type and path
+   */
+  notify(event) {
+    this.version++;
+    const normalizedPath = normalizeRootPath(event.path);
+    const watchers = this.watchers[normalizedPath];
+    if (watchers) {
+      for (const cb of watchers) {
+        try {
+          cb(event);
+        } catch (err) {
+          console.error("SchemaRuntime: watcher callback error:", err);
+        }
+      }
+    }
+    for (const cb of this.globalWatchers) {
+      try {
+        cb(event);
+      } catch (err) {
+        console.error("SchemaRuntime: global watcher callback error:", err);
+      }
+    }
+  }
+  /**
+   * 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.
+   *
+   * @param path - The JSON Pointer path (e.g., "/user/name", "" for root)
+   * @returns The value at the path, or undefined if not found
+   *
+   * @example
+   * runtime.getValue(""); // returns entire root value
+   * 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);
+  }
+  /**
+   * Remove a node at the specified path.
+   * This deletes the value from the data structure (array splice or object delete).
+   * @param path - The path to remove
+   * @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;
+    }
+    const success = removeJsonPointer(this.value, normalizedPath);
+    if (!success) {
+      return false;
+    }
+    const lastSlash = normalizedPath.lastIndexOf("/");
+    const parentPath = lastSlash <= 0 ? ROOT_PATH : normalizedPath.substring(0, lastSlash);
+    this.reconcile(parentPath);
+    this.notify({ type: "value", path: parentPath });
+    return true;
+  }
+  /**
+   * Add a new child to an array or object at the specified parent path.
+   * For arrays, appends a new item with default value based on items schema.
+   * For objects, adds a new property with the given key and default value based on additionalProperties schema.
+   * @param parentPath - The path to the parent array or object
+   * @param key - For objects: the property key. For arrays: optional, ignored (appends to end)
+   * @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);
+    if (!parentNode || !parentNode.canAdd) {
+      return false;
+    }
+    const parentValue = this.getValue(normalizedPath);
+    const parentSchema = parentNode.schema;
+    if (parentNode.type === "array" && Array.isArray(parentValue)) {
+      const newIndex = parentValue.length;
+      const { schema: subschema } = getSubSchema(
+        parentSchema,
+        String(newIndex)
+      );
+      const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
+      const itemPath = jsonPointerJoin(normalizedPath, String(newIndex));
+      return this.setValue(itemPath, defaultValue);
+    } else if (parentNode.type === "object" && parentValue && typeof parentValue === "object") {
+      if (!key) {
+        return false;
+      }
+      const { schema: subschema } = getSubSchema(parentSchema, key);
+      if (!parentSchema.additionalProperties) {
+        return false;
+      }
+      const defaultValue = initialValue !== void 0 ? initialValue : getDefaultValue(subschema);
+      const propertyPath = jsonPointerJoin(normalizedPath, key);
+      return this.setValue(propertyPath, defaultValue);
+    }
+    return false;
+  }
+  /**
+   * Set the value at a specific path.
+   * Creates intermediate containers (objects/arrays) as needed.
+   * Triggers reconciliation and notifies subscribers.
+   *
+   * @param path - The JSON Pointer path (e.g., "/user/name", "" for root)
+   * @param value - The new value to set
+   * @returns true if successful, false if the path cannot be set
+   *
+   * @example
+   * runtime.setValue("/name", "Bob"); // set name to "Bob"
+   * runtime.setValue("", { name: "Alice" }); // replace entire root value
+   */
+  setValue(path, value) {
+    const normalizedPath = normalizeRootPath(path);
+    if (normalizedPath === ROOT_PATH) {
+      this.value = value;
+    } else {
+      const success = setJsonPointer(this.value, normalizedPath, value);
+      if (!success) return false;
+    }
+    this.reconcile(normalizedPath);
+    this.notify({ type: "value", path: normalizedPath });
+    return true;
+  }
+  /**
+   * Find 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");
+   * 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);
+    let current = this.root;
+    for (const segment of segments) {
+      if (!current?.children) return void 0;
+      const expectedPath = jsonPointerJoin(current.instanceLocation, segment);
+      const found = current.children?.find(
+        (child) => child.instanceLocation === expectedPath
+      );
+      if (!found) return void 0;
+      current = found;
+    }
+    return current;
+  }
+  findNearestExistingNode(path) {
+    const normalizedPath = normalizeRootPath(path);
+    let currentPath = normalizedPath;
+    while (currentPath !== ROOT_PATH) {
+      const node = this.findNode(currentPath);
+      if (node) return node;
+      const lastSlash = currentPath.lastIndexOf("/");
+      currentPath = lastSlash <= 0 ? ROOT_PATH : currentPath.substring(0, lastSlash);
+    }
+    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.
+   */
+  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;
+    }
+    if (this.updatingNodes.has(instanceLocation)) {
+      return;
+    }
+    const updatedNodes = options.updatedNodes || /* @__PURE__ */ new Set();
+    if (updatedNodes.has(instanceLocation)) {
+      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);
+        }
+      }
+    }
+    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++;
+    const oldChildrenMap = /* @__PURE__ */ new Map();
+    if (node.children) {
+      for (const child of node.children) {
+        oldChildrenMap.set(child.instanceLocation, child);
+      }
+    }
+    const newChildren = [];
+    const processChild = (childKey, childSchema, childkeywordLocation, canRemove = false) => {
+      const childinstanceLocation = jsonPointerJoin(instanceLocation, childKey);
+      let childNode = oldChildrenMap.get(childinstanceLocation);
+      if (childNode) {
+        oldChildrenMap.delete(childinstanceLocation);
+        childNode.keywordLocation = childkeywordLocation;
+      } else {
+        childNode = this.createEmptyNode(
+          childinstanceLocation,
+          childkeywordLocation
+        );
+      }
+      childNode.canRemove = canRemove;
+      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;
+        if (effectiveSchema.properties) {
+          for (const [key, subschema] of Object.entries(
+            effectiveSchema.properties
+          )) {
+            processedKeys.add(key);
+            processChild(
+              key,
+              subschema,
+              `${keywordLocation}/properties/${key}`,
+              false
+            );
+          }
+        }
+        if (effectiveSchema.patternProperties) {
+          for (const [pattern, subschema] of Object.entries(
+            effectiveSchema.patternProperties
+          )) {
+            for (const key of valueKeys) {
+              if (safeRegexTest(pattern, key) && !processedKeys.has(key)) {
+                processedKeys.add(key);
+                processChild(
+                  key,
+                  subschema,
+                  `${keywordLocation}/patternProperties/${jsonPointerEscape(pattern)}`,
+                  true
+                );
+              }
+            }
+          }
+        }
+        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
+              );
+            }
+          }
+        }
+        break;
+      }
+      case "array": {
+        node.canAdd = !!effectiveSchema.items;
+        if (Array.isArray(value)) {
+          let prefixItemsLength = 0;
+          if (effectiveSchema.prefixItems) {
+            prefixItemsLength = effectiveSchema.prefixItems.length;
+            for (let i = 0; i < Math.min(value.length, prefixItemsLength); i++) {
+              processChild(
+                String(i),
+                effectiveSchema.prefixItems[i],
+                `${keywordLocation}/prefixItems/${i}`,
+                false
+              );
+            }
+          }
+          if (effectiveSchema.items && value.length > prefixItemsLength) {
+            for (let i = prefixItemsLength; i < value.length; i++) {
+              processChild(
+                String(i),
+                effectiveSchema.items,
+                `${keywordLocation}/items`,
+                true
+              );
+            }
+          }
+        }
+        break;
+      }
+    }
+    for (const oldChild of oldChildrenMap.values()) {
+      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
+        });
+      }
+    }
+  }
+};
+
+exports.DRAFT_URIS = DRAFT_URIS;
+exports.MESSAGES = MESSAGES;
+exports.SchemaRuntime = SchemaRuntime;
+exports.StringFormatValidator = StringFormatValidator;
+exports.Validator = Validator;
+exports.deepEqual = deepEqual;
+exports.defaultErrorFormatter = defaultErrorFormatter;
+exports.detectSchemaDraft = detectSchemaDraft;
+exports.detectSchemaType = detectSchemaType;
+exports.get = get;
+exports.getJsonPointer = getJsonPointer;
+exports.jsonPointerEscape = jsonPointerEscape;
+exports.jsonPointerJoin = jsonPointerJoin;
+exports.jsonPointerUnescape = jsonPointerUnescape;
+exports.matchSchemaType = matchSchemaType;
+exports.normalizeSchema = normalizeSchema;
+exports.parseJsonPointer = parseJsonPointer;
+exports.removeJsonPointer = removeJsonPointer;
+exports.resolveAbsolutePath = resolveAbsolutePath;
+exports.safeRegexTest = safeRegexTest;
+exports.setJsonPointer = setJsonPointer;
+exports.stringFormatValidator = stringFormatValidator;
+exports.validateSchema = validateSchema;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map