uss-xsd-engine 0.1.1 → 0.2.1

package/dist/uss-xsd-engine.esm.js

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.1.1
+ * uss-xsd-engine v0.2.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -45,6 +45,10 @@ var ISSUE_CODES = {
   UNKNOWN_GROUP: "UNKNOWN_GROUP",
   UNKNOWN_ATTRIBUTE_GROUP: "UNKNOWN_ATTRIBUTE_GROUP",
   MISSING_BASE_TYPE: "MISSING_BASE_TYPE",
+  INVALID_CONSTRAINT_SELECTOR: "INVALID_CONSTRAINT_SELECTOR",
+  INVALID_CONSTRAINT_FIELD: "INVALID_CONSTRAINT_FIELD",
+  UNKNOWN_KEY_REFERENCE: "UNKNOWN_KEY_REFERENCE",
+  DUPLICATE_CONSTRAINT_NAME: "DUPLICATE_CONSTRAINT_NAME",
   UNSUPPORTED_FEATURE: "UNSUPPORTED_FEATURE",
   INVALID_OCCURS_RANGE: "INVALID_OCCURS_RANGE",
   INVALID_DEFAULT_FIXED_COMBINATION: "INVALID_DEFAULT_FIXED_COMBINATION",
@@ -61,6 +65,12 @@ var ISSUE_CODES = {
   XML_VALUE_INVALID: "XML_VALUE_INVALID",
   XML_ENUMERATION_MISMATCH: "XML_ENUMERATION_MISMATCH",
   XML_VALUE_REQUIRED: "XML_VALUE_REQUIRED",
+  XML_KEY_VIOLATION: "XML_KEY_VIOLATION",
+  XML_KEY_NULL_VIOLATION: "XML_KEY_NULL_VIOLATION",
+  XML_KEYREF_VIOLATION: "XML_KEYREF_VIOLATION",
+  XML_UNIQUE_VIOLATION: "XML_UNIQUE_VIOLATION",
+  XML_ANY_STRICT_VALIDATION_FAILED: "XML_ANY_STRICT_VALIDATION_FAILED",
+  XML_ANYATTRIBUTE_STRICT_VALIDATION_FAILED: "XML_ANYATTRIBUTE_STRICT_VALIDATION_FAILED",
   XML_PATTERN_MISMATCH: "XML_PATTERN_MISMATCH",
   XML_LENGTH_MISMATCH: "XML_LENGTH_MISMATCH",
   XML_MIN_LENGTH_VIOLATION: "XML_MIN_LENGTH_VIOLATION",
@@ -87,6 +97,9 @@ var ISSUE_CODES = {
   XSD_RESTRICTION_NOT_SUBSET: "XSD_RESTRICTION_NOT_SUBSET",
   XSD_RESTRICTION_OCCURS_WIDENED: "XSD_RESTRICTION_OCCURS_WIDENED",
   XSD_RESTRICTION_ATTRIBUTE_WIDENED: "XSD_RESTRICTION_ATTRIBUTE_WIDENED",
+  XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE: "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+  XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE: "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+  XSD_RESTRICTION_WILDCARD_INCOMPATIBLE: "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
   XSD_INCLUDE_NOT_PROVIDED: "XSD_INCLUDE_NOT_PROVIDED",
   XSD_IMPORT_NOT_PROVIDED: "XSD_IMPORT_NOT_PROVIDED",
   XSD_INCLUDE_NAMESPACE_MISMATCH: "XSD_INCLUDE_NAMESPACE_MISMATCH",
@@ -162,6 +175,7 @@ function createEmptySchemaModel() {
     },
     importedSchemas: [],
     roots: [],
+    identityConstraints: [],
     references: {
       types: [],
       refs: [],
@@ -193,7 +207,7 @@ function normalizeUse(value) {
 function createElementDecl({
   name = null,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   typeName = null,
   refName = null,
   inlineType = null,
@@ -202,6 +216,7 @@ function createElementDecl({
   defaultValue = null,
   fixedValue = null,
   nillable = false,
+  identityConstraints = [],
   line = null,
   column = null,
   path = null
@@ -210,7 +225,7 @@ function createElementDecl({
     kind: "element",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     typeName,
     refName,
     inlineType,
@@ -219,6 +234,7 @@ function createElementDecl({
     defaultValue,
     fixedValue,
     nillable,
+    identityConstraints,
     line,
     column,
     path
@@ -227,7 +243,7 @@ function createElementDecl({
 function createAttributeDecl({
   name = null,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   typeName = null,
   refName = null,
   inlineType = null,
@@ -242,7 +258,7 @@ function createAttributeDecl({
     kind: "attribute",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     typeName,
     refName,
     inlineType,
@@ -257,13 +273,14 @@ function createAttributeDecl({
 function createComplexTypeDecl({
   name = null,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   content = null,
   attributes = [],
   derivation = { kind: null, baseTypeName: null },
   contentModel = "complex",
   mixed = false,
   abstract = false,
+  identityConstraints = [],
   line = null,
   column = null,
   path = null
@@ -272,13 +289,14 @@ function createComplexTypeDecl({
     kind: "complexType",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     content,
     attributes,
     derivation,
     contentModel,
     mixed,
     abstract,
+    identityConstraints,
     line,
     column,
     path
@@ -287,7 +305,7 @@ function createComplexTypeDecl({
 function createSimpleTypeDecl({
   name = null,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   baseTypeName = null,
   facets = {},
   enumerations = [],
@@ -299,7 +317,7 @@ function createSimpleTypeDecl({
     kind: "simpleType",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     baseTypeName,
     facets,
     enumerations,
@@ -311,7 +329,7 @@ function createSimpleTypeDecl({
 function createGroupDecl({
   name,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   content = null,
   line = null,
   column = null,
@@ -321,7 +339,7 @@ function createGroupDecl({
     kind: "group",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     content,
     line,
     column,
@@ -331,7 +349,7 @@ function createGroupDecl({
 function createAttributeGroupDecl({
   name,
   qName = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   attributes = [],
   line = null,
   column = null,
@@ -341,7 +359,7 @@ function createAttributeGroupDecl({
     kind: "attributeGroup",
     name,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     attributes,
     line,
     column,
@@ -362,6 +380,37 @@ function createAttributeGroupRef({
     path
   };
 }
+function createIdentityConstraint({
+  kind = null,
+  name = null,
+  qName = null,
+  namespaceUri: namespaceUri4 = null,
+  selector = null,
+  fields = [],
+  refer = null,
+  ownerName = null,
+  ownerNamespaceUri = null,
+  ownerPath = null,
+  line = null,
+  column = null,
+  path = null
+} = {}) {
+  return {
+    kind,
+    name,
+    qName,
+    namespaceUri: namespaceUri4,
+    selector,
+    fields,
+    refer,
+    ownerName,
+    ownerNamespaceUri,
+    ownerPath,
+    line,
+    column,
+    path
+  };
+}
 function createSequenceNode({
   children = [],
   minOccurs = 1,
@@ -436,9 +485,11 @@ function createGroupRefNode({
 }
 function createAnyNode({
   namespace = null,
-  processContents = null,
+  processContents = "strict",
   minOccurs = 1,
   maxOccurs = 1,
+  notNamespace = [],
+  notQName = [],
   line = null,
   column = null,
   path = null
@@ -446,9 +497,31 @@ function createAnyNode({
   return {
     kind: "any",
     namespace,
-    processContents,
+    processContents: processContents || "strict",
     minOccurs,
     maxOccurs,
+    notNamespace,
+    notQName,
+    line,
+    column,
+    path
+  };
+}
+function createAnyAttributeNode({
+  namespace = null,
+  processContents = "strict",
+  notNamespace = [],
+  notQName = [],
+  line = null,
+  column = null,
+  path = null
+} = {}) {
+  return {
+    kind: "anyAttribute",
+    namespace,
+    processContents: processContents || "strict",
+    notNamespace,
+    notQName,
     line,
     column,
     path
@@ -533,8 +606,8 @@ function resolveQName(schema, qName) {
     namespaceUri: resolveNamespaceUri(schema, parsed.prefix)
   };
 }
-function makeLookupKey(namespaceUri3, localName3) {
-  return `${namespaceUri3 || ""}::${localName3 || ""}`;
+function makeLookupKey(namespaceUri4, localName4) {
+  return `${namespaceUri4 || ""}::${localName4 || ""}`;
 }
 function isBuiltinType(typeName, schema = null) {
   const q = parseQName(typeName);
@@ -550,41 +623,41 @@ function isBuiltinType(typeName, schema = null) {
 function getLocalName(name) {
   return parseQName(name).localName;
 }
-function lookupBucketByNamespace(bucket, namespaceUri3, localName3) {
-  if (!bucket || !localName3) return null;
-  return bucket[makeLookupKey(namespaceUri3, localName3)] || null;
+function lookupBucketByNamespace(bucket, namespaceUri4, localName4) {
+  if (!bucket || !localName4) return null;
+  return bucket[makeLookupKey(namespaceUri4, localName4)] || null;
 }
-function lookupInSchemaBucket(bucketName, schema, namespaceUri3, localName3) {
-  return lookupBucketByNamespace(schema?.globals?.[bucketName], namespaceUri3, localName3);
+function lookupInSchemaBucket(bucketName, schema, namespaceUri4, localName4) {
+  return lookupBucketByNamespace(schema?.globals?.[bucketName], namespaceUri4, localName4);
 }
-function lookupInImportedSchemas(bucketName, schema, namespaceUri3, localName3, visited = /* @__PURE__ */ new Set()) {
-  if (!schema || !namespaceUri3) return null;
+function lookupInImportedSchemas(bucketName, schema, namespaceUri4, localName4, visited = /* @__PURE__ */ new Set()) {
+  if (!schema || !namespaceUri4) return null;
   if (visited.has(schema)) return null;
   visited.add(schema);
   for (const importedSchema of schema.importedSchemas || []) {
     if (!importedSchema) continue;
-    if ((importedSchema.targetNamespace || null) === namespaceUri3) {
+    if ((importedSchema.targetNamespace || null) === namespaceUri4) {
       const direct = lookupInSchemaBucket(
         bucketName,
         importedSchema,
-        namespaceUri3,
-        localName3
+        namespaceUri4,
+        localName4
       );
       if (direct) return direct;
     }
     const nested = lookupInImportedSchemas(
       bucketName,
       importedSchema,
-      namespaceUri3,
-      localName3,
+      namespaceUri4,
+      localName4,
       visited
     );
     if (nested) return nested;
   }
   return null;
 }
-function lookupInImportedSchemasForUnprefixed(bucketName, schema, localName3, visited = /* @__PURE__ */ new Set()) {
-  if (!schema || !localName3) return null;
+function lookupInImportedSchemasForUnprefixed(bucketName, schema, localName4, visited = /* @__PURE__ */ new Set()) {
+  if (!schema || !localName4) return null;
   if (visited.has(schema)) return null;
   visited.add(schema);
   const targetNs = schema.targetNamespace || null;
@@ -596,14 +669,14 @@ function lookupInImportedSchemasForUnprefixed(bucketName, schema, localName3, vi
         bucketName,
         importedSchema,
         importedNs,
-        localName3
+        localName4
       );
       if (direct) return direct;
     }
     const nested = lookupInImportedSchemasForUnprefixed(
       bucketName,
       importedSchema,
-      localName3,
+      localName4,
       visited
     );
     if (nested) return nested;
@@ -614,24 +687,24 @@ function lookupByQName(bucketName, schema, name) {
   if (!schema || !name) return null;
   const parsed = parseQName(name);
   const resolved = resolveQName(schema, name);
-  const localName3 = resolved.localName;
-  if (!localName3) return null;
+  const localName4 = resolved.localName;
+  if (!localName4) return null;
   if (parsed.prefix) {
     const direct = lookupInSchemaBucket(
       bucketName,
       schema,
       resolved.namespaceUri,
-      localName3
+      localName4
     );
     if (direct) return direct;
     return lookupInImportedSchemas(
       bucketName,
       schema,
       resolved.namespaceUri,
-      localName3
+      localName4
     );
   }
-  const noNamespace = lookupInSchemaBucket(bucketName, schema, null, localName3);
+  const noNamespace = lookupInSchemaBucket(bucketName, schema, null, localName4);
   if (noNamespace) return noNamespace;
   const sameSchemaNs = schema.targetNamespace || null;
   if (sameSchemaNs !== null) {
@@ -639,13 +712,13 @@ function lookupByQName(bucketName, schema, name) {
       bucketName,
       schema,
       sameSchemaNs,
-      localName3
+      localName4
     );
     if (hostNamespaceDecl) return hostNamespaceDecl;
     const importedSameNamespaceDecl = lookupInImportedSchemasForUnprefixed(
       bucketName,
       schema,
-      localName3
+      localName4
     );
     if (importedSameNamespaceDecl) return importedSameNamespaceDecl;
   }
@@ -773,11 +846,6 @@ function getEffectiveContent(schema, complexTypeDecl) {
 
 // src/parser/buildSchemaModel.js
 var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-  "key",
-  "keyref",
-  "unique",
-  "any",
-  "anyAttribute",
   "redefine",
   "notation"
 ]);
@@ -840,6 +908,9 @@ function mergeGlobalsIntoSchema(targetSchema, sourceSchema, issues, createDuplic
     ...sourceSchema.externalRefs.imports || []
   );
   targetSchema.importedSchemas.push(...sourceSchema.importedSchemas || []);
+  targetSchema.identityConstraints.push(
+    ...sourceSchema.identityConstraints || []
+  );
   for (const feature of sourceSchema.usedFeatures || []) {
     targetSchema.usedFeatures.add(feature);
   }
@@ -892,17 +963,17 @@ function escapeRegExp(value) {
 }
 function locateNodeInSource(xsdText, lineStarts, node) {
   if (!xsdText || !node) return { line: null, column: null };
-  const localName3 = node.localName;
+  const localName4 = node.localName;
   const name = node.getAttribute("name");
   const ref = node.getAttribute("ref");
   const base = node.getAttribute("base");
   const type = node.getAttribute("type");
   const candidates = [
-    name ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bname=(["'])${escapeRegExp(name)}\\1` : null,
-    ref ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bref=(["'])${escapeRegExp(ref)}\\1` : null,
-    base ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bbase=(["'])${escapeRegExp(base)}\\1` : null,
-    type ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\btype=(["'])${escapeRegExp(type)}\\1` : null,
-    `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b`
+    name ? `<(?:[\\w.-]+:)?${escapeRegExp(localName4)}\\b[^>]*\\bname=(["'])${escapeRegExp(name)}\\1` : null,
+    ref ? `<(?:[\\w.-]+:)?${escapeRegExp(localName4)}\\b[^>]*\\bref=(["'])${escapeRegExp(ref)}\\1` : null,
+    base ? `<(?:[\\w.-]+:)?${escapeRegExp(localName4)}\\b[^>]*\\bbase=(["'])${escapeRegExp(base)}\\1` : null,
+    type ? `<(?:[\\w.-]+:)?${escapeRegExp(localName4)}\\b[^>]*\\btype=(["'])${escapeRegExp(type)}\\1` : null,
+    `<(?:[\\w.-]+:)?${escapeRegExp(localName4)}\\b`
   ].filter(Boolean);
   for (const pattern of candidates) {
     const regex = new RegExp(pattern, "m");
@@ -925,9 +996,9 @@ function buildPath(parentPath, node) {
   return `${parentPath}/${kind}${qualifier}`;
 }
 function registerGlobal(schema, issues, bucketName, duplicateCode, decl) {
-  const localName3 = stripNamespacePrefix(decl.name);
-  if (!localName3) return;
-  const key = makeLookupKey(decl.namespaceUri, localName3);
+  const localName4 = stripNamespacePrefix(decl.name);
+  if (!localName4) return;
+  const key = makeLookupKey(decl.namespaceUri, localName4);
   if (schema.globals[bucketName][key]) {
     issues.push(
       createIssue({
@@ -954,15 +1025,15 @@ function collectUnsupportedFeature(schema, feature) {
   schema.unsupportedFeatures.push(feature);
 }
 function collectNodeDiagnostics(schema, issues, node, path, loc) {
-  const localName3 = node.localName;
-  schema.usedFeatures.add(localName3);
-  if (UNSUPPORTED_NODE_FEATURES.has(localName3)) {
+  const localName4 = node.localName;
+  schema.usedFeatures.add(localName4);
+  if (UNSUPPORTED_NODE_FEATURES.has(localName4)) {
     collectUnsupportedFeature(schema, {
-      feature: `xs:${localName3}`,
+      feature: `xs:${localName4}`,
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
@@ -972,7 +1043,7 @@ function collectNodeDiagnostics(schema, issues, node, path, loc) {
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
@@ -982,47 +1053,47 @@ function collectNodeDiagnostics(schema, issues, node, path, loc) {
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || node.getAttribute("ref") || null
     });
   }
-  if ((localName3 === "element" || localName3 === "attribute") && node.hasAttribute("ref")) {
+  if ((localName4 === "element" || localName4 === "attribute") && node.hasAttribute("ref")) {
     collectReference(schema, "refs", {
       refName: node.getAttribute("ref"),
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
-  if ((localName3 === "extension" || localName3 === "restriction") && node.hasAttribute("base")) {
+  if ((localName4 === "extension" || localName4 === "restriction") && node.hasAttribute("base")) {
     collectReference(schema, "baseTypes", {
       baseTypeName: node.getAttribute("base"),
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
-  if (localName3 === "group" && node.hasAttribute("ref")) {
+  if (localName4 === "group" && node.hasAttribute("ref")) {
     collectReference(schema, "groupRefs", {
       refName: node.getAttribute("ref"),
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
-  if (localName3 === "attributeGroup" && node.hasAttribute("ref")) {
+  if (localName4 === "attributeGroup" && node.hasAttribute("ref")) {
     collectReference(schema, "attributeGroupRefs", {
       refName: node.getAttribute("ref"),
       line: loc.line,
       column: loc.column,
       path,
-      nodeKind: localName3,
+      nodeKind: localName4,
       name: node.getAttribute("name") || null
     });
   }
@@ -1038,13 +1109,13 @@ function collectNodeDiagnostics(schema, issues, node, path, loc) {
         column: loc.column,
         path,
         source: "xsd",
-        nodeKind: localName3,
+        nodeKind: localName4,
         name: node.getAttribute("name") || null,
         details: { minOccurs, maxOccurs }
       })
     );
   }
-  if ((localName3 === "element" || localName3 === "attribute") && node.hasAttribute("default") && node.hasAttribute("fixed")) {
+  if ((localName4 === "element" || localName4 === "attribute") && node.hasAttribute("default") && node.hasAttribute("fixed")) {
     issues.push(
       createIssue({
         code: ISSUE_CODES.INVALID_DEFAULT_FIXED_COMBINATION,
@@ -1054,7 +1125,7 @@ function collectNodeDiagnostics(schema, issues, node, path, loc) {
         column: loc.column,
         path,
         source: "xsd",
-        nodeKind: localName3,
+        nodeKind: localName4,
         name: node.getAttribute("name") || node.getAttribute("ref") || null,
         details: {
           defaultValue: node.getAttribute("default"),
@@ -1135,11 +1206,11 @@ function parseSimpleType(node, xsdText, lineStarts, parentPath, schema, issues)
     enumerations = parsed.enumerations;
   }
   const qName = node.getAttribute("name");
-  const namespaceUri3 = schema.targetNamespace || null;
+  const namespaceUri4 = schema.targetNamespace || null;
   return createSimpleTypeDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     baseTypeName,
     facets,
     enumerations,
@@ -1164,11 +1235,11 @@ function parseAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
     issues
   ) : null;
   const qName = node.getAttribute("name");
-  const namespaceUri3 = getDeclarationNamespaceUri(schema, node, "attribute");
+  const namespaceUri4 = getDeclarationNamespaceUri(schema, node, "attribute");
   return createAttributeDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     typeName: node.getAttribute("type"),
     refName: node.getAttribute("ref"),
     inlineType,
@@ -1209,6 +1280,10 @@ function parseAttributesContainer(nodes, xsdText, lineStarts, parentPath, schema
           issues
         )
       );
+    } else if (child.localName === "anyAttribute") {
+      attributes.push(
+        parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+      );
     }
   }
   return attributes;
@@ -1245,11 +1320,26 @@ function parseElement(node, xsdText, lineStarts, parentPath, schema, issues) {
     );
   }
   const qName = node.getAttribute("name");
-  const namespaceUri3 = getDeclarationNamespaceUri(schema, node, "element");
+  const namespaceUri4 = getDeclarationNamespaceUri(schema, node, "element");
+  const identityConstraints = children.filter(
+    (child) => ["key", "keyref", "unique"].includes(child.localName)
+  ).map(
+    (child) => parseIdentityConstraint(
+      child,
+      xsdText,
+      lineStarts,
+      path,
+      schema,
+      issues,
+      qName ? parseQName(qName).localName : null,
+      namespaceUri4,
+      path
+    )
+  );
   return createElementDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     typeName: node.getAttribute("type"),
     refName: node.getAttribute("ref"),
     inlineType,
@@ -1258,6 +1348,7 @@ function parseElement(node, xsdText, lineStarts, parentPath, schema, issues) {
     defaultValue: node.getAttribute("default"),
     fixedValue: node.getAttribute("fixed"),
     nillable: node.getAttribute("nillable") === "true",
+    identityConstraints,
     line: loc.line,
     column: loc.column,
     path
@@ -1276,20 +1367,101 @@ function parseGroupRef(node, xsdText, lineStarts, parentPath, schema, issues) {
     path
   });
 }
+function parseWildcardNamespace(namespaceStr) {
+  if (!namespaceStr) return null;
+  const trimmed = namespaceStr.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return trimmed;
+}
+function parseNotNamespace(notNamespaceStr) {
+  if (!notNamespaceStr) return [];
+  const trimmed = notNamespaceStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return [trimmed];
+}
+function parseNotQName(notQNameStr) {
+  if (!notQNameStr) return [];
+  const trimmed = notQNameStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((qn) => qn);
+  }
+  return [trimmed];
+}
 function parseAny(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
   collectNodeDiagnostics(schema, issues, node, path, loc);
   return createAnyNode({
-    namespace: node.getAttribute("namespace"),
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
     processContents: node.getAttribute("processContents"),
     minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
     maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
     line: loc.line,
     column: loc.column,
     path
   });
 }
+function parseAnyAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
+  const path = buildPath(parentPath, node);
+  const loc = locateNodeInSource(xsdText, lineStarts, node);
+  collectNodeDiagnostics(schema, issues, node, path, loc);
+  return createAnyAttributeNode({
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
+    processContents: node.getAttribute("processContents"),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
+    line: loc.line,
+    column: loc.column,
+    path
+  });
+}
+function parseIdentityConstraint(node, xsdText, lineStarts, parentPath, schema, issues, ownerName, ownerNamespaceUri, ownerPath) {
+  const path = buildPath(parentPath, node);
+  const loc = locateNodeInSource(xsdText, lineStarts, node);
+  collectNodeDiagnostics(schema, issues, node, path, loc);
+  const selectorNode = elementChildren(node).find(
+    (child) => child.localName === "selector"
+  );
+  const selector = selectorNode ? {
+    xpath: selectorNode.getAttribute("xpath"),
+    path: buildPath(path, selectorNode)
+  } : null;
+  const fields = elementChildren(node).filter((child) => child.localName === "field").map((child) => ({
+    xpath: child.getAttribute("xpath"),
+    line: locateNodeInSource(xsdText, lineStarts, child).line,
+    column: locateNodeInSource(xsdText, lineStarts, child).column,
+    path: buildPath(path, child)
+  })).filter((field) => field.xpath != null);
+  const qName = node.getAttribute("name");
+  const name = qName ? parseQName(qName).localName : null;
+  const namespaceUri4 = ownerNamespaceUri || schema.targetNamespace || null;
+  const constraint = createIdentityConstraint({
+    kind: node.localName,
+    name,
+    qName,
+    namespaceUri: namespaceUri4,
+    selector,
+    fields,
+    refer: node.getAttribute("refer"),
+    ownerName,
+    ownerNamespaceUri,
+    ownerPath,
+    line: loc.line,
+    column: loc.column,
+    path
+  });
+  schema.identityConstraints.push(constraint);
+  return constraint;
+}
 function parseContentNode(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
@@ -1436,6 +1608,22 @@ function parseComplexType(node, xsdText, lineStarts, parentPath, schema, issues)
   let derivation = { kind: null, baseTypeName: null };
   let contentModel = "complex";
   const children = elementChildren(node);
+  const namespaceUri4 = schema.targetNamespace || null;
+  const identityConstraints = children.filter(
+    (child) => ["key", "keyref", "unique"].includes(child.localName)
+  ).map(
+    (child) => parseIdentityConstraint(
+      child,
+      xsdText,
+      lineStarts,
+      path,
+      schema,
+      issues,
+      null,
+      namespaceUri4,
+      path
+    )
+  );
   const directContentNode = children.find(
     (child) => ["sequence", "choice", "all", "group", "element", "any"].includes(
       child.localName
@@ -1495,17 +1683,17 @@ function parseComplexType(node, xsdText, lineStarts, parentPath, schema, issues)
     );
   }
   const qName = node.getAttribute("name");
-  const namespaceUri3 = schema.targetNamespace || null;
   return createComplexTypeDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     content,
     attributes,
     derivation,
     contentModel,
     mixed: node.getAttribute("mixed") === "true",
     abstract: node.getAttribute("abstract") === "true",
+    identityConstraints,
     line: loc.line,
     column: loc.column,
     path
@@ -1519,11 +1707,11 @@ function parseGroup(node, xsdText, lineStarts, parentPath, schema, issues) {
     (child) => ["sequence", "choice", "all"].includes(child.localName)
   );
   const qName = node.getAttribute("name");
-  const namespaceUri3 = schema.targetNamespace || null;
+  const namespaceUri4 = schema.targetNamespace || null;
   return createGroupDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     content: contentNode ? parseContentNode(contentNode, xsdText, lineStarts, path, schema, issues) : null,
     line: loc.line,
     column: loc.column,
@@ -1545,11 +1733,11 @@ function parseAttributeGroup(node, xsdText, lineStarts, parentPath, schema, issu
     issues
   );
   const qName = node.getAttribute("name");
-  const namespaceUri3 = schema.targetNamespace || null;
+  const namespaceUri4 = schema.targetNamespace || null;
   return createAttributeGroupDecl({
     name: qName ? parseQName(qName).localName : null,
     qName,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     attributes,
     line: loc.line,
     column: loc.column,
@@ -1653,24 +1841,24 @@ function resolveExternalDocument(ref, externalDocuments) {
     }
   }
   if (ref?.kind === "import" && ref.namespace) {
-    const namespaceMatches = entries.filter((entry) => {
+    const namespaceMatches2 = entries.filter((entry) => {
       const declaredTargetNamespace = getDeclaredTargetNamespaceFromText(
         entry.text
       );
       return (declaredTargetNamespace || null) === (ref.namespace || null);
     });
-    if (namespaceMatches.length === 1) {
+    if (namespaceMatches2.length === 1) {
       return {
         kind: "namespace",
-        entry: namespaceMatches[0],
-        matches: namespaceMatches
+        entry: namespaceMatches2[0],
+        matches: namespaceMatches2
       };
     }
-    if (namespaceMatches.length > 1) {
+    if (namespaceMatches2.length > 1) {
       return {
         kind: "ambiguous-namespace",
         entry: null,
-        matches: namespaceMatches
+        matches: namespaceMatches2
       };
     }
   }
@@ -2287,6 +2475,115 @@ function checkRestrictedAttributes(schema, derivedType, baseType, issues) {
     }
   }
 }
+function checkWildcardRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  const derivedWildcards = [];
+  const baseWildcards = [];
+  function collectWildcards(node, arr) {
+    if (!node) return;
+    if (node.kind === "any") {
+      arr.push(node);
+      return;
+    }
+    if (node.children) {
+      for (const child of asArray(node.children)) {
+        collectWildcards(child, arr);
+      }
+    }
+  }
+  collectWildcards(derivedContent, derivedWildcards);
+  collectWildcards(baseContent, baseWildcards);
+  if (derivedWildcards.length > 0 && baseWildcards.length === 0) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces wildcard elements that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const derivedHasAnyAttribute = derivedAttrs.some((a) => a?.kind === "anyAttribute");
+  const baseHasAnyAttribute = baseAttrs.some((a) => a?.kind === "anyAttribute");
+  if (derivedHasAnyAttribute && !baseHasAnyAttribute) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces anyAttribute that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+}
+function checkOccurrenceCompatibility(derived, base, name) {
+  const dMin = typeof derived.minOccurs === "number" ? derived.minOccurs : 1;
+  const bMin = typeof base.minOccurs === "number" ? base.minOccurs : 1;
+  const dMax = maxToNumber(derived.maxOccurs ?? 1);
+  const bMax = maxToNumber(base.maxOccurs ?? 1);
+  return dMin >= bMin && dMax <= bMax;
+}
+function checkComplexContentRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  if (!derivedContent || !baseContent) return;
+  const derivedFlat = flattenContent(derivedContent, []);
+  const baseFlat = flattenContent(baseContent, []);
+  const baseMap = new Map(baseFlat.map((item) => [item.name, item]));
+  for (const item of derivedFlat) {
+    const baseItem = baseMap.get(item.name);
+    if (!baseItem) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_NOT_SUBSET",
+          `Restricted type contains element '${item.name}' not in base type.`,
+          item
+        )
+      );
+      continue;
+    }
+    if (!checkOccurrenceCompatibility(item, baseItem, item.name)) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+          `Restricted type has incompatible occurrence constraints for '${item.name}'.`,
+          item
+        )
+      );
+    }
+  }
+}
+function checkSimpleContentRestriction(schema, derivedType, baseType, issues) {
+  if (baseType.contentModel !== "simple") {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_NOT_SUBSET",
+        `SimpleContent restriction requires base type to have simple content.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const baseAttrMap = new Map(
+    baseAttrs.filter((attr) => attr?.kind === "attribute").map((attr) => [localDeclName(attr), attr])
+  );
+  for (const attr of derivedAttrs) {
+    if (attr?.kind !== "attribute") continue;
+    const name = localDeclName(attr);
+    const baseAttr = baseAttrMap.get(name);
+    if (!baseAttr && !baseAttrs.some((a) => a?.kind === "anyAttribute")) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+          `SimpleContent restricted type adds attribute '${name}' not in base type.`,
+          attr
+        )
+      );
+    }
+  }
+}
 function runRestrictionDiagnostics(schema) {
   const issues = [];
   for (const complexType of Object.values(schema.globals.complexTypes || {})) {
@@ -2296,6 +2593,12 @@ function runRestrictionDiagnostics(schema) {
     if (!baseType) continue;
     checkRestrictedContentSubset(schema, complexType, baseType, issues);
     checkRestrictedAttributes(schema, complexType, baseType, issues);
+    checkWildcardRestriction(schema, complexType, baseType, issues);
+    if (complexType.contentModel === "complex" && baseType.contentModel === "complex") {
+      checkComplexContentRestriction(schema, complexType, baseType, issues);
+    } else if (complexType.contentModel === "simple" && baseType.contentModel === "simple") {
+      checkSimpleContentRestriction(schema, complexType, baseType, issues);
+    }
   }
   return issues;
 }
@@ -2332,6 +2635,188 @@ function runDefaultFixedDiagnostics(schema) {
   return issues;
 }
 
+// src/diagnostics/schemaIdentityConstraintDiagnostics.js
+function isValidConstraintXPath(xpath) {
+  if (!xpath || typeof xpath !== "string") return false;
+  const trimmed = xpath.trim();
+  if (!trimmed) return false;
+  let normalized = trimmed;
+  if (trimmed.startsWith("./")) {
+    if (trimmed.startsWith(".//")) normalized = trimmed.slice(1);
+    else normalized = trimmed.slice(2);
+  }
+  if (normalized.startsWith("/") && !normalized.startsWith("//")) return false;
+  if (normalized.includes("///")) return false;
+  let segments = normalized.split(
+    /\/+/
+  );
+  if (normalized.startsWith("//")) segments = segments.slice(1);
+  if (normalized.endsWith("//")) segments = segments.slice(0, -1);
+  if (segments.some((segment) => segment.length === 0)) return false;
+  for (const segment of segments) {
+    if (segment === ".") continue;
+    if (segment === "*") continue;
+    if (segment.startsWith("@")) {
+      const attrName = segment.slice(1);
+      if (!/^[A-Za-z_][\w.-]*$/.test(attrName)) return false;
+      continue;
+    }
+    const parsed = parseQName(segment);
+    if (!parsed.localName) return false;
+  }
+  return true;
+}
+function getConstraintKey(constraint) {
+  return `${constraint.ownerPath || ""}::${constraint.name || ""}`;
+}
+function findReferencedKey(schema, refer) {
+  if (!refer) return null;
+  const referName = parseQName(refer).localName;
+  return schema.identityConstraints.find(
+    (constraint) => constraint.kind === "key" && constraint.name === referName
+  );
+}
+function runIdentityConstraintDiagnostics(schema) {
+  const issues = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const constraint of schema.identityConstraints || []) {
+    const key = getConstraintKey(constraint);
+    if (seenNames.has(key)) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.DUPLICATE_CONSTRAINT_NAME,
+          severity: "error",
+          message: `Duplicate identity constraint name '${constraint.name}' in the same scope.`,
+          line: constraint.line,
+          column: constraint.column,
+          path: constraint.path,
+          source: "xsd",
+          nodeKind: constraint.kind,
+          name: constraint.name,
+          details: {
+            ownerPath: constraint.ownerPath,
+            ownerName: constraint.ownerName
+          }
+        })
+      );
+    } else {
+      seenNames.add(key);
+    }
+    if (!constraint.selector || !constraint.selector.xpath) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.INVALID_CONSTRAINT_SELECTOR,
+          severity: "error",
+          message: `Identity constraint '${constraint.name || constraint.kind}' is missing a selector xpath.`,
+          line: constraint.line,
+          column: constraint.column,
+          path: constraint.path,
+          source: "xsd",
+          nodeKind: constraint.kind,
+          name: constraint.name,
+          details: {
+            ownerPath: constraint.ownerPath,
+            ownerName: constraint.ownerName
+          }
+        })
+      );
+    } else if (!isValidConstraintXPath(constraint.selector.xpath)) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.INVALID_CONSTRAINT_SELECTOR,
+          severity: "error",
+          message: `Invalid selector xpath '${constraint.selector.xpath}'.`,
+          line: constraint.line,
+          column: constraint.column,
+          path: constraint.selector.path,
+          source: "xsd",
+          nodeKind: constraint.kind,
+          name: constraint.name,
+          details: {
+            selector: constraint.selector.xpath,
+            ownerPath: constraint.ownerPath
+          }
+        })
+      );
+    }
+    if (!constraint.fields?.length) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.INVALID_CONSTRAINT_FIELD,
+          severity: "error",
+          message: `Identity constraint '${constraint.name || constraint.kind}' must declare at least one field.`,
+          line: constraint.line,
+          column: constraint.column,
+          path: constraint.path,
+          source: "xsd",
+          nodeKind: constraint.kind,
+          name: constraint.name,
+          details: { ownerPath: constraint.ownerPath }
+        })
+      );
+    } else {
+      for (const field of constraint.fields) {
+        if (!field.xpath || !isValidConstraintXPath(field.xpath)) {
+          issues.push(
+            createIssue({
+              code: ISSUE_CODES.INVALID_CONSTRAINT_FIELD,
+              severity: "error",
+              message: `Invalid field xpath '${field.xpath}'.`,
+              line: field.line,
+              column: field.column,
+              path: field.path,
+              source: "xsd",
+              nodeKind: constraint.kind,
+              name: constraint.name,
+              details: {
+                field: field.xpath,
+                ownerPath: constraint.ownerPath
+              }
+            })
+          );
+        }
+      }
+    }
+    if (constraint.kind === "keyref") {
+      if (!constraint.refer) {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.UNKNOWN_KEY_REFERENCE,
+            severity: "error",
+            message: `xs:keyref '${constraint.name || "unnamed"}' is missing a refer attribute.`,
+            line: constraint.line,
+            column: constraint.column,
+            path: constraint.path,
+            source: "xsd",
+            nodeKind: constraint.kind,
+            name: constraint.name,
+            details: { ownerPath: constraint.ownerPath }
+          })
+        );
+      } else if (!findReferencedKey(schema, constraint.refer)) {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.UNKNOWN_KEY_REFERENCE,
+            severity: "error",
+            message: `xs:keyref refers to unknown key '${constraint.refer}'.`,
+            line: constraint.line,
+            column: constraint.column,
+            path: constraint.path,
+            source: "xsd",
+            nodeKind: constraint.kind,
+            name: constraint.name,
+            details: {
+              refer: constraint.refer,
+              ownerPath: constraint.ownerPath
+            }
+          })
+        );
+      }
+    }
+  }
+  return issues;
+}
+
 // src/diagnostics/schemaImportDiagnostics.js
 function normalizeSchemaPath2(value) {
   if (!value || typeof value !== "string") return null;
@@ -2440,6 +2925,130 @@ function runImportDiagnostics(schema, options = {}) {
   return issues;
 }
 
+// src/diagnostics/schemaWildcardDiagnostics.js
+function validateWildcardNamespace(namespace, path) {
+  if (!namespace) return null;
+  const trimmed = namespace.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(/\s+/);
+  for (const part of parts) {
+    if (part === "##any" || part === "##other" || part === "##targetNamespace") {
+      continue;
+    }
+    if (!part.includes(":") && part !== "") {
+      return createIssue({
+        code: "INVALID_WILDCARD_NAMESPACE",
+        severity: "warning",
+        message: `Invalid namespace in wildcard constraint: '${part}'. Expected ##any, ##other, ##targetNamespace, or a valid namespace URI.`,
+        path
+      });
+    }
+  }
+  return null;
+}
+function validateProcessContents(processContents, path) {
+  if (!processContents) return null;
+  const trimmed = processContents.trim();
+  if (trimmed === "strict" || trimmed === "lax" || trimmed === "skip") {
+    return null;
+  }
+  return createIssue({
+    code: "INVALID_PROCESS_CONTENTS",
+    severity: "error",
+    message: `Invalid processContents value: '${processContents}'. Must be 'strict', 'lax', or 'skip'.`,
+    path
+  });
+}
+function validateSingleWildcard(wildcardNode, nodeName) {
+  const issues = [];
+  const nsIssue = validateWildcardNamespace(wildcardNode.namespace, wildcardNode.path);
+  if (nsIssue) {
+    issues.push(nsIssue);
+  }
+  const pcIssue = validateProcessContents(wildcardNode.processContents, wildcardNode.path);
+  if (pcIssue) {
+    issues.push(pcIssue);
+  }
+  if (wildcardNode.notNamespace && wildcardNode.notNamespace.length > 0) {
+    if (wildcardNode.namespace !== "##other" && wildcardNode.namespace !== "##targetNamespace") {
+      issues.push(
+        createIssue({
+          code: "INVALID_NOT_NAMESPACE_USAGE",
+          severity: "warning",
+          message: `notNamespace is only meaningful with ##other or ##targetNamespace namespace constraint.`,
+          path: wildcardNode.path
+        })
+      );
+    }
+  }
+  if (wildcardNode.notQName && wildcardNode.notQName.length > 0) {
+    for (const qname of wildcardNode.notQName) {
+      if (!qname || qname.trim() === "") {
+        issues.push(
+          createIssue({
+            code: "INVALID_NOT_QNAME",
+            severity: "warning",
+            message: `Empty QName in notQName constraint.`,
+            path: wildcardNode.path
+          })
+        );
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function findWildcardsInContent(node, wildcards) {
+  if (!node) return;
+  if (node.kind === "any" || node.kind === "anyAttribute") {
+    wildcards.push(node);
+    return;
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      findWildcardsInContent(child, wildcards);
+    }
+  }
+}
+function findWildcardsInAttributes(attributes, wildcards) {
+  if (!attributes || !Array.isArray(attributes)) return;
+  for (const attr of attributes) {
+    if (attr.kind === "anyAttribute") {
+      wildcards.push(attr);
+    }
+  }
+}
+function runWildcardDiagnostics(schema) {
+  const issues = [];
+  const wildcards = [];
+  for (const elem of Object.values(schema.globals.elements || {})) {
+    if (elem.inlineType?.content) {
+      findWildcardsInContent(elem.inlineType.content, wildcards);
+    }
+    if (elem.inlineType?.attributes) {
+      findWildcardsInAttributes(elem.inlineType.attributes, wildcards);
+    }
+  }
+  for (const complexType of Object.values(schema.globals.complexTypes || {})) {
+    if (complexType.content) {
+      findWildcardsInContent(complexType.content, wildcards);
+    }
+    if (complexType.attributes) {
+      findWildcardsInAttributes(complexType.attributes, wildcards);
+    }
+  }
+  for (const group of Object.values(schema.globals.groups || {})) {
+    if (group.content) {
+      findWildcardsInContent(group.content, wildcards);
+    }
+  }
+  for (const wildcard of wildcards) {
+    const wildcardIssues = validateSingleWildcard(wildcard, wildcard.kind);
+    issues.push(...wildcardIssues);
+  }
+  return issues;
+}
+
 // src/diagnostics/schemaDiagnostics.js
 function buildStats(schema) {
   return {
@@ -2467,11 +3076,14 @@ function getSupportedFeatures(schema) {
         "element",
         "extension",
         "group",
+        "key",
+        "keyref",
         "restriction",
         "schema",
         "sequence",
         "simpleContent",
-        "simpleType"
+        "simpleType",
+        "unique"
       ].includes(name)
     ).map((name) => `xs:${name}`)
   );
@@ -2608,7 +3220,11 @@ function runSchemaDiagnostics(schema, options = {}) {
   checkMissingBaseTypes(schema, issues);
   checkUnknownGroups(schema, issues);
   checkUnknownAttributeGroups(schema, issues);
+  const identityIssues = runIdentityConstraintDiagnostics(schema);
+  issues.push(...identityIssues);
   emitUnsupportedFeatureWarnings(schema, issues, options);
+  const wildcardIssues = runWildcardDiagnostics(schema);
+  issues.push(...wildcardIssues);
   const facetIssues = runFacetDiagnostics(schema, options);
   issues.push(...facetIssues);
   const restrictionIssues = runRestrictionDiagnostics(schema);
@@ -2629,7 +3245,7 @@ function runSchemaDiagnostics(schema, options = {}) {
 }
 
 // src/version.js
-var ENGINE_VERSION = "v0.1.1";
+var ENGINE_VERSION = "v0.2.1";
 
 // src/utils/result.js
 function summarizeIssues(issues = []) {
@@ -2695,7 +3311,7 @@ function createTreeNode({
   refName = null,
   baseTypeName = null,
   derivation = null,
-  namespaceUri: namespaceUri3 = null,
+  namespaceUri: namespaceUri4 = null,
   minOccurs = 1,
   maxOccurs = 1,
   use = null,
@@ -2712,7 +3328,7 @@ function createTreeNode({
     refName,
     baseTypeName,
     derivation,
-    namespaceUri: namespaceUri3,
+    namespaceUri: namespaceUri4,
     minOccurs,
     maxOccurs,
     use,
@@ -2724,9 +3340,9 @@ function createTreeNode({
 }
 
 // src/tree/extractTree.js
-function buildQualifiedLabel(name, namespaceUri3) {
+function buildQualifiedLabel(name, namespaceUri4) {
   if (!name) return name;
-  return namespaceUri3 ? `{${namespaceUri3}} ${name}` : name;
+  return namespaceUri4 ? `{${namespaceUri4}} ${name}` : name;
 }
 function asArray2(value) {
   return Array.isArray(value) ? value : [];
@@ -3367,8 +3983,8 @@ function mergeAttributes(target, source) {
   Object.assign(target, source);
 }
 function qualifiedElementName(schema, elementDecl, state, isRoot = false) {
-  const localName3 = elementDecl.name || elementDecl.refName || "element";
-  const bare = localName3.includes(":") ? localName3.split(":")[1] : localName3;
+  const localName4 = elementDecl.name || elementDecl.refName || "element";
+  const bare = localName4.includes(":") ? localName4.split(":")[1] : localName4;
   const ns = elementDecl.namespaceUri;
   if (!ns) return bare;
   const prefix = state.nsContext.getPrefix(ns);
@@ -3517,6 +4133,24 @@ function buildNodesFromContent(schema, contentNode, options, state) {
 function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
   const content = getEffectiveContent(schema, complexTypeDecl);
   const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+  if (state.currentDepth >= options.maxDepth) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  const typeKey = complexTypeDecl.name || complexTypeDecl.qName;
+  if (typeKey && state.visitedTypes.has(typeKey)) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  if (typeKey) {
+    state.visitedTypes.add(typeKey);
+  }
+  const previousDepth = state.currentDepth;
+  state.currentDepth += 1;
   let children = content ? buildNodesFromContent(schema, content, options, state) : [];
   if (options.mode === "minimal" && children.length === 0 && content) {
     children = buildRepresentativeNodesFromContent(
@@ -3526,6 +4160,10 @@ function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
       state
     );
   }
+  state.currentDepth = previousDepth;
+  if (typeKey) {
+    state.visitedTypes.delete(typeKey);
+  }
   return {
     attributes: buildAttributesObject(schema, attributes, options, state),
     children
@@ -3604,7 +4242,10 @@ function selectRoot(schema, options = {}) {
 function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const normalizedOptions = {
     mode: options.mode === "full" ? "full" : "minimal",
-    includeOptionalAttributes: options.includeOptionalAttributes === true
+    includeOptionalAttributes: options.includeOptionalAttributes === true,
+    maxDepth: options.maxDepth ?? 3,
+    maxChoiceBranches: options.maxChoiceBranches ?? 1,
+    expandRepeatingElements: options.expandRepeatingElements ?? 2
   };
   const root = selectRoot(schema, options);
   if (!root) {
@@ -3617,7 +4258,9 @@ function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const state = {
     resolveAttributeGroup: helpers.resolveAttributeGroup,
     targetPrefix: options.targetPrefix || "tns",
-    nsContext
+    nsContext,
+    visitedTypes: /* @__PURE__ */ new Set(),
+    currentDepth: 0
   };
   const [rootNode] = buildElementInstances(
     schema,
@@ -3720,6 +4363,80 @@ function generateSampleXml({ xsdText, options = {} } = {}) {
   });
 }
 
+// src/validation/wildcardValidator.js
+function namespaceMatches(elementNamespace, wildcardNamespace, targetNamespace) {
+  if (!wildcardNamespace) return true;
+  if (wildcardNamespace === "##any") return true;
+  if (wildcardNamespace === "##targetNamespace") {
+    return elementNamespace === targetNamespace;
+  }
+  if (wildcardNamespace === "##other") {
+    return elementNamespace !== targetNamespace;
+  }
+  if (Array.isArray(wildcardNamespace)) {
+    return wildcardNamespace.includes(elementNamespace);
+  }
+  return elementNamespace === wildcardNamespace;
+}
+function isExcludedByNotNamespace(elementNamespace, notNamespace) {
+  if (!notNamespace || notNamespace.length === 0) return false;
+  return notNamespace.includes(elementNamespace);
+}
+function isExcludedByNotQName(qName, notQName) {
+  if (!notQName || notQName.length === 0) return false;
+  return notQName.includes(qName);
+}
+function buildQName(localName4, namespaceUri4) {
+  if (!namespaceUri4 || namespaceUri4 === "") {
+    return localName4;
+  }
+  return `{${namespaceUri4}}${localName4}`;
+}
+function elementMatchesWildcard(elementLocalName, elementNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "any") {
+    return false;
+  }
+  if (!namespaceMatches(elementNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(elementNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(elementLocalName, elementNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function attributeMatchesWildcard(attrLocalName, attrNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "anyAttribute") {
+    return false;
+  }
+  if (!namespaceMatches(attrNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(attrNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(attrLocalName, attrNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function normalizeProcessContents(processContents) {
+  if (processContents === "lax" || processContents === "skip") {
+    return processContents;
+  }
+  return "strict";
+}
+function isStrictWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "strict";
+}
+function shouldSkipWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "skip";
+}
+
 // src/validation/structureValidator.js
 function elementChildren2(xmlNode) {
   return Array.from(xmlNode?.children || []).filter((child) => child.nodeType === 1);
@@ -3789,6 +4506,7 @@ function isSimpleContentComplexType(complexTypeDecl) {
 function validateAttributes(xmlNode, attributes, context) {
   const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts, validateAttributeValue: validateAttributeValue2 } = context;
   const allowed = /* @__PURE__ */ new Map();
+  let anyAttributeWildcard = null;
   for (const attr of attributes || []) {
     if (!attr) continue;
     if (attr.kind === "attribute") {
@@ -3800,6 +4518,8 @@ function validateAttributes(xmlNode, attributes, context) {
       const group = context.resolveAttributeGroup?.(attr.refName);
       if (!group) continue;
       validateAttributes(xmlNode, group.attributes || [], context);
+    } else if (attr.kind === "anyAttribute") {
+      anyAttributeWildcard = attr;
     }
   }
   for (const attrDecl of allowed.values()) {
@@ -3845,6 +4565,15 @@ function validateAttributes(xmlNode, attributes, context) {
       continue;
     }
     if (!allowed.has(attr.name)) {
+      if (anyAttributeWildcard) {
+        const attrLocalName = attr.localName || attr.name.split(":")[1] || attr.name;
+        const attrNamespace = attr.namespaceURI || null;
+        if (attributeMatchesWildcard(attrLocalName, attrNamespace, anyAttributeWildcard, schema.targetNamespace)) {
+          if (!shouldSkipWildcardValidation(anyAttributeWildcard.processContents)) {
+          }
+          continue;
+        }
+      }
       issues.push(
         createIssue2({
           code: ISSUE_CODES2.XML_UNEXPECTED_ATTRIBUTE,
@@ -4262,7 +4991,16 @@ function validateContentModel(children, modelNode, context, pathParts, startInde
       return validateAll(children, startIndex, modelNode, context, pathParts, silent);
     case "any":
       if (startIndex < children.length) {
-        return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        const childNode = children[startIndex];
+        const childLocalName = localName(childNode);
+        const childNamespace = namespaceUri(childNode);
+        if (elementMatchesWildcard(childLocalName, childNamespace, modelNode, context.schema.targetNamespace)) {
+          if (isStrictWildcardValidation(modelNode.processContents)) {
+            validateElementDecl(childNode, { name: childLocalName, typeName: null }, context, [...pathParts, childLocalName]);
+          } else if (!shouldSkipWildcardValidation(modelNode.processContents)) {
+          }
+          return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        }
       }
       return { nextIndex: startIndex, matched: true, matchedAny: false };
     default:
@@ -4270,6 +5008,461 @@ function validateContentModel(children, modelNode, context, pathParts, startInde
   }
 }
 
+// src/utils/xpathEvaluator.js
+function nodeMatchesQName(schema, node, qName) {
+  if (!node || !qName) return false;
+  const parsed = parseQName(qName);
+  const expectedNs = resolveNamespaceUri(schema, parsed.prefix);
+  const nodeLocal = node.localName || node.nodeName || null;
+  const nodeNs = node.namespaceURI || null;
+  if (parsed.prefix) {
+    let nsToCompare = expectedNs || null;
+    if (!nsToCompare) {
+      if (typeof node.lookupNamespaceURI === "function") {
+        try {
+          nsToCompare = node.lookupNamespaceURI(parsed.prefix) || null;
+        } catch (e) {
+          nsToCompare = null;
+        }
+      }
+      if (!nsToCompare && node.prefix) {
+        return nodeLocal === parsed.localName && node.prefix === parsed.prefix;
+      }
+    }
+    return nodeLocal === parsed.localName && (nodeNs || null) === (nsToCompare || null);
+  }
+  return nodeLocal === parsed.localName;
+}
+function collectDescendants(node, predicate) {
+  const matches = [];
+  function traverse(n) {
+    if (!n || n.nodeType !== 1) return;
+    if (predicate(n)) matches.push(n);
+    for (const child of Array.from(n.childNodes || [])) {
+      traverse(child);
+    }
+  }
+  traverse(node);
+  return matches;
+}
+function evaluateSelector(schema, startNodes, selectorXPath) {
+  if (!selectorXPath || !Array.isArray(startNodes) || startNodes.length === 0) return [];
+  let xpath = selectorXPath.trim();
+  if (xpath.startsWith("./")) xpath = xpath.slice(2);
+  if (xpath === "." || xpath === "") return startNodes;
+  if (xpath.includes("//")) {
+    return evaluateSelectorWithDescendant(schema, startNodes, xpath);
+  }
+  const segments = xpath.split("/");
+  let nodes = startNodes;
+  for (const raw of segments) {
+    if (!raw || raw === ".") continue;
+    const m = raw.match(/^([^\[]+)(?:\[(.+)\])?$/);
+    if (!m) return [];
+    const step = m[1];
+    const predicate = m[2] || null;
+    if (step === "*") {
+      nodes = nodes.flatMap((n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1));
+    } else if (step.startsWith("@")) {
+      return [];
+    } else {
+      nodes = nodes.flatMap(
+        (n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1).filter((c) => {
+          return nodeMatchesQName(schema, c, step);
+        })
+      );
+      if (predicate && nodes.length) {
+        const num = Number(predicate);
+        if (Number.isInteger(num) && num > 0) {
+          const idx = num - 1;
+          nodes = nodes.length > idx ? [nodes[idx]] : [];
+        } else {
+          const attrMatch = predicate.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+          if (attrMatch) {
+            const attrName = attrMatch[1];
+            const attrValue = attrMatch[2];
+            nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+          } else {
+            nodes = [];
+          }
+        }
+      }
+    }
+  }
+  return nodes;
+}
+function evaluateSelectorWithDescendant(schema, startNodes, xpath) {
+  const fullParts = xpath.split(/\/\//);
+  let nodes = startNodes;
+  for (let partIdx = 0; partIdx < fullParts.length; partIdx++) {
+    const part = fullParts[partIdx].trim();
+    if (!part) continue;
+    if (partIdx === 0) {
+      if (part !== ".") {
+        const segments = part.split("/");
+        for (const seg of segments) {
+          if (!seg || seg === ".") continue;
+          const m = seg.match(/^([^\[]+)(?:\[(.+)\])?$/);
+          if (!m) return [];
+          const step = m[1];
+          const predicate = m[2] || null;
+          if (step === "*") {
+            nodes = nodes.flatMap((n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1));
+          } else if (step.startsWith("@")) {
+            return [];
+          } else {
+            nodes = nodes.flatMap(
+              (n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1).filter((c) => nodeMatchesQName(schema, c, step))
+            );
+            if (predicate && nodes.length) {
+              const num = Number(predicate);
+              if (Number.isInteger(num) && num > 0) {
+                const idx = num - 1;
+                nodes = nodes.length > idx ? [nodes[idx]] : [];
+              } else {
+                const attrMatch = predicate.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+                if (attrMatch) {
+                  const attrName = attrMatch[1];
+                  const attrValue = attrMatch[2];
+                  nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+                } else {
+                  nodes = [];
+                }
+              }
+            }
+          }
+        }
+      }
+    } else {
+      const segments = part.split("/");
+      for (let segIdx = 0; segIdx < segments.length; segIdx++) {
+        const segment = segments[segIdx];
+        if (!segment || segment === ".") continue;
+        const m = segment.match(/^([^\[]+)(?:\[(.+)\])?$/);
+        if (!m) return [];
+        const step = m[1];
+        const predicate = m[2] || null;
+        if (segIdx === 0) {
+          const descendants = [];
+          for (const node of nodes) {
+            const matches = collectDescendants(node, (n) => {
+              if (step === "*") return true;
+              if (step.startsWith("@")) return false;
+              return nodeMatchesQName(schema, n, step);
+            });
+            descendants.push(...matches);
+          }
+          nodes = descendants;
+          if (predicate && nodes.length) {
+            const predicateMatch = predicate.match(/^\[(.+)\]$/);
+            if (predicateMatch) {
+              const pred = predicateMatch[1];
+              const num = Number(pred);
+              if (Number.isInteger(num) && num > 0) {
+                const idx = num - 1;
+                nodes = nodes.length > idx ? [nodes[idx]] : [];
+              } else {
+                const attrMatch = pred.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+                if (attrMatch) {
+                  const attrName = attrMatch[1];
+                  const attrValue = attrMatch[2];
+                  nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+                } else {
+                  nodes = [];
+                }
+              }
+            }
+          }
+        } else {
+          nodes = nodes.flatMap(
+            (n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1).filter((c) => {
+              if (step === "*") return true;
+              if (step.startsWith("@")) return false;
+              return nodeMatchesQName(schema, c, step);
+            })
+          );
+          if (predicate && nodes.length) {
+            const predicateMatch = predicate.match(/^\[(.+)\]$/);
+            if (predicateMatch) {
+              const pred = predicateMatch[1];
+              const num = Number(pred);
+              if (Number.isInteger(num) && num > 0) {
+                const idx = num - 1;
+                nodes = nodes.length > idx ? [nodes[idx]] : [];
+              } else {
+                const attrMatch = pred.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+                if (attrMatch) {
+                  const attrName = attrMatch[1];
+                  const attrValue = attrMatch[2];
+                  nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+                } else {
+                  nodes = [];
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (!nodes.length && partIdx < fullParts.length - 1) {
+      return [];
+    }
+  }
+  return nodes;
+}
+function evaluateField(schema, contextNode, fieldXPath) {
+  if (!fieldXPath || !contextNode) return null;
+  let xpath = fieldXPath.trim();
+  if (xpath.startsWith("./")) xpath = xpath.slice(2);
+  if (xpath === ".") return (contextNode.textContent || "").trim() || null;
+  if (xpath.startsWith("@")) {
+    const attr = xpath.slice(1);
+    return contextNode.getAttribute(attr) ?? null;
+  }
+  if (xpath.includes("//")) {
+    return evaluateFieldWithDescendant(schema, contextNode, xpath);
+  }
+  const segments = xpath.split("/");
+  let nodes = [contextNode];
+  for (let i = 0; i < segments.length; i += 1) {
+    const raw = segments[i];
+    if (!raw || raw === ".") continue;
+    const m = raw.match(/^([^\[]+)(?:\[(.+)\])?$/);
+    if (!m) return null;
+    const step = m[1];
+    const predicate = m[2] || null;
+    if (step.startsWith("@")) {
+      if (i !== segments.length - 1) return null;
+      return nodes[0]?.getAttribute(step.slice(1)) ?? null;
+    }
+    nodes = nodes.flatMap(
+      (n) => Array.from(n.childNodes || []).filter((c) => c.nodeType === 1 && nodeMatchesQName(schema, c, step))
+    );
+    if (!nodes.length) return null;
+    if (predicate) {
+      const num = Number(predicate);
+      if (Number.isInteger(num) && num > 0) {
+        const idx = num - 1;
+        nodes = nodes.length > idx ? [nodes[idx]] : [];
+      } else {
+        const attrMatch = predicate.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+        if (attrMatch) {
+          const attrName = attrMatch[1];
+          const attrValue = attrMatch[2];
+          nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+        } else {
+          return null;
+        }
+      }
+    }
+  }
+  const v = nodes[0];
+  if (!v) return null;
+  return (v.textContent || "").trim() || null;
+}
+function evaluateFieldWithDescendant(schema, contextNode, xpath) {
+  const parts = xpath.split(/\/\//);
+  let nodes = [contextNode];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i].trim();
+    if (!part) continue;
+    if (i === 0) {
+      if (part !== "." && part !== "") {
+        const val = evaluateField(schema, nodes[0], part);
+        if (val !== null) return val;
+        nodes = [];
+      }
+    } else {
+      const m = part.match(/^([^\[]+)(?:\[(.+)\])?/);
+      if (!m) return null;
+      const step = m[1];
+      const predicate = part.slice(m[0].length);
+      if (step.startsWith("@")) {
+        const attrName = step.slice(1);
+        for (const node of nodes) {
+          const descendants2 = collectDescendants(node, () => true);
+          if (descendants2.length) {
+            return descendants2[0]?.getAttribute(attrName) ?? null;
+          }
+        }
+        return null;
+      }
+      const descendants = [];
+      for (const node of nodes) {
+        descendants.push(
+          ...collectDescendants(node, (n) => {
+            if (step === "*") return true;
+            return nodeMatchesQName(schema, n, step);
+          })
+        );
+      }
+      nodes = descendants;
+      if (!nodes.length) return null;
+      if (predicate) {
+        const predicateMatch = predicate.match(/^\[(.+)\]$/);
+        if (predicateMatch) {
+          const pred = predicateMatch[1];
+          const num = Number(pred);
+          if (Number.isInteger(num) && num > 0) {
+            const idx = num - 1;
+            nodes = nodes.length > idx ? [nodes[idx]] : [];
+          } else {
+            const attrMatch = pred.match(/^@([A-Za-z_][\w.-]*)=['"](.*)['"]$/);
+            if (attrMatch) {
+              const attrName = attrMatch[1];
+              const attrValue = attrMatch[2];
+              nodes = nodes.filter((n) => (n.getAttribute(attrName) || "") === attrValue);
+            }
+          }
+        }
+      }
+      if (nodes.length) {
+        const v = nodes[0];
+        return (v.textContent || "").trim() || null;
+      }
+    }
+  }
+  return null;
+}
+
+// src/validation/identityConstraintValidator.js
+function localName2(node) {
+  return node?.localName || node?.nodeName || null;
+}
+function namespaceUri2(node) {
+  return node?.namespaceURI || null;
+}
+function collectOwnerXmlNodes(xmlRoot, ownerName, ownerNamespaceUri) {
+  const matches = [];
+  function traverse(node) {
+    if (!node || node.nodeType !== 1) return;
+    if (localName2(node) === ownerName && (ownerNamespaceUri == null || ownerNamespaceUri === namespaceUri2(node))) {
+      matches.push(node);
+    }
+    for (const child of Array.from(node.children || [])) {
+      traverse(child);
+    }
+  }
+  traverse(xmlRoot);
+  return matches;
+}
+function getConstraintOwnerNodes(schema, xmlRoot, constraint) {
+  if (!constraint.ownerName) {
+    return [xmlRoot];
+  }
+  return collectOwnerXmlNodes(
+    xmlRoot,
+    constraint.ownerName,
+    constraint.ownerNamespaceUri
+  );
+}
+function validateIdentityConstraints(schema, xmlRoot, getNodeLocation) {
+  const issues = [];
+  const keySets = /* @__PURE__ */ new Map();
+  function buildKeySet(constraint) {
+    if (keySets.has(constraint.name)) {
+      return keySets.get(constraint.name);
+    }
+    const set = /* @__PURE__ */ new Set();
+    const ownerNodes = getConstraintOwnerNodes(schema, xmlRoot, constraint);
+    for (const ownerNode of ownerNodes) {
+      const selected = evaluateSelector(schema, [ownerNode], constraint.selector?.xpath);
+      for (const selectedNode of selected) {
+        const tuple = constraint.fields.map((field) => evaluateField(schema, selectedNode, field.xpath));
+        set.add(JSON.stringify(tuple));
+      }
+    }
+    keySets.set(constraint.name, set);
+    return set;
+  }
+  for (const constraint of schema.identityConstraints || []) {
+    const ownerNodes = getConstraintOwnerNodes(schema, xmlRoot, constraint);
+    if (!ownerNodes.length) {
+      continue;
+    }
+    const valueIndex = /* @__PURE__ */ new Map();
+    const referenceKeyConstraint = schema.identityConstraints.find(
+      (item) => item.kind === "key" && item.name === parseQName(constraint.refer || "").localName
+    );
+    const referenceKeySet = constraint.kind === "keyref" && referenceKeyConstraint ? buildKeySet(referenceKeyConstraint) : null;
+    for (const ownerNode of ownerNodes) {
+      const selected = evaluateSelector(schema, [ownerNode], constraint.selector?.xpath);
+      for (const selectedNode of selected) {
+        const tuple = constraint.fields.map((field) => evaluateField(schema, selectedNode, field.xpath));
+        const tupleKey = JSON.stringify(tuple);
+        const rawLocation = getNodeLocation ? getNodeLocation(selectedNode) : null;
+        const location = rawLocation || { line: constraint.line || 1, column: constraint.column || 1 };
+        if (tuple.some((value) => value == null || value === "")) {
+          if (constraint.kind === "key") {
+            issues.push(
+              createIssue({
+                code: ISSUE_CODES.XML_KEY_NULL_VIOLATION,
+                severity: "error",
+                message: `xs:key '${constraint.name}' requires non-empty values for all fields.`,
+                line: location.line,
+                column: location.column,
+                path: constraint.path,
+                source: "xml",
+                nodeKind: "element",
+                name: constraint.name,
+                details: {
+                  selector: constraint.selector?.xpath,
+                  fields: constraint.fields.map((field) => field.xpath)
+                }
+              })
+            );
+          }
+        }
+        if (constraint.kind === "key" || constraint.kind === "unique") {
+          if (valueIndex.has(tupleKey)) {
+            issues.push(
+              createIssue({
+                code: constraint.kind === "key" ? ISSUE_CODES.XML_KEY_VIOLATION : ISSUE_CODES.XML_UNIQUE_VIOLATION,
+                severity: "error",
+                message: `Duplicate ${constraint.kind} value for '${constraint.name}'.`,
+                line: location.line,
+                column: location.column,
+                path: constraint.path,
+                source: "xml",
+                nodeKind: "element",
+                name: constraint.name,
+                details: {
+                  selector: constraint.selector?.xpath,
+                  fields: constraint.fields.map((field) => field.xpath)
+                }
+              })
+            );
+          }
+          valueIndex.set(tupleKey, true);
+        }
+        if (constraint.kind === "keyref" && referenceKeySet) {
+          if (!referenceKeySet.has(tupleKey)) {
+            issues.push(
+              createIssue({
+                code: ISSUE_CODES.XML_KEYREF_VIOLATION,
+                severity: "error",
+                message: `xs:keyref '${constraint.name}' references a missing key value.`,
+                line: location.line,
+                column: location.column,
+                path: constraint.path,
+                source: "xml",
+                nodeKind: "element",
+                name: constraint.name,
+                details: {
+                  refer: constraint.refer,
+                  selector: constraint.selector?.xpath,
+                  fields: constraint.fields.map((field) => field.xpath)
+                }
+              })
+            );
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
+
 // src/validation/builtinTypeValidators.js
 function isIntegerString(value) {
   return /^[-+]?\d+$/.test(value);
@@ -4767,12 +5960,12 @@ function findAttributeValueOffset(tagText, attrName) {
   const end = tagText.indexOf(quoteChar, start);
   return end >= start ? start : -1;
 }
-function findTextContentOffset(text, tagEndOffset, localName3) {
+function findTextContentOffset(text, tagEndOffset, localName4) {
   let i = tagEndOffset + 1;
   while (i < text.length && /\s/.test(text[i])) {
     i += 1;
   }
-  if (text.startsWith(`</${localName3}`, i) || text[i] === "<") {
+  if (text.startsWith(`</${localName4}`, i) || text[i] === "<") {
     return -1;
   }
   return i < text.length ? i : -1;
@@ -4799,10 +5992,20 @@ function createXmlSourceLocator(xmlText, xmlDocument) {
       }
     };
   }
-  const orderedNodes = [
-    documentElement,
-    ...Array.from(documentElement.querySelectorAll("*"))
-  ];
+  let orderedNodes = null;
+  if (typeof documentElement.querySelectorAll === "function") {
+    orderedNodes = [documentElement, ...Array.from(documentElement.querySelectorAll("*"))];
+  } else {
+    let collect = function(node) {
+      if (!node || node.nodeType !== 1) return;
+      orderedNodes.push(node);
+      for (const child of Array.from(node.children || [])) {
+        collect(child);
+      }
+    };
+    orderedNodes = [];
+    collect(documentElement);
+  }
   let searchFrom = 0;
   for (const node of orderedNodes) {
     const expectedLocalName = getNodeLocalName(node);
@@ -4879,10 +6082,10 @@ function elementChildren3(xmlNode) {
     (child) => child.nodeType === 1
   );
 }
-function localName2(node) {
+function localName3(node) {
   return node?.localName || node?.nodeName || null;
 }
-function namespaceUri2(node) {
+function namespaceUri3(node) {
   return node?.namespaceURI || null;
 }
 function determineRootElement(schema, xmlRootName, xmlRootNs, options) {
@@ -4927,8 +6130,8 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
   }
   const locator = createXmlSourceLocator(xmlText, xmlParse.document);
   const xmlRoot = xmlParse.document.documentElement;
-  const xmlRootName = localName2(xmlRoot);
-  const xmlRootNs = namespaceUri2(xmlRoot);
+  const xmlRootName = localName3(xmlRoot);
+  const xmlRootNs = namespaceUri3(xmlRoot);
   const issues = [...parseIssues];
   if (!xmlRoot) {
     return {
@@ -5048,7 +6251,7 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
       const children2 = elementChildren3(xmlRoot);
       if (children2.length > 0) {
         for (const childNode of children2) {
-          const childName = localName2(childNode);
+          const childName = localName3(childNode);
           issues.push(
             createIssue({
               code: ISSUE_CODES.XML_UNEXPECTED_ELEMENT,
@@ -5060,7 +6263,7 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
               nodeKind: "element",
               name: childName,
               details: {
-                namespaceUri: namespaceUri2(childNode)
+                namespaceUri: namespaceUri3(childNode)
               }
             })
           );
@@ -5137,7 +6340,7 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
       if (result.nextIndex < children.length) {
         for (let i = result.nextIndex; i < children.length; i += 1) {
           const childNode = children[i];
-          const childName = localName2(childNode);
+          const childName = localName3(childNode);
           issues.push(
             createIssue({
               code: ISSUE_CODES.XML_UNEXPECTED_ELEMENT,
@@ -5149,7 +6352,7 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
               nodeKind: "element",
               name: childName,
               details: {
-                namespaceUri: namespaceUri2(childNode)
+                namespaceUri: namespaceUri3(childNode)
               }
             })
           );
@@ -5180,6 +6383,12 @@ function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
       );
     }
   }
+  const identityConstraintIssues = validateIdentityConstraints(
+    schema,
+    xmlRoot,
+    locator.getNodeLocation
+  );
+  issues.push(...identityConstraintIssues);
   return {
     data: {
       xmlValid: !issues.some((issue) => issue.severity === "error")