uss-xsd-engine 0.2.0 → 0.2.2

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

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.2.0
+ * uss-xsd-engine v0.2.2
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -69,6 +69,8 @@ var ISSUE_CODES = {
   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",
@@ -95,10 +97,15 @@ var ISSUE_CODES = {
   XSD_RESTRICTION_NOT_SUBSET: "XSD_RESTRICTION_NOT_SUBSET",
   XSD_RESTRICTION_OCCURS_WIDENED: "XSD_RESTRICTION_OCCURS_WIDENED",
   XSD_RESTRICTION_ATTRIBUTE_WIDENED: "XSD_RESTRICTION_ATTRIBUTE_WIDENED",
+  XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE: "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+  XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE: "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+  XSD_RESTRICTION_WILDCARD_INCOMPATIBLE: "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
   XSD_INCLUDE_NOT_PROVIDED: "XSD_INCLUDE_NOT_PROVIDED",
   XSD_IMPORT_NOT_PROVIDED: "XSD_IMPORT_NOT_PROVIDED",
   XSD_INCLUDE_NAMESPACE_MISMATCH: "XSD_INCLUDE_NAMESPACE_MISMATCH",
-  XSD_IMPORT_NAMESPACE_MISMATCH: "XSD_IMPORT_NAMESPACE_MISMATCH"
+  XSD_IMPORT_NAMESPACE_MISMATCH: "XSD_IMPORT_NAMESPACE_MISMATCH",
+  XSD_REDEFINE_NAMESPACE_MISMATCH: "XSD_REDEFINE_NAMESPACE_MISMATCH",
+  REDEFINE_INVALID_OVERRIDE: "REDEFINE_INVALID_OVERRIDE"
 };
 
 // src/parser/parseXsd.js
@@ -151,6 +158,7 @@ function createEmptySchemaModel() {
     targetNamespace: null,
     elementFormDefault: null,
     attributeFormDefault: null,
+    schemaVersion: null,
     namespaces: {
       default: null,
       prefixes: /* @__PURE__ */ Object.create(null)
@@ -166,7 +174,8 @@ function createEmptySchemaModel() {
     documents: [],
     externalRefs: {
       includes: [],
-      imports: []
+      imports: [],
+      redefines: []
     },
     importedSchemas: [],
     roots: [],
@@ -199,6 +208,16 @@ function normalizeUse(value) {
   }
   return null;
 }
+function createAnnotation({
+  documentation = null,
+  appinfo = null
+} = {}) {
+  return {
+    kind: "annotation",
+    documentation,
+    appinfo
+  };
+}
 function createElementDecl({
   name = null,
   qName = null,
@@ -212,6 +231,7 @@ function createElementDecl({
   fixedValue = null,
   nillable = false,
   identityConstraints = [],
+  annotation = null,
   line = null,
   column = null,
   path = null
@@ -230,6 +250,7 @@ function createElementDecl({
     fixedValue,
     nillable,
     identityConstraints,
+    annotation,
     line,
     column,
     path
@@ -245,6 +266,7 @@ function createAttributeDecl({
   use = null,
   defaultValue = null,
   fixedValue = null,
+  annotation = null,
   line = null,
   column = null,
   path = null
@@ -260,6 +282,7 @@ function createAttributeDecl({
     use,
     defaultValue,
     fixedValue,
+    annotation,
     line,
     column,
     path
@@ -276,6 +299,7 @@ function createComplexTypeDecl({
   mixed = false,
   abstract = false,
   identityConstraints = [],
+  annotation = null,
   line = null,
   column = null,
   path = null
@@ -292,6 +316,7 @@ function createComplexTypeDecl({
     mixed,
     abstract,
     identityConstraints,
+    annotation,
     line,
     column,
     path
@@ -304,6 +329,7 @@ function createSimpleTypeDecl({
   baseTypeName = null,
   facets = {},
   enumerations = [],
+  annotation = null,
   line = null,
   column = null,
   path = null
@@ -316,6 +342,7 @@ function createSimpleTypeDecl({
     baseTypeName,
     facets,
     enumerations,
+    annotation,
     line,
     column,
     path
@@ -363,6 +390,7 @@ function createAttributeGroupDecl({
 }
 function createAttributeGroupRef({
   refName,
+  use = null,
   line = null,
   column = null,
   path = null
@@ -370,6 +398,7 @@ function createAttributeGroupRef({
   return {
     kind: "attributeGroupRef",
     refName,
+    use,
     line,
     column,
     path
@@ -480,9 +509,11 @@ function createGroupRefNode({
 }
 function createAnyNode({
   namespace = null,
-  processContents = null,
+  processContents = "strict",
   minOccurs = 1,
   maxOccurs = 1,
+  notNamespace = [],
+  notQName = [],
   line = null,
   column = null,
   path = null
@@ -490,9 +521,31 @@ function createAnyNode({
   return {
     kind: "any",
     namespace,
-    processContents,
+    processContents: processContents || "strict",
     minOccurs,
     maxOccurs,
+    notNamespace,
+    notQName,
+    line,
+    column,
+    path
+  };
+}
+function createAnyAttributeNode({
+  namespace = null,
+  processContents = "strict",
+  notNamespace = [],
+  notQName = [],
+  line = null,
+  column = null,
+  path = null
+} = {}) {
+  return {
+    kind: "anyAttribute",
+    namespace,
+    processContents: processContents || "strict",
+    notNamespace,
+    notQName,
     line,
     column,
     path
@@ -817,9 +870,6 @@ function getEffectiveContent(schema, complexTypeDecl) {
 
 // src/parser/buildSchemaModel.js
 var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-  "any",
-  "anyAttribute",
-  "redefine",
   "notation"
 ]);
 function elementChildren(node) {
@@ -840,6 +890,8 @@ function recordExternalRef(schema, kind, node, path, loc) {
     schema.externalRefs.includes.push(entry);
   } else if (kind === "import") {
     schema.externalRefs.imports.push(entry);
+  } else if (kind === "redefine") {
+    schema.externalRefs.redefines.push(entry);
   }
 }
 function mergeGlobalsIntoSchema(targetSchema, sourceSchema, issues, createDuplicateIssue) {
@@ -880,6 +932,9 @@ function mergeGlobalsIntoSchema(targetSchema, sourceSchema, issues, createDuplic
   targetSchema.externalRefs.imports.push(
     ...sourceSchema.externalRefs.imports || []
   );
+  targetSchema.externalRefs.redefines.push(
+    ...sourceSchema.externalRefs.redefines || []
+  );
   targetSchema.importedSchemas.push(...sourceSchema.importedSchemas || []);
   targetSchema.identityConstraints.push(
     ...sourceSchema.identityConstraints || []
@@ -1153,6 +1208,42 @@ function parseFacets(node) {
   }
   return { facets, enumerations };
 }
+function parseAnnotation(node) {
+  if (!node || node.localName !== "annotation") {
+    return null;
+  }
+  const children = Array.from(node.children || []).filter(
+    (child) => child.nodeType === 1
+  );
+  let documentation = null;
+  let appinfo = null;
+  for (const child of children) {
+    if (child.localName === "documentation") {
+      const lang = child.getAttribute("xml:lang") || null;
+      const source = child.getAttribute("source") || null;
+      const text = (child.textContent || "").trim();
+      documentation = {
+        text,
+        lang,
+        source
+      };
+    } else if (child.localName === "appinfo") {
+      const source = child.getAttribute("source") || null;
+      const text = (child.textContent || "").trim();
+      appinfo = {
+        text,
+        source
+      };
+    }
+  }
+  if (!documentation && !appinfo) {
+    return null;
+  }
+  return createAnnotation({
+    documentation,
+    appinfo
+  });
+}
 function parseSimpleType(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
@@ -1160,7 +1251,12 @@ function parseSimpleType(node, xsdText, lineStarts, parentPath, schema, issues)
   let baseTypeName = null;
   let facets = {};
   let enumerations = [];
-  const restriction = elementChildren(node).find(
+  const children = elementChildren(node);
+  const annotationNode = children.find(
+    (child) => child.localName === "annotation"
+  );
+  const annotation = parseAnnotation(annotationNode);
+  const restriction = children.find(
     (child) => child.localName === "restriction"
   );
   if (restriction) {
@@ -1187,6 +1283,7 @@ function parseSimpleType(node, xsdText, lineStarts, parentPath, schema, issues)
     baseTypeName,
     facets,
     enumerations,
+    annotation,
     line: loc.line,
     column: loc.column,
     path
@@ -1196,7 +1293,12 @@ function parseAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
   collectNodeDiagnostics(schema, issues, node, path, loc);
-  const inlineSimpleTypeNode = elementChildren(node).find(
+  const children = elementChildren(node);
+  const annotationNode = children.find(
+    (child) => child.localName === "annotation"
+  );
+  const annotation = parseAnnotation(annotationNode);
+  const inlineSimpleTypeNode = children.find(
     (child) => child.localName === "simpleType"
   );
   const inlineType = inlineSimpleTypeNode ? parseSimpleType(
@@ -1219,6 +1321,7 @@ function parseAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
     use: normalizeUse(node.getAttribute("use")),
     defaultValue: node.getAttribute("default"),
     fixedValue: node.getAttribute("fixed"),
+    annotation,
     line: loc.line,
     column: loc.column,
     path
@@ -1230,6 +1333,7 @@ function parseAttributeGroupRef(node, xsdText, lineStarts, parentPath, schema, i
   collectNodeDiagnostics(schema, issues, node, path, loc);
   return createAttributeGroupRef({
     refName: node.getAttribute("ref"),
+    use: normalizeUse(node.getAttribute("use")),
     line: loc.line,
     column: loc.column,
     path
@@ -1253,6 +1357,10 @@ function parseAttributesContainer(nodes, xsdText, lineStarts, parentPath, schema
           issues
         )
       );
+    } else if (child.localName === "anyAttribute") {
+      attributes.push(
+        parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+      );
     }
   }
   return attributes;
@@ -1263,6 +1371,10 @@ function parseElement(node, xsdText, lineStarts, parentPath, schema, issues) {
   collectNodeDiagnostics(schema, issues, node, path, loc);
   let inlineType = null;
   const children = elementChildren(node);
+  const annotationNode = children.find(
+    (child) => child.localName === "annotation"
+  );
+  const annotation = parseAnnotation(annotationNode);
   const inlineComplexTypeNode = children.find(
     (child) => child.localName === "complexType"
   );
@@ -1318,6 +1430,7 @@ function parseElement(node, xsdText, lineStarts, parentPath, schema, issues) {
     fixedValue: node.getAttribute("fixed"),
     nillable: node.getAttribute("nillable") === "true",
     identityConstraints,
+    annotation,
     line: loc.line,
     column: loc.column,
     path
@@ -1336,15 +1449,58 @@ function parseGroupRef(node, xsdText, lineStarts, parentPath, schema, issues) {
     path
   });
 }
+function parseWildcardNamespace(namespaceStr) {
+  if (!namespaceStr) return null;
+  const trimmed = namespaceStr.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return trimmed;
+}
+function parseNotNamespace(notNamespaceStr) {
+  if (!notNamespaceStr) return [];
+  const trimmed = notNamespaceStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return [trimmed];
+}
+function parseNotQName(notQNameStr) {
+  if (!notQNameStr) return [];
+  const trimmed = notQNameStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((qn) => qn);
+  }
+  return [trimmed];
+}
 function parseAny(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
   collectNodeDiagnostics(schema, issues, node, path, loc);
   return createAnyNode({
-    namespace: node.getAttribute("namespace"),
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
     processContents: node.getAttribute("processContents"),
     minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
     maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
+    line: loc.line,
+    column: loc.column,
+    path
+  });
+}
+function parseAnyAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
+  const path = buildPath(parentPath, node);
+  const loc = locateNodeInSource(xsdText, lineStarts, node);
+  collectNodeDiagnostics(schema, issues, node, path, loc);
+  return createAnyAttributeNode({
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
+    processContents: node.getAttribute("processContents"),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
     line: loc.line,
     column: loc.column,
     path
@@ -1535,6 +1691,10 @@ function parseComplexType(node, xsdText, lineStarts, parentPath, schema, issues)
   let contentModel = "complex";
   const children = elementChildren(node);
   const namespaceUri4 = schema.targetNamespace || null;
+  const annotationNode = children.find(
+    (child) => child.localName === "annotation"
+  );
+  const annotation = parseAnnotation(annotationNode);
   const identityConstraints = children.filter(
     (child) => ["key", "keyref", "unique"].includes(child.localName)
   ).map(
@@ -1620,6 +1780,7 @@ function parseComplexType(node, xsdText, lineStarts, parentPath, schema, issues)
     mixed: node.getAttribute("mixed") === "true",
     abstract: node.getAttribute("abstract") === "true",
     identityConstraints,
+    annotation,
     line: loc.line,
     column: loc.column,
     path
@@ -1689,6 +1850,63 @@ function isImportNamespaceCompatible(ref, importedSchema) {
   }
   return (declaredNs || null) === (importedNs || null);
 }
+function isRedefineNamespaceCompatible(hostSchema, redefinedSchema) {
+  const hostNs = hostSchema?.targetNamespace || null;
+  const redefinedNs = redefinedSchema?.targetNamespace || null;
+  return hostNs === redefinedNs;
+}
+function mergeRedefinesIntoSchema(targetSchema, sourceSchema, issues, createDuplicateIssue) {
+  const buckets = [
+    ["complexTypes", "DUPLICATE_GLOBAL_COMPLEX_TYPE"],
+    ["simpleTypes", "DUPLICATE_GLOBAL_SIMPLE_TYPE"],
+    ["groups", "DUPLICATE_GLOBAL_GROUP"],
+    ["attributeGroups", "DUPLICATE_GLOBAL_ATTRIBUTE_GROUP"]
+  ];
+  for (const [bucketName, _duplicateCode] of buckets) {
+    for (const [key, decl] of Object.entries(
+      sourceSchema.globals[bucketName] || {}
+    )) {
+      if (targetSchema.globals[bucketName][key]) {
+        targetSchema.globals[bucketName][key] = {
+          ...decl,
+          redefined: true,
+          originalDefinition: targetSchema.globals[bucketName][key]
+        };
+      } else {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.REDEFINE_INVALID_OVERRIDE,
+            severity: "error",
+            message: `xs:redefine attempts to override ${bucketName.slice(0, -1)} '${decl.name}' which does not exist in the base schema.`,
+            line: decl.line,
+            column: decl.column,
+            path: decl.path,
+            source: "xsd",
+            nodeKind: decl.kind,
+            name: decl.name,
+            details: { declarationName: decl.name }
+          })
+        );
+      }
+    }
+  }
+  targetSchema.references.types.push(...sourceSchema.references.types || []);
+  targetSchema.references.baseTypes.push(
+    ...sourceSchema.references.baseTypes || []
+  );
+  targetSchema.references.groupRefs.push(
+    ...sourceSchema.references.groupRefs || []
+  );
+  targetSchema.references.attributeGroupRefs.push(
+    ...sourceSchema.references.attributeGroupRefs || []
+  );
+  for (const feature of sourceSchema.usedFeatures || []) {
+    targetSchema.usedFeatures.add(feature);
+  }
+  targetSchema.unsupportedFeatures.push(
+    ...sourceSchema.unsupportedFeatures || []
+  );
+}
 function normalizeSchemaPath(value) {
   if (!value || typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -1767,24 +1985,24 @@ function resolveExternalDocument(ref, externalDocuments) {
     }
   }
   if (ref?.kind === "import" && ref.namespace) {
-    const namespaceMatches = entries.filter((entry) => {
+    const namespaceMatches2 = entries.filter((entry) => {
       const declaredTargetNamespace = getDeclaredTargetNamespaceFromText(
         entry.text
       );
       return (declaredTargetNamespace || null) === (ref.namespace || null);
     });
-    if (namespaceMatches.length === 1) {
+    if (namespaceMatches2.length === 1) {
       return {
         kind: "namespace",
-        entry: namespaceMatches[0],
-        matches: namespaceMatches
+        entry: namespaceMatches2[0],
+        matches: namespaceMatches2
       };
     }
-    if (namespaceMatches.length > 1) {
+    if (namespaceMatches2.length > 1) {
       return {
         kind: "ambiguous-namespace",
         entry: null,
-        matches: namespaceMatches
+        matches: namespaceMatches2
       };
     }
   }
@@ -1814,6 +2032,7 @@ function buildSchemaModel(doc, options = {}) {
   schema.targetNamespace = getEffectiveTargetNamespace(schemaRoot, options);
   schema.elementFormDefault = schemaRoot.getAttribute("elementFormDefault");
   schema.attributeFormDefault = schemaRoot.getAttribute("attributeFormDefault");
+  schema.schemaVersion = schemaRoot.getAttribute("version");
   extractNamespaces(schemaRoot, schema);
   const rootPath = "/schema";
   const rootLoc = locateNodeInSource(xsdText, lineStarts, schemaRoot);
@@ -1966,6 +2185,13 @@ function buildSchemaModel(doc, options = {}) {
         recordExternalRef(schema, "import", child, path, loc);
         break;
       }
+      case "redefine": {
+        const path = buildPath(rootPath, child);
+        const loc = locateNodeInSource(xsdText, lineStarts, child);
+        collectNodeDiagnostics(schema, issues, child, path, loc);
+        recordExternalRef(schema, "redefine", child, path, loc);
+        break;
+      }
       default: {
         const path = buildPath(rootPath, child);
         const loc = locateNodeInSource(xsdText, lineStarts, child);
@@ -1990,7 +2216,8 @@ function buildSchemaModel(doc, options = {}) {
   const visited = options._visitedExternalSchemas || /* @__PURE__ */ new Set();
   const includes = schema.externalRefs.includes || [];
   const imports = schema.externalRefs.imports || [];
-  for (const ref of [...includes, ...imports]) {
+  const redefines = schema.externalRefs.redefines || [];
+  for (const ref of [...includes, ...imports, ...redefines]) {
     if (!ref.schemaLocation) continue;
     const resolution = resolveExternalDocument(ref, externalDocuments);
     if (resolution.kind === "ambiguous-namespace") {
@@ -2117,6 +2344,34 @@ function buildSchemaModel(doc, options = {}) {
         } else {
           schema.importedSchemas.push(externalBuild.schema);
         }
+      } else if (ref.kind === "redefine") {
+        if (!isRedefineNamespaceCompatible(schema, externalBuild.schema)) {
+          issues.push(
+            createIssue({
+              code: ISSUE_CODES.XSD_REDEFINE_NAMESPACE_MISMATCH,
+              severity: "error",
+              message: `xs:redefine namespace mismatch. Host targetNamespace is '${schema.targetNamespace || ""}', redefined schema targetNamespace is '${externalBuild.schema.targetNamespace || ""}'.`,
+              line: ref.line,
+              column: ref.column,
+              path: ref.path,
+              source: "xsd",
+              nodeKind: "redefine",
+              details: {
+                schemaLocation: ref.schemaLocation,
+                resolvedSchemaKey,
+                hostTargetNamespace: schema.targetNamespace || null,
+                redefinedTargetNamespace: externalBuild.schema.targetNamespace || null
+              }
+            })
+          );
+        } else {
+          mergeRedefinesIntoSchema(
+            schema,
+            externalBuild.schema,
+            issues,
+            createDuplicateIssue
+          );
+        }
       }
     }
     issues.push(...externalBuild.issues || []);
@@ -2401,6 +2656,115 @@ function checkRestrictedAttributes(schema, derivedType, baseType, issues) {
     }
   }
 }
+function checkWildcardRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  const derivedWildcards = [];
+  const baseWildcards = [];
+  function collectWildcards(node, arr) {
+    if (!node) return;
+    if (node.kind === "any") {
+      arr.push(node);
+      return;
+    }
+    if (node.children) {
+      for (const child of asArray(node.children)) {
+        collectWildcards(child, arr);
+      }
+    }
+  }
+  collectWildcards(derivedContent, derivedWildcards);
+  collectWildcards(baseContent, baseWildcards);
+  if (derivedWildcards.length > 0 && baseWildcards.length === 0) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces wildcard elements that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const derivedHasAnyAttribute = derivedAttrs.some((a) => a?.kind === "anyAttribute");
+  const baseHasAnyAttribute = baseAttrs.some((a) => a?.kind === "anyAttribute");
+  if (derivedHasAnyAttribute && !baseHasAnyAttribute) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces anyAttribute that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+}
+function checkOccurrenceCompatibility(derived, base, name) {
+  const dMin = typeof derived.minOccurs === "number" ? derived.minOccurs : 1;
+  const bMin = typeof base.minOccurs === "number" ? base.minOccurs : 1;
+  const dMax = maxToNumber(derived.maxOccurs ?? 1);
+  const bMax = maxToNumber(base.maxOccurs ?? 1);
+  return dMin >= bMin && dMax <= bMax;
+}
+function checkComplexContentRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  if (!derivedContent || !baseContent) return;
+  const derivedFlat = flattenContent(derivedContent, []);
+  const baseFlat = flattenContent(baseContent, []);
+  const baseMap = new Map(baseFlat.map((item) => [item.name, item]));
+  for (const item of derivedFlat) {
+    const baseItem = baseMap.get(item.name);
+    if (!baseItem) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_NOT_SUBSET",
+          `Restricted type contains element '${item.name}' not in base type.`,
+          item
+        )
+      );
+      continue;
+    }
+    if (!checkOccurrenceCompatibility(item, baseItem, item.name)) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+          `Restricted type has incompatible occurrence constraints for '${item.name}'.`,
+          item
+        )
+      );
+    }
+  }
+}
+function checkSimpleContentRestriction(schema, derivedType, baseType, issues) {
+  if (baseType.contentModel !== "simple") {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_NOT_SUBSET",
+        `SimpleContent restriction requires base type to have simple content.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const baseAttrMap = new Map(
+    baseAttrs.filter((attr) => attr?.kind === "attribute").map((attr) => [localDeclName(attr), attr])
+  );
+  for (const attr of derivedAttrs) {
+    if (attr?.kind !== "attribute") continue;
+    const name = localDeclName(attr);
+    const baseAttr = baseAttrMap.get(name);
+    if (!baseAttr && !baseAttrs.some((a) => a?.kind === "anyAttribute")) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+          `SimpleContent restricted type adds attribute '${name}' not in base type.`,
+          attr
+        )
+      );
+    }
+  }
+}
 function runRestrictionDiagnostics(schema) {
   const issues = [];
   for (const complexType of Object.values(schema.globals.complexTypes || {})) {
@@ -2410,6 +2774,12 @@ function runRestrictionDiagnostics(schema) {
     if (!baseType) continue;
     checkRestrictedContentSubset(schema, complexType, baseType, issues);
     checkRestrictedAttributes(schema, complexType, baseType, issues);
+    checkWildcardRestriction(schema, complexType, baseType, issues);
+    if (complexType.contentModel === "complex" && baseType.contentModel === "complex") {
+      checkComplexContentRestriction(schema, complexType, baseType, issues);
+    } else if (complexType.contentModel === "simple" && baseType.contentModel === "simple") {
+      checkSimpleContentRestriction(schema, complexType, baseType, issues);
+    }
   }
   return issues;
 }
@@ -2736,6 +3106,130 @@ function runImportDiagnostics(schema, options = {}) {
   return issues;
 }
 
+// src/diagnostics/schemaWildcardDiagnostics.js
+function validateWildcardNamespace(namespace, path) {
+  if (!namespace) return null;
+  const trimmed = namespace.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(/\s+/);
+  for (const part of parts) {
+    if (part === "##any" || part === "##other" || part === "##targetNamespace") {
+      continue;
+    }
+    if (!part.includes(":") && part !== "") {
+      return createIssue({
+        code: "INVALID_WILDCARD_NAMESPACE",
+        severity: "warning",
+        message: `Invalid namespace in wildcard constraint: '${part}'. Expected ##any, ##other, ##targetNamespace, or a valid namespace URI.`,
+        path
+      });
+    }
+  }
+  return null;
+}
+function validateProcessContents(processContents, path) {
+  if (!processContents) return null;
+  const trimmed = processContents.trim();
+  if (trimmed === "strict" || trimmed === "lax" || trimmed === "skip") {
+    return null;
+  }
+  return createIssue({
+    code: "INVALID_PROCESS_CONTENTS",
+    severity: "error",
+    message: `Invalid processContents value: '${processContents}'. Must be 'strict', 'lax', or 'skip'.`,
+    path
+  });
+}
+function validateSingleWildcard(wildcardNode, nodeName) {
+  const issues = [];
+  const nsIssue = validateWildcardNamespace(wildcardNode.namespace, wildcardNode.path);
+  if (nsIssue) {
+    issues.push(nsIssue);
+  }
+  const pcIssue = validateProcessContents(wildcardNode.processContents, wildcardNode.path);
+  if (pcIssue) {
+    issues.push(pcIssue);
+  }
+  if (wildcardNode.notNamespace && wildcardNode.notNamespace.length > 0) {
+    if (wildcardNode.namespace !== "##other" && wildcardNode.namespace !== "##targetNamespace") {
+      issues.push(
+        createIssue({
+          code: "INVALID_NOT_NAMESPACE_USAGE",
+          severity: "warning",
+          message: `notNamespace is only meaningful with ##other or ##targetNamespace namespace constraint.`,
+          path: wildcardNode.path
+        })
+      );
+    }
+  }
+  if (wildcardNode.notQName && wildcardNode.notQName.length > 0) {
+    for (const qname of wildcardNode.notQName) {
+      if (!qname || qname.trim() === "") {
+        issues.push(
+          createIssue({
+            code: "INVALID_NOT_QNAME",
+            severity: "warning",
+            message: `Empty QName in notQName constraint.`,
+            path: wildcardNode.path
+          })
+        );
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function findWildcardsInContent(node, wildcards) {
+  if (!node) return;
+  if (node.kind === "any" || node.kind === "anyAttribute") {
+    wildcards.push(node);
+    return;
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      findWildcardsInContent(child, wildcards);
+    }
+  }
+}
+function findWildcardsInAttributes(attributes, wildcards) {
+  if (!attributes || !Array.isArray(attributes)) return;
+  for (const attr of attributes) {
+    if (attr.kind === "anyAttribute") {
+      wildcards.push(attr);
+    }
+  }
+}
+function runWildcardDiagnostics(schema) {
+  const issues = [];
+  const wildcards = [];
+  for (const elem of Object.values(schema.globals.elements || {})) {
+    if (elem.inlineType?.content) {
+      findWildcardsInContent(elem.inlineType.content, wildcards);
+    }
+    if (elem.inlineType?.attributes) {
+      findWildcardsInAttributes(elem.inlineType.attributes, wildcards);
+    }
+  }
+  for (const complexType of Object.values(schema.globals.complexTypes || {})) {
+    if (complexType.content) {
+      findWildcardsInContent(complexType.content, wildcards);
+    }
+    if (complexType.attributes) {
+      findWildcardsInAttributes(complexType.attributes, wildcards);
+    }
+  }
+  for (const group of Object.values(schema.globals.groups || {})) {
+    if (group.content) {
+      findWildcardsInContent(group.content, wildcards);
+    }
+  }
+  for (const wildcard of wildcards) {
+    const wildcardIssues = validateSingleWildcard(wildcard, wildcard.kind);
+    issues.push(...wildcardIssues);
+  }
+  return issues;
+}
+
 // src/diagnostics/schemaDiagnostics.js
 function buildStats(schema) {
   return {
@@ -2910,6 +3404,8 @@ function runSchemaDiagnostics(schema, options = {}) {
   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);
@@ -2930,7 +3426,7 @@ function runSchemaDiagnostics(schema, options = {}) {
 }
 
 // src/version.js
-var ENGINE_VERSION = "v0.2.0";
+var ENGINE_VERSION = "v0.2.2";
 
 // src/utils/result.js
 function summarizeIssues(issues = []) {
@@ -3818,6 +4314,24 @@ function buildNodesFromContent(schema, contentNode, options, state) {
 function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
   const content = getEffectiveContent(schema, complexTypeDecl);
   const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+  if (state.currentDepth >= options.maxDepth) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  const typeKey = complexTypeDecl.name || complexTypeDecl.qName;
+  if (typeKey && state.visitedTypes.has(typeKey)) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  if (typeKey) {
+    state.visitedTypes.add(typeKey);
+  }
+  const previousDepth = state.currentDepth;
+  state.currentDepth += 1;
   let children = content ? buildNodesFromContent(schema, content, options, state) : [];
   if (options.mode === "minimal" && children.length === 0 && content) {
     children = buildRepresentativeNodesFromContent(
@@ -3827,6 +4341,10 @@ function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
       state
     );
   }
+  state.currentDepth = previousDepth;
+  if (typeKey) {
+    state.visitedTypes.delete(typeKey);
+  }
   return {
     attributes: buildAttributesObject(schema, attributes, options, state),
     children
@@ -3905,7 +4423,10 @@ function selectRoot(schema, options = {}) {
 function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const normalizedOptions = {
     mode: options.mode === "full" ? "full" : "minimal",
-    includeOptionalAttributes: options.includeOptionalAttributes === true
+    includeOptionalAttributes: options.includeOptionalAttributes === true,
+    maxDepth: options.maxDepth ?? 3,
+    maxChoiceBranches: options.maxChoiceBranches ?? 1,
+    expandRepeatingElements: options.expandRepeatingElements ?? 2
   };
   const root = selectRoot(schema, options);
   if (!root) {
@@ -3918,7 +4439,9 @@ function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const state = {
     resolveAttributeGroup: helpers.resolveAttributeGroup,
     targetPrefix: options.targetPrefix || "tns",
-    nsContext
+    nsContext,
+    visitedTypes: /* @__PURE__ */ new Set(),
+    currentDepth: 0
   };
   const [rootNode] = buildElementInstances(
     schema,
@@ -4021,6 +4544,80 @@ function generateSampleXml({ xsdText, options = {} } = {}) {
   });
 }
 
+// src/validation/wildcardValidator.js
+function namespaceMatches(elementNamespace, wildcardNamespace, targetNamespace) {
+  if (!wildcardNamespace) return true;
+  if (wildcardNamespace === "##any") return true;
+  if (wildcardNamespace === "##targetNamespace") {
+    return elementNamespace === targetNamespace;
+  }
+  if (wildcardNamespace === "##other") {
+    return elementNamespace !== targetNamespace;
+  }
+  if (Array.isArray(wildcardNamespace)) {
+    return wildcardNamespace.includes(elementNamespace);
+  }
+  return elementNamespace === wildcardNamespace;
+}
+function isExcludedByNotNamespace(elementNamespace, notNamespace) {
+  if (!notNamespace || notNamespace.length === 0) return false;
+  return notNamespace.includes(elementNamespace);
+}
+function isExcludedByNotQName(qName, notQName) {
+  if (!notQName || notQName.length === 0) return false;
+  return notQName.includes(qName);
+}
+function buildQName(localName4, namespaceUri4) {
+  if (!namespaceUri4 || namespaceUri4 === "") {
+    return localName4;
+  }
+  return `{${namespaceUri4}}${localName4}`;
+}
+function elementMatchesWildcard(elementLocalName, elementNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "any") {
+    return false;
+  }
+  if (!namespaceMatches(elementNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(elementNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(elementLocalName, elementNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function attributeMatchesWildcard(attrLocalName, attrNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "anyAttribute") {
+    return false;
+  }
+  if (!namespaceMatches(attrNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(attrNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(attrLocalName, attrNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function normalizeProcessContents(processContents) {
+  if (processContents === "lax" || processContents === "skip") {
+    return processContents;
+  }
+  return "strict";
+}
+function isStrictWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "strict";
+}
+function shouldSkipWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "skip";
+}
+
 // src/validation/structureValidator.js
 function elementChildren2(xmlNode) {
   return Array.from(xmlNode?.children || []).filter((child) => child.nodeType === 1);
@@ -4090,6 +4687,7 @@ function isSimpleContentComplexType(complexTypeDecl) {
 function validateAttributes(xmlNode, attributes, context) {
   const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts, validateAttributeValue: validateAttributeValue2 } = context;
   const allowed = /* @__PURE__ */ new Map();
+  let anyAttributeWildcard = null;
   for (const attr of attributes || []) {
     if (!attr) continue;
     if (attr.kind === "attribute") {
@@ -4101,6 +4699,8 @@ function validateAttributes(xmlNode, attributes, context) {
       const group = context.resolveAttributeGroup?.(attr.refName);
       if (!group) continue;
       validateAttributes(xmlNode, group.attributes || [], context);
+    } else if (attr.kind === "anyAttribute") {
+      anyAttributeWildcard = attr;
     }
   }
   for (const attrDecl of allowed.values()) {
@@ -4146,6 +4746,15 @@ function validateAttributes(xmlNode, attributes, context) {
       continue;
     }
     if (!allowed.has(attr.name)) {
+      if (anyAttributeWildcard) {
+        const attrLocalName = attr.localName || attr.name.split(":")[1] || attr.name;
+        const attrNamespace = attr.namespaceURI || null;
+        if (attributeMatchesWildcard(attrLocalName, attrNamespace, anyAttributeWildcard, schema.targetNamespace)) {
+          if (!shouldSkipWildcardValidation(anyAttributeWildcard.processContents)) {
+          }
+          continue;
+        }
+      }
       issues.push(
         createIssue2({
           code: ISSUE_CODES2.XML_UNEXPECTED_ATTRIBUTE,
@@ -4563,7 +5172,16 @@ function validateContentModel(children, modelNode, context, pathParts, startInde
       return validateAll(children, startIndex, modelNode, context, pathParts, silent);
     case "any":
       if (startIndex < children.length) {
-        return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        const childNode = children[startIndex];
+        const childLocalName = localName(childNode);
+        const childNamespace = namespaceUri(childNode);
+        if (elementMatchesWildcard(childLocalName, childNamespace, modelNode, context.schema.targetNamespace)) {
+          if (isStrictWildcardValidation(modelNode.processContents)) {
+            validateElementDecl(childNode, { name: childLocalName, typeName: null }, context, [...pathParts, childLocalName]);
+          } else if (!shouldSkipWildcardValidation(modelNode.processContents)) {
+          }
+          return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        }
       }
       return { nextIndex: startIndex, matched: true, matchedAny: false };
     default: