uss-xsd-engine 0.1.1 → 0.2.1

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

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.1.1
+ * uss-xsd-engine v0.2.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -72,6 +72,10 @@ var UssXsdEngine = (() => {
     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",
@@ -88,6 +92,12 @@ var UssXsdEngine = (() => {
     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",
@@ -114,6 +124,9 @@ var UssXsdEngine = (() => {
     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",
@@ -189,6 +202,7 @@ var UssXsdEngine = (() => {
       },
       importedSchemas: [],
       roots: [],
+      identityConstraints: [],
       references: {
         types: [],
         refs: [],
@@ -220,7 +234,7 @@ var UssXsdEngine = (() => {
   function createElementDecl({
     name = null,
     qName = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     typeName = null,
     refName = null,
     inlineType = null,
@@ -229,6 +243,7 @@ var UssXsdEngine = (() => {
     defaultValue = null,
     fixedValue = null,
     nillable = false,
+    identityConstraints = [],
     line = null,
     column = null,
     path = null
@@ -237,7 +252,7 @@ var UssXsdEngine = (() => {
       kind: "element",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       typeName,
       refName,
       inlineType,
@@ -246,6 +261,7 @@ var UssXsdEngine = (() => {
       defaultValue,
       fixedValue,
       nillable,
+      identityConstraints,
       line,
       column,
       path
@@ -254,7 +270,7 @@ var UssXsdEngine = (() => {
   function createAttributeDecl({
     name = null,
     qName = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     typeName = null,
     refName = null,
     inlineType = null,
@@ -269,7 +285,7 @@ var UssXsdEngine = (() => {
       kind: "attribute",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       typeName,
       refName,
       inlineType,
@@ -284,13 +300,14 @@ var UssXsdEngine = (() => {
   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
@@ -299,13 +316,14 @@ var UssXsdEngine = (() => {
       kind: "complexType",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       content,
       attributes,
       derivation,
       contentModel,
       mixed,
       abstract,
+      identityConstraints,
       line,
       column,
       path
@@ -314,7 +332,7 @@ var UssXsdEngine = (() => {
   function createSimpleTypeDecl({
     name = null,
     qName = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     baseTypeName = null,
     facets = {},
     enumerations = [],
@@ -326,7 +344,7 @@ var UssXsdEngine = (() => {
       kind: "simpleType",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       baseTypeName,
       facets,
       enumerations,
@@ -338,7 +356,7 @@ var UssXsdEngine = (() => {
   function createGroupDecl({
     name,
     qName = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     content = null,
     line = null,
     column = null,
@@ -348,7 +366,7 @@ var UssXsdEngine = (() => {
       kind: "group",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       content,
       line,
       column,
@@ -358,7 +376,7 @@ var UssXsdEngine = (() => {
   function createAttributeGroupDecl({
     name,
     qName = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     attributes = [],
     line = null,
     column = null,
@@ -368,7 +386,7 @@ var UssXsdEngine = (() => {
       kind: "attributeGroup",
       name,
       qName,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       attributes,
       line,
       column,
@@ -389,6 +407,37 @@ var UssXsdEngine = (() => {
       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,
@@ -463,9 +512,11 @@ var UssXsdEngine = (() => {
   }
   function createAnyNode({
     namespace = null,
-    processContents = null,
+    processContents = "strict",
     minOccurs = 1,
     maxOccurs = 1,
+    notNamespace = [],
+    notQName = [],
     line = null,
     column = null,
     path = null
@@ -473,9 +524,31 @@ var UssXsdEngine = (() => {
     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
@@ -560,8 +633,8 @@ var UssXsdEngine = (() => {
       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);
@@ -577,41 +650,41 @@ var UssXsdEngine = (() => {
   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;
@@ -623,14 +696,14 @@ var UssXsdEngine = (() => {
           bucketName,
           importedSchema,
           importedNs,
-          localName3
+          localName4
         );
         if (direct) return direct;
       }
       const nested = lookupInImportedSchemasForUnprefixed(
         bucketName,
         importedSchema,
-        localName3,
+        localName4,
         visited
       );
       if (nested) return nested;
@@ -641,24 +714,24 @@ var UssXsdEngine = (() => {
     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) {
@@ -666,13 +739,13 @@ var UssXsdEngine = (() => {
         bucketName,
         schema,
         sameSchemaNs,
-        localName3
+        localName4
       );
       if (hostNamespaceDecl) return hostNamespaceDecl;
       const importedSameNamespaceDecl = lookupInImportedSchemasForUnprefixed(
         bucketName,
         schema,
-        localName3
+        localName4
       );
       if (importedSameNamespaceDecl) return importedSameNamespaceDecl;
     }
@@ -800,11 +873,6 @@ var UssXsdEngine = (() => {
 
   // src/parser/buildSchemaModel.js
   var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-    "key",
-    "keyref",
-    "unique",
-    "any",
-    "anyAttribute",
     "redefine",
     "notation"
   ]);
@@ -867,6 +935,9 @@ var UssXsdEngine = (() => {
       ...sourceSchema.externalRefs.imports || []
     );
     targetSchema.importedSchemas.push(...sourceSchema.importedSchemas || []);
+    targetSchema.identityConstraints.push(
+      ...sourceSchema.identityConstraints || []
+    );
     for (const feature of sourceSchema.usedFeatures || []) {
       targetSchema.usedFeatures.add(feature);
     }
@@ -919,17 +990,17 @@ var UssXsdEngine = (() => {
   }
   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");
@@ -952,9 +1023,9 @@ var UssXsdEngine = (() => {
     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({
@@ -981,15 +1052,15 @@ var UssXsdEngine = (() => {
     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
       });
     }
@@ -999,7 +1070,7 @@ var UssXsdEngine = (() => {
         line: loc.line,
         column: loc.column,
         path,
-        nodeKind: localName3,
+        nodeKind: localName4,
         name: node.getAttribute("name") || null
       });
     }
@@ -1009,47 +1080,47 @@ var UssXsdEngine = (() => {
         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
       });
     }
@@ -1065,13 +1136,13 @@ var UssXsdEngine = (() => {
           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,
@@ -1081,7 +1152,7 @@ var UssXsdEngine = (() => {
           column: loc.column,
           path,
           source: "xsd",
-          nodeKind: localName3,
+          nodeKind: localName4,
           name: node.getAttribute("name") || node.getAttribute("ref") || null,
           details: {
             defaultValue: node.getAttribute("default"),
@@ -1162,11 +1233,11 @@ var UssXsdEngine = (() => {
       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,
@@ -1191,11 +1262,11 @@ var UssXsdEngine = (() => {
       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,
@@ -1236,6 +1307,10 @@ var UssXsdEngine = (() => {
             issues
           )
         );
+      } else if (child.localName === "anyAttribute") {
+        attributes.push(
+          parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+        );
       }
     }
     return attributes;
@@ -1272,11 +1347,26 @@ var UssXsdEngine = (() => {
       );
     }
     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,
@@ -1285,6 +1375,7 @@ var UssXsdEngine = (() => {
       defaultValue: node.getAttribute("default"),
       fixedValue: node.getAttribute("fixed"),
       nillable: node.getAttribute("nillable") === "true",
+      identityConstraints,
       line: loc.line,
       column: loc.column,
       path
@@ -1303,20 +1394,101 @@ var UssXsdEngine = (() => {
       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);
@@ -1463,6 +1635,22 @@ var UssXsdEngine = (() => {
     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
@@ -1522,17 +1710,17 @@ var UssXsdEngine = (() => {
       );
     }
     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
@@ -1546,11 +1734,11 @@ var UssXsdEngine = (() => {
       (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,
@@ -1572,11 +1760,11 @@ var UssXsdEngine = (() => {
       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,
@@ -1680,24 +1868,24 @@ var UssXsdEngine = (() => {
       }
     }
     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
         };
       }
     }
@@ -2314,6 +2502,115 @@ var UssXsdEngine = (() => {
       }
     }
   }
+  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 || {})) {
@@ -2323,6 +2620,12 @@ var UssXsdEngine = (() => {
       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;
   }
@@ -2359,6 +2662,188 @@ var UssXsdEngine = (() => {
     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;
@@ -2467,6 +2952,130 @@ var UssXsdEngine = (() => {
     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 {
@@ -2494,11 +3103,14 @@ var UssXsdEngine = (() => {
           "element",
           "extension",
           "group",
+          "key",
+          "keyref",
           "restriction",
           "schema",
           "sequence",
           "simpleContent",
-          "simpleType"
+          "simpleType",
+          "unique"
         ].includes(name)
       ).map((name) => `xs:${name}`)
     );
@@ -2635,7 +3247,11 @@ var UssXsdEngine = (() => {
     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);
@@ -2656,7 +3272,7 @@ var UssXsdEngine = (() => {
   }
 
   // src/version.js
-  var ENGINE_VERSION = "v0.1.1";
+  var ENGINE_VERSION = "v0.2.1";
 
   // src/utils/result.js
   function summarizeIssues(issues = []) {
@@ -2722,7 +3338,7 @@ var UssXsdEngine = (() => {
     refName = null,
     baseTypeName = null,
     derivation = null,
-    namespaceUri: namespaceUri3 = null,
+    namespaceUri: namespaceUri4 = null,
     minOccurs = 1,
     maxOccurs = 1,
     use = null,
@@ -2739,7 +3355,7 @@ var UssXsdEngine = (() => {
       refName,
       baseTypeName,
       derivation,
-      namespaceUri: namespaceUri3,
+      namespaceUri: namespaceUri4,
       minOccurs,
       maxOccurs,
       use,
@@ -2751,9 +3367,9 @@ var UssXsdEngine = (() => {
   }
 
   // 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 : [];
@@ -3394,8 +4010,8 @@ var UssXsdEngine = (() => {
     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);
@@ -3544,6 +4160,24 @@ var UssXsdEngine = (() => {
   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(
@@ -3553,6 +4187,10 @@ var UssXsdEngine = (() => {
         state
       );
     }
+    state.currentDepth = previousDepth;
+    if (typeKey) {
+      state.visitedTypes.delete(typeKey);
+    }
     return {
       attributes: buildAttributesObject(schema, attributes, options, state),
       children
@@ -3631,7 +4269,10 @@ var UssXsdEngine = (() => {
   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) {
@@ -3644,7 +4285,9 @@ var UssXsdEngine = (() => {
     const state = {
       resolveAttributeGroup: helpers.resolveAttributeGroup,
       targetPrefix: options.targetPrefix || "tns",
-      nsContext
+      nsContext,
+      visitedTypes: /* @__PURE__ */ new Set(),
+      currentDepth: 0
     };
     const [rootNode] = buildElementInstances(
       schema,
@@ -3747,6 +4390,80 @@ ${writeNode(rootNode, 0)}`;
     });
   }
 
+  // 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);
@@ -3816,6 +4533,7 @@ ${writeNode(rootNode, 0)}`;
   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") {
@@ -3827,6 +4545,8 @@ ${writeNode(rootNode, 0)}`;
         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()) {
@@ -3872,6 +4592,15 @@ ${writeNode(rootNode, 0)}`;
         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,
@@ -4289,7 +5018,16 @@ ${writeNode(rootNode, 0)}`;
         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:
@@ -4297,6 +5035,461 @@ ${writeNode(rootNode, 0)}`;
     }
   }
 
+  // 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);
@@ -4794,12 +5987,12 @@ ${writeNode(rootNode, 0)}`;
     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;
@@ -4826,10 +6019,20 @@ ${writeNode(rootNode, 0)}`;
         }
       };
     }
-    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);
@@ -4906,10 +6109,10 @@ ${writeNode(rootNode, 0)}`;
       (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) {
@@ -4954,8 +6157,8 @@ ${writeNode(rootNode, 0)}`;
     }
     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 {
@@ -5075,7 +6278,7 @@ ${writeNode(rootNode, 0)}`;
         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,
@@ -5087,7 +6290,7 @@ ${writeNode(rootNode, 0)}`;
                 nodeKind: "element",
                 name: childName,
                 details: {
-                  namespaceUri: namespaceUri2(childNode)
+                  namespaceUri: namespaceUri3(childNode)
                 }
               })
             );
@@ -5164,7 +6367,7 @@ ${writeNode(rootNode, 0)}`;
         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,
@@ -5176,7 +6379,7 @@ ${writeNode(rootNode, 0)}`;
                 nodeKind: "element",
                 name: childName,
                 details: {
-                  namespaceUri: namespaceUri2(childNode)
+                  namespaceUri: namespaceUri3(childNode)
                 }
               })
             );
@@ -5207,6 +6410,12 @@ ${writeNode(rootNode, 0)}`;
         );
       }
     }
+    const identityConstraintIssues = validateIdentityConstraints(
+      schema,
+      xmlRoot,
+      locator.getNodeLocation
+    );
+    issues.push(...identityConstraintIssues);
     return {
       data: {
         xmlValid: !issues.some((issue) => issue.severity === "error")