uss-xsd-engine 0.2.0 → 0.2.1

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

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.2.0
+ * uss-xsd-engine v0.2.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -96,6 +96,8 @@ var UssXsdEngine = (() => {
     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",
@@ -122,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",
@@ -507,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
@@ -517,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
@@ -844,8 +873,6 @@ var UssXsdEngine = (() => {
 
   // src/parser/buildSchemaModel.js
   var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-    "any",
-    "anyAttribute",
     "redefine",
     "notation"
   ]);
@@ -1280,6 +1307,10 @@ var UssXsdEngine = (() => {
             issues
           )
         );
+      } else if (child.localName === "anyAttribute") {
+        attributes.push(
+          parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+        );
       }
     }
     return attributes;
@@ -1363,15 +1394,58 @@ 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
@@ -1794,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
         };
       }
     }
@@ -2428,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 || {})) {
@@ -2437,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;
   }
@@ -2763,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 {
@@ -2937,6 +3250,8 @@ var UssXsdEngine = (() => {
     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);
@@ -2957,7 +3272,7 @@ var UssXsdEngine = (() => {
   }
 
   // src/version.js
-  var ENGINE_VERSION = "v0.2.0";
+  var ENGINE_VERSION = "v0.2.1";
 
   // src/utils/result.js
   function summarizeIssues(issues = []) {
@@ -3845,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(
@@ -3854,6 +4187,10 @@ var UssXsdEngine = (() => {
         state
       );
     }
+    state.currentDepth = previousDepth;
+    if (typeKey) {
+      state.visitedTypes.delete(typeKey);
+    }
     return {
       attributes: buildAttributesObject(schema, attributes, options, state),
       children
@@ -3932,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) {
@@ -3945,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,
@@ -4048,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);
@@ -4117,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") {
@@ -4128,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()) {
@@ -4173,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,
@@ -4590,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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uss-xsd-engine",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Browser-first XSD engine for schema diagnostics, tree extraction, sample XML generation, and XML validation.",
   "type": "module",
   "main": "dist/uss-xsd-engine.esm.js",