uss-xsd-engine 0.2.0 → 0.2.2

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

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.2.0
+ * uss-xsd-engine v0.2.2
  * (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,10 +124,15 @@ 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",
-    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
@@ -178,6 +185,7 @@ var UssXsdEngine = (() => {
       targetNamespace: null,
       elementFormDefault: null,
       attributeFormDefault: null,
+      schemaVersion: null,
       namespaces: {
         default: null,
         prefixes: /* @__PURE__ */ Object.create(null)
@@ -193,7 +201,8 @@ var UssXsdEngine = (() => {
       documents: [],
       externalRefs: {
         includes: [],
-        imports: []
+        imports: [],
+        redefines: []
       },
       importedSchemas: [],
       roots: [],
@@ -226,6 +235,16 @@ var UssXsdEngine = (() => {
     }
     return null;
   }
+  function createAnnotation({
+    documentation = null,
+    appinfo = null
+  } = {}) {
+    return {
+      kind: "annotation",
+      documentation,
+      appinfo
+    };
+  }
   function createElementDecl({
     name = null,
     qName = null,
@@ -239,6 +258,7 @@ var UssXsdEngine = (() => {
     fixedValue = null,
     nillable = false,
     identityConstraints = [],
+    annotation = null,
     line = null,
     column = null,
     path = null
@@ -257,6 +277,7 @@ var UssXsdEngine = (() => {
       fixedValue,
       nillable,
       identityConstraints,
+      annotation,
       line,
       column,
       path
@@ -272,6 +293,7 @@ var UssXsdEngine = (() => {
     use = null,
     defaultValue = null,
     fixedValue = null,
+    annotation = null,
     line = null,
     column = null,
     path = null
@@ -287,6 +309,7 @@ var UssXsdEngine = (() => {
       use,
       defaultValue,
       fixedValue,
+      annotation,
       line,
       column,
       path
@@ -303,6 +326,7 @@ var UssXsdEngine = (() => {
     mixed = false,
     abstract = false,
     identityConstraints = [],
+    annotation = null,
     line = null,
     column = null,
     path = null
@@ -319,6 +343,7 @@ var UssXsdEngine = (() => {
       mixed,
       abstract,
       identityConstraints,
+      annotation,
       line,
       column,
       path
@@ -331,6 +356,7 @@ var UssXsdEngine = (() => {
     baseTypeName = null,
     facets = {},
     enumerations = [],
+    annotation = null,
     line = null,
     column = null,
     path = null
@@ -343,6 +369,7 @@ var UssXsdEngine = (() => {
       baseTypeName,
       facets,
       enumerations,
+      annotation,
       line,
       column,
       path
@@ -390,6 +417,7 @@ var UssXsdEngine = (() => {
   }
   function createAttributeGroupRef({
     refName,
+    use = null,
     line = null,
     column = null,
     path = null
@@ -397,6 +425,7 @@ var UssXsdEngine = (() => {
     return {
       kind: "attributeGroupRef",
       refName,
+      use,
       line,
       column,
       path
@@ -507,9 +536,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 +548,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,9 +897,6 @@ var UssXsdEngine = (() => {
 
   // src/parser/buildSchemaModel.js
   var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-    "any",
-    "anyAttribute",
-    "redefine",
     "notation"
   ]);
   function elementChildren(node) {
@@ -867,6 +917,8 @@ var UssXsdEngine = (() => {
       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) {
@@ -907,6 +959,9 @@ var UssXsdEngine = (() => {
     targetSchema.externalRefs.imports.push(
       ...sourceSchema.externalRefs.imports || []
     );
+    targetSchema.externalRefs.redefines.push(
+      ...sourceSchema.externalRefs.redefines || []
+    );
     targetSchema.importedSchemas.push(...sourceSchema.importedSchemas || []);
     targetSchema.identityConstraints.push(
       ...sourceSchema.identityConstraints || []
@@ -1180,6 +1235,42 @@ var UssXsdEngine = (() => {
     }
     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);
@@ -1187,7 +1278,12 @@ var UssXsdEngine = (() => {
     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) {
@@ -1214,6 +1310,7 @@ var UssXsdEngine = (() => {
       baseTypeName,
       facets,
       enumerations,
+      annotation,
       line: loc.line,
       column: loc.column,
       path
@@ -1223,7 +1320,12 @@ var UssXsdEngine = (() => {
     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(
@@ -1246,6 +1348,7 @@ var UssXsdEngine = (() => {
       use: normalizeUse(node.getAttribute("use")),
       defaultValue: node.getAttribute("default"),
       fixedValue: node.getAttribute("fixed"),
+      annotation,
       line: loc.line,
       column: loc.column,
       path
@@ -1257,6 +1360,7 @@ var UssXsdEngine = (() => {
     collectNodeDiagnostics(schema, issues, node, path, loc);
     return createAttributeGroupRef({
       refName: node.getAttribute("ref"),
+      use: normalizeUse(node.getAttribute("use")),
       line: loc.line,
       column: loc.column,
       path
@@ -1280,6 +1384,10 @@ var UssXsdEngine = (() => {
             issues
           )
         );
+      } else if (child.localName === "anyAttribute") {
+        attributes.push(
+          parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+        );
       }
     }
     return attributes;
@@ -1290,6 +1398,10 @@ var UssXsdEngine = (() => {
     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"
     );
@@ -1345,6 +1457,7 @@ var UssXsdEngine = (() => {
       fixedValue: node.getAttribute("fixed"),
       nillable: node.getAttribute("nillable") === "true",
       identityConstraints,
+      annotation,
       line: loc.line,
       column: loc.column,
       path
@@ -1363,15 +1476,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
@@ -1562,6 +1718,10 @@ var UssXsdEngine = (() => {
     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(
@@ -1647,6 +1807,7 @@ var UssXsdEngine = (() => {
       mixed: node.getAttribute("mixed") === "true",
       abstract: node.getAttribute("abstract") === "true",
       identityConstraints,
+      annotation,
       line: loc.line,
       column: loc.column,
       path
@@ -1716,6 +1877,63 @@ var UssXsdEngine = (() => {
     }
     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();
@@ -1794,24 +2012,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
         };
       }
     }
@@ -1841,6 +2059,7 @@ var UssXsdEngine = (() => {
     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);
@@ -1993,6 +2212,13 @@ var UssXsdEngine = (() => {
           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);
@@ -2017,7 +2243,8 @@ var UssXsdEngine = (() => {
     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") {
@@ -2144,6 +2371,34 @@ var UssXsdEngine = (() => {
           } 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 || []);
@@ -2428,6 +2683,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 +2801,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 +3133,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 +3431,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 +3453,7 @@ var UssXsdEngine = (() => {
   }
 
   // src/version.js
-  var ENGINE_VERSION = "v0.2.0";
+  var ENGINE_VERSION = "v0.2.2";
 
   // src/utils/result.js
   function summarizeIssues(issues = []) {
@@ -3845,6 +4341,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 +4368,10 @@ var UssXsdEngine = (() => {
         state
       );
     }
+    state.currentDepth = previousDepth;
+    if (typeKey) {
+      state.visitedTypes.delete(typeKey);
+    }
     return {
       attributes: buildAttributesObject(schema, attributes, options, state),
       children
@@ -3932,7 +4450,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 +4466,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 +4571,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 +4714,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 +4726,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 +4773,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 +5199,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: