uss-xsd-engine 0.1.0-beta.2

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

@@ -0,0 +1,4172 @@
+/*!
+ * uss-xsd-engine v0.1.0-beta.2
+ * (c) 2026 Bernard Mumble
+ * MIT License
+ */
+var UssXsdEngine = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    extractSchemaTree: () => extractSchemaTree,
+    generateSampleXml: () => generateSampleXml,
+    getSchemaDiagnostics: () => getSchemaDiagnostics,
+    validateXml: () => validateXml
+  });
+
+  // src/diagnostics/createIssue.js
+  function createIssue({
+    code,
+    severity = "error",
+    message,
+    line = null,
+    column = null,
+    path = null,
+    source = "xsd",
+    nodeKind = null,
+    name = null,
+    details = {}
+  }) {
+    return {
+      code,
+      severity,
+      message,
+      line,
+      column,
+      path,
+      source,
+      nodeKind,
+      name,
+      details
+    };
+  }
+
+  // src/diagnostics/issueCodes.js
+  var ISSUE_CODES = {
+    XSD_PARSE_ERROR: "XSD_PARSE_ERROR",
+    DUPLICATE_GLOBAL_ELEMENT: "DUPLICATE_GLOBAL_ELEMENT",
+    DUPLICATE_GLOBAL_COMPLEX_TYPE: "DUPLICATE_GLOBAL_COMPLEX_TYPE",
+    DUPLICATE_GLOBAL_SIMPLE_TYPE: "DUPLICATE_GLOBAL_SIMPLE_TYPE",
+    DUPLICATE_GLOBAL_ATTRIBUTE: "DUPLICATE_GLOBAL_ATTRIBUTE",
+    DUPLICATE_GLOBAL_GROUP: "DUPLICATE_GLOBAL_GROUP",
+    DUPLICATE_GLOBAL_ATTRIBUTE_GROUP: "DUPLICATE_GLOBAL_ATTRIBUTE_GROUP",
+    UNKNOWN_TYPE: "UNKNOWN_TYPE",
+    UNKNOWN_REF: "UNKNOWN_REF",
+    UNKNOWN_GROUP: "UNKNOWN_GROUP",
+    UNKNOWN_ATTRIBUTE_GROUP: "UNKNOWN_ATTRIBUTE_GROUP",
+    MISSING_BASE_TYPE: "MISSING_BASE_TYPE",
+    UNSUPPORTED_FEATURE: "UNSUPPORTED_FEATURE",
+    INVALID_OCCURS_RANGE: "INVALID_OCCURS_RANGE",
+    INVALID_DEFAULT_FIXED_COMBINATION: "INVALID_DEFAULT_FIXED_COMBINATION",
+    XML_PARSE_ERROR: "XML_PARSE_ERROR",
+    XML_ROOT_ELEMENT_MISMATCH: "XML_ROOT_ELEMENT_MISMATCH",
+    XML_UNKNOWN_ROOT_ELEMENT: "XML_UNKNOWN_ROOT_ELEMENT",
+    XML_UNEXPECTED_ELEMENT: "XML_UNEXPECTED_ELEMENT",
+    XML_MISSING_REQUIRED_ELEMENT: "XML_MISSING_REQUIRED_ELEMENT",
+    XML_CHOICE_NOT_SATISFIED: "XML_CHOICE_NOT_SATISFIED",
+    XML_ALL_MISSING_REQUIRED_ELEMENT: "XML_ALL_MISSING_REQUIRED_ELEMENT",
+    XML_UNEXPECTED_ATTRIBUTE: "XML_UNEXPECTED_ATTRIBUTE",
+    XML_MISSING_REQUIRED_ATTRIBUTE: "XML_MISSING_REQUIRED_ATTRIBUTE",
+    XML_INVALID_TEXT_FOR_COMPLEX_TYPE: "XML_INVALID_TEXT_FOR_COMPLEX_TYPE",
+    XML_VALUE_INVALID: "XML_VALUE_INVALID",
+    XML_ENUMERATION_MISMATCH: "XML_ENUMERATION_MISMATCH",
+    XML_PATTERN_MISMATCH: "XML_PATTERN_MISMATCH",
+    XML_LENGTH_MISMATCH: "XML_LENGTH_MISMATCH",
+    XML_MIN_LENGTH_VIOLATION: "XML_MIN_LENGTH_VIOLATION",
+    XML_MAX_LENGTH_VIOLATION: "XML_MAX_LENGTH_VIOLATION",
+    XML_MIN_INCLUSIVE_VIOLATION: "XML_MIN_INCLUSIVE_VIOLATION",
+    XML_MAX_INCLUSIVE_VIOLATION: "XML_MAX_INCLUSIVE_VIOLATION",
+    XML_MIN_EXCLUSIVE_VIOLATION: "XML_MIN_EXCLUSIVE_VIOLATION",
+    XML_MAX_EXCLUSIVE_VIOLATION: "XML_MAX_EXCLUSIVE_VIOLATION",
+    XML_TOTAL_DIGITS_VIOLATION: "XML_TOTAL_DIGITS_VIOLATION",
+    XML_FRACTION_DIGITS_VIOLATION: "XML_FRACTION_DIGITS_VIOLATION",
+    XML_MIXED_CONTENT_NOT_ALLOWED: "XML_MIXED_CONTENT_NOT_ALLOWED",
+    XML_RESTRICTION_VIOLATION: "XML_RESTRICTION_VIOLATION",
+    XML_ALL_DUPLICATE_ELEMENT: "XML_ALL_DUPLICATE_ELEMENT",
+    XML_CHOICE_MULTIPLE_BRANCHES: "XML_CHOICE_MULTIPLE_BRANCHES",
+    XML_RESTRICTED_ELEMENT_NOT_ALLOWED: "XML_RESTRICTED_ELEMENT_NOT_ALLOWED",
+    XML_FIXED_VALUE_MISMATCH: "XML_FIXED_VALUE_MISMATCH",
+    XSD_LENGTH_CONFLICT: "XSD_LENGTH_CONFLICT",
+    XSD_NUMERIC_RANGE_CONFLICT: "XSD_NUMERIC_RANGE_CONFLICT",
+    XSD_DIGITS_INVALID: "XSD_DIGITS_INVALID",
+    XSD_DIGITS_CONFLICT: "XSD_DIGITS_CONFLICT",
+    XSD_ENUM_DUPLICATE: "XSD_ENUM_DUPLICATE",
+    XSD_PATTERN_INVALID: "XSD_PATTERN_INVALID",
+    XSD_FACET_NOT_ALLOWED: "XSD_FACET_NOT_ALLOWED",
+    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_INCLUDE_NOT_PROVIDED: "XSD_INCLUDE_NOT_PROVIDED",
+    XSD_IMPORT_NOT_PROVIDED: "XSD_IMPORT_NOT_PROVIDED"
+  };
+
+  // src/parser/parseXsd.js
+  function parseXsd(xsdText) {
+    const issues = [];
+    if (typeof xsdText !== "string" || !xsdText.trim()) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_PARSE_ERROR,
+          severity: "error",
+          message: "XSD input must be a non-empty string.",
+          source: "xsd"
+        })
+      );
+      return { ok: false, doc: null, issues };
+    }
+    try {
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(xsdText, "application/xml");
+      const parserError = doc.querySelector("parsererror");
+      if (parserError) {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.XSD_PARSE_ERROR,
+            severity: "error",
+            message: parserError.textContent?.trim() || "Failed to parse XSD.",
+            source: "xsd"
+          })
+        );
+        return { ok: false, doc: null, issues };
+      }
+      return { ok: true, doc, issues };
+    } catch (error) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_PARSE_ERROR,
+          severity: "error",
+          message: error instanceof Error ? error.message : "Failed to parse XSD.",
+          source: "xsd"
+        })
+      );
+      return { ok: false, doc: null, issues };
+    }
+  }
+
+  // src/model/schemaModel.js
+  function createEmptySchemaModel() {
+    return {
+      kind: "schema",
+      targetNamespace: null,
+      elementFormDefault: null,
+      attributeFormDefault: null,
+      namespaces: {
+        default: null,
+        prefixes: /* @__PURE__ */ Object.create(null)
+      },
+      globals: {
+        elements: /* @__PURE__ */ Object.create(null),
+        complexTypes: /* @__PURE__ */ Object.create(null),
+        simpleTypes: /* @__PURE__ */ Object.create(null),
+        attributes: /* @__PURE__ */ Object.create(null),
+        groups: /* @__PURE__ */ Object.create(null),
+        attributeGroups: /* @__PURE__ */ Object.create(null)
+      },
+      documents: [],
+      externalRefs: {
+        includes: [],
+        imports: []
+      },
+      roots: [],
+      references: {
+        types: [],
+        refs: [],
+        baseTypes: [],
+        groupRefs: [],
+        attributeGroupRefs: []
+      },
+      usedFeatures: /* @__PURE__ */ new Set(),
+      unsupportedFeatures: [],
+      sourceInfo: {
+        systemId: null
+      }
+    };
+  }
+  function normalizeOccurs(value, fallback = 1) {
+    if (value == null || value === "") return fallback;
+    if (value === "unbounded") return "unbounded";
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed >= 0) return parsed;
+    return fallback;
+  }
+  function normalizeUse(value) {
+    if (!value) return null;
+    if (value === "optional" || value === "required" || value === "prohibited") {
+      return value;
+    }
+    return null;
+  }
+  function createElementDecl({
+    name = null,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    typeName = null,
+    refName = null,
+    inlineType = null,
+    minOccurs = 1,
+    maxOccurs = 1,
+    defaultValue = null,
+    fixedValue = null,
+    nillable = false,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "element",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      typeName,
+      refName,
+      inlineType,
+      minOccurs,
+      maxOccurs,
+      defaultValue,
+      fixedValue,
+      nillable,
+      line,
+      column,
+      path
+    };
+  }
+  function createAttributeDecl({
+    name = null,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    typeName = null,
+    refName = null,
+    inlineType = null,
+    use = null,
+    defaultValue = null,
+    fixedValue = null,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "attribute",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      typeName,
+      refName,
+      inlineType,
+      use,
+      defaultValue,
+      fixedValue,
+      line,
+      column,
+      path
+    };
+  }
+  function createComplexTypeDecl({
+    name = null,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    content = null,
+    attributes = [],
+    derivation = { kind: null, baseTypeName: null },
+    mixed = false,
+    abstract = false,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "complexType",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      content,
+      attributes,
+      derivation,
+      mixed,
+      abstract,
+      line,
+      column,
+      path
+    };
+  }
+  function createSimpleTypeDecl({
+    name = null,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    baseTypeName = null,
+    facets = {},
+    enumerations = [],
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "simpleType",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      baseTypeName,
+      facets,
+      enumerations,
+      line,
+      column,
+      path
+    };
+  }
+  function createGroupDecl({
+    name,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    content = null,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "group",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      content,
+      line,
+      column,
+      path
+    };
+  }
+  function createAttributeGroupDecl({
+    name,
+    qName = null,
+    namespaceUri: namespaceUri3 = null,
+    attributes = [],
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "attributeGroup",
+      name,
+      qName,
+      namespaceUri: namespaceUri3,
+      attributes,
+      line,
+      column,
+      path
+    };
+  }
+  function createAttributeGroupRef({
+    refName,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "attributeGroupRef",
+      refName,
+      line,
+      column,
+      path
+    };
+  }
+  function createSequenceNode({
+    children = [],
+    minOccurs = 1,
+    maxOccurs = 1,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "sequence",
+      children,
+      minOccurs,
+      maxOccurs,
+      line,
+      column,
+      path
+    };
+  }
+  function createChoiceNode({
+    children = [],
+    minOccurs = 1,
+    maxOccurs = 1,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "choice",
+      children,
+      minOccurs,
+      maxOccurs,
+      line,
+      column,
+      path
+    };
+  }
+  function createAllNode({
+    children = [],
+    minOccurs = 1,
+    maxOccurs = 1,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "all",
+      children,
+      minOccurs,
+      maxOccurs,
+      line,
+      column,
+      path
+    };
+  }
+  function createGroupRefNode({
+    refName,
+    minOccurs = 1,
+    maxOccurs = 1,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "groupRef",
+      refName,
+      minOccurs,
+      maxOccurs,
+      line,
+      column,
+      path
+    };
+  }
+  function createAnyNode({
+    namespace = null,
+    processContents = null,
+    minOccurs = 1,
+    maxOccurs = 1,
+    line = null,
+    column = null,
+    path = null
+  } = {}) {
+    return {
+      kind: "any",
+      namespace,
+      processContents,
+      minOccurs,
+      maxOccurs,
+      line,
+      column,
+      path
+    };
+  }
+
+  // src/resolver/schemaResolvers.js
+  var BUILTIN_TYPES = /* @__PURE__ */ new Set([
+    "string",
+    "normalizedString",
+    "token",
+    "language",
+    "Name",
+    "NCName",
+    "ID",
+    "IDREF",
+    "IDREFS",
+    "ENTITY",
+    "ENTITIES",
+    "NMTOKEN",
+    "NMTOKENS",
+    "boolean",
+    "decimal",
+    "float",
+    "double",
+    "integer",
+    "nonPositiveInteger",
+    "negativeInteger",
+    "long",
+    "int",
+    "short",
+    "byte",
+    "nonNegativeInteger",
+    "unsignedLong",
+    "unsignedInt",
+    "unsignedShort",
+    "unsignedByte",
+    "positiveInteger",
+    "date",
+    "time",
+    "dateTime",
+    "duration",
+    "gYear",
+    "gYearMonth",
+    "gMonth",
+    "gMonthDay",
+    "gDay",
+    "hexBinary",
+    "base64Binary",
+    "anyURI",
+    "QName",
+    "NOTATION"
+  ]);
+  function parseQName(name) {
+    if (!name || typeof name !== "string") {
+      return { prefix: null, localName: null, qName: name || null };
+    }
+    const idx = name.indexOf(":");
+    if (idx < 0) {
+      return { prefix: null, localName: name, qName: name };
+    }
+    return {
+      prefix: name.slice(0, idx),
+      localName: name.slice(idx + 1),
+      qName: name
+    };
+  }
+  function stripNamespacePrefix(name) {
+    return parseQName(name).localName;
+  }
+  function resolveNamespaceUri(schema, prefix) {
+    if (!schema?.namespaces) return null;
+    if (prefix == null || prefix === "") {
+      return schema.namespaces.default || null;
+    }
+    return schema.namespaces.prefixes?.[prefix] || null;
+  }
+  function resolveQName(schema, qName) {
+    const parsed = parseQName(qName);
+    return {
+      ...parsed,
+      namespaceUri: resolveNamespaceUri(schema, parsed.prefix)
+    };
+  }
+  function makeLookupKey(namespaceUri3, localName3) {
+    return `${namespaceUri3 || ""}::${localName3 || ""}`;
+  }
+  function isBuiltinType(typeName, schema = null) {
+    const q = parseQName(typeName);
+    if (!q.localName) return false;
+    if (BUILTIN_TYPES.has(q.localName)) {
+      if (!q.prefix) return true;
+      if (!schema) return true;
+      const ns = resolveNamespaceUri(schema, q.prefix);
+      return ns === "http://www.w3.org/2001/XMLSchema";
+    }
+    return false;
+  }
+  function lookupByQName(bucket, schema, name) {
+    if (!bucket || !name) return null;
+    const resolved = resolveQName(schema, name);
+    const directKey = makeLookupKey(resolved.namespaceUri, resolved.localName);
+    return bucket[directKey] || bucket[makeLookupKey(null, resolved.localName)] || null;
+  }
+  function resolveGlobalElement(schema, name) {
+    return lookupByQName(schema?.globals?.elements, schema, name);
+  }
+  function resolveGlobalComplexType(schema, name) {
+    return lookupByQName(schema?.globals?.complexTypes, schema, name);
+  }
+  function resolveGlobalSimpleType(schema, name) {
+    return lookupByQName(schema?.globals?.simpleTypes, schema, name);
+  }
+  function resolveGlobalAttribute(schema, name) {
+    return lookupByQName(schema?.globals?.attributes, schema, name);
+  }
+  function resolveGroup(schema, name) {
+    return lookupByQName(schema?.globals?.groups, schema, name);
+  }
+  function resolveAttributeGroup(schema, name) {
+    return lookupByQName(schema?.globals?.attributeGroups, schema, name);
+  }
+  function resolveType(schema, typeName) {
+    if (!typeName) return null;
+    if (isBuiltinType(typeName, schema)) {
+      return {
+        kind: "builtinType",
+        name: parseQName(typeName).localName,
+        qName: typeName
+      };
+    }
+    return resolveGlobalSimpleType(schema, typeName) || resolveGlobalComplexType(schema, typeName) || null;
+  }
+  function resolveElementType(schema, elementDecl) {
+    if (!elementDecl) return null;
+    if (elementDecl.inlineType) return elementDecl.inlineType;
+    if (elementDecl.typeName) return resolveType(schema, elementDecl.typeName);
+    if (elementDecl.refName) {
+      const target = resolveGlobalElement(schema, elementDecl.refName);
+      if (!target) return null;
+      return resolveElementType(schema, target);
+    }
+    return null;
+  }
+  function resolveAttributeType(schema, attributeDecl) {
+    if (!attributeDecl) return null;
+    if (attributeDecl.inlineType) return attributeDecl.inlineType;
+    if (attributeDecl.typeName) return resolveType(schema, attributeDecl.typeName);
+    if (attributeDecl.refName) {
+      const target = resolveGlobalAttribute(schema, attributeDecl.refName);
+      if (!target) return null;
+      return resolveAttributeType(schema, target);
+    }
+    return null;
+  }
+  function getEffectiveSimpleType(schema, simpleTypeDecl) {
+    if (!simpleTypeDecl) return null;
+    const facets = { ...simpleTypeDecl.facets || {} };
+    const enumerations = [...simpleTypeDecl.enumerations || []];
+    if (simpleTypeDecl.baseTypeName && !isBuiltinType(simpleTypeDecl.baseTypeName, schema)) {
+      const base = resolveGlobalSimpleType(schema, simpleTypeDecl.baseTypeName);
+      if (base) {
+        const baseEffective = getEffectiveSimpleType(schema, base);
+        return {
+          ...simpleTypeDecl,
+          baseTypeName: baseEffective?.baseTypeName || simpleTypeDecl.baseTypeName,
+          facets: {
+            ...baseEffective?.facets || {},
+            ...facets
+          },
+          enumerations: enumerations.length ? enumerations : [...baseEffective?.enumerations || []]
+        };
+      }
+    }
+    return {
+      ...simpleTypeDecl,
+      facets,
+      enumerations
+    };
+  }
+  function mergeAttributeArrays(baseAttrs = [], ownAttrs = []) {
+    return [...baseAttrs, ...ownAttrs];
+  }
+  function getEffectiveAttributes(schema, complexTypeDecl) {
+    if (!complexTypeDecl) return [];
+    const own = complexTypeDecl.attributes || [];
+    const baseTypeName = complexTypeDecl.derivation?.baseTypeName;
+    if (!baseTypeName || complexTypeDecl.derivation?.kind !== "extension") {
+      return own;
+    }
+    const base = resolveGlobalComplexType(schema, baseTypeName);
+    if (!base) return own;
+    return mergeAttributeArrays(getEffectiveAttributes(schema, base), own);
+  }
+  function getEffectiveContent(schema, complexTypeDecl) {
+    if (!complexTypeDecl) return null;
+    const ownContent = complexTypeDecl.content || null;
+    const derivationKind = complexTypeDecl.derivation?.kind;
+    const baseTypeName = complexTypeDecl.derivation?.baseTypeName;
+    if (!baseTypeName || !derivationKind) {
+      return ownContent;
+    }
+    const base = resolveGlobalComplexType(schema, baseTypeName);
+    if (!base) return ownContent;
+    const baseContent = getEffectiveContent(schema, base);
+    if (derivationKind === "restriction") {
+      return ownContent || baseContent;
+    }
+    if (derivationKind === "extension") {
+      if (!baseContent) return ownContent;
+      if (!ownContent) return baseContent;
+      return {
+        kind: "sequence",
+        children: [baseContent, ownContent],
+        minOccurs: 1,
+        maxOccurs: 1,
+        line: complexTypeDecl.line,
+        column: complexTypeDecl.column,
+        path: `${complexTypeDecl.path || ""}/effectiveExtensionSequence`
+      };
+    }
+    return ownContent || baseContent;
+  }
+
+  // src/parser/buildSchemaModel.js
+  var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
+    "key",
+    "keyref",
+    "unique",
+    "any",
+    "anyAttribute",
+    "redefine",
+    "notation"
+  ]);
+  function elementChildren(node) {
+    return Array.from(node?.children || []).filter(
+      (child) => child.nodeType === 1
+    );
+  }
+  function recordExternalRef(schema, kind, node, path, loc) {
+    const entry = {
+      kind,
+      namespace: node.getAttribute("namespace") || null,
+      schemaLocation: node.getAttribute("schemaLocation") || null,
+      line: loc.line,
+      column: loc.column,
+      path
+    };
+    if (kind === "include") {
+      schema.externalRefs.includes.push(entry);
+    } else if (kind === "import") {
+      schema.externalRefs.imports.push(entry);
+    }
+  }
+  function mergeGlobalsIntoSchema(targetSchema, sourceSchema, issues, createDuplicateIssue) {
+    const buckets = [
+      ["elements", "DUPLICATE_GLOBAL_ELEMENT"],
+      ["complexTypes", "DUPLICATE_GLOBAL_COMPLEX_TYPE"],
+      ["simpleTypes", "DUPLICATE_GLOBAL_SIMPLE_TYPE"],
+      ["attributes", "DUPLICATE_GLOBAL_ATTRIBUTE"],
+      ["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]) {
+          issues.push(createDuplicateIssue(duplicateCode, decl));
+          continue;
+        }
+        targetSchema.globals[bucketName][key] = decl;
+      }
+    }
+    targetSchema.roots.push(...sourceSchema.roots || []);
+    targetSchema.references.types.push(...sourceSchema.references.types || []);
+    targetSchema.references.refs.push(...sourceSchema.references.refs || []);
+    targetSchema.references.baseTypes.push(
+      ...sourceSchema.references.baseTypes || []
+    );
+    targetSchema.references.groupRefs.push(
+      ...sourceSchema.references.groupRefs || []
+    );
+    targetSchema.references.attributeGroupRefs.push(
+      ...sourceSchema.references.attributeGroupRefs || []
+    );
+    targetSchema.externalRefs.includes.push(
+      ...sourceSchema.externalRefs.includes || []
+    );
+    targetSchema.externalRefs.imports.push(
+      ...sourceSchema.externalRefs.imports || []
+    );
+    for (const feature of sourceSchema.usedFeatures || []) {
+      targetSchema.usedFeatures.add(feature);
+    }
+    targetSchema.unsupportedFeatures.push(
+      ...sourceSchema.unsupportedFeatures || []
+    );
+  }
+  function extractNamespaces(schemaRoot, schema) {
+    for (const attr of Array.from(schemaRoot.attributes || [])) {
+      if (attr.name === "xmlns") {
+        schema.namespaces.default = attr.value;
+      } else if (attr.name.startsWith("xmlns:")) {
+        const prefix = attr.name.slice("xmlns:".length);
+        schema.namespaces.prefixes[prefix] = attr.value;
+      }
+    }
+  }
+  function getDeclarationNamespaceUri(schema, node, kind) {
+    const isQualified = kind === "attribute" ? schema.attributeFormDefault === "qualified" : schema.elementFormDefault === "qualified";
+    if (node.parentElement?.localName === "schema") {
+      return schema.targetNamespace || null;
+    }
+    return isQualified ? schema.targetNamespace || null : null;
+  }
+  function getSchemaRoot(doc) {
+    const root = doc?.documentElement || null;
+    return root && root.localName === "schema" ? root : null;
+  }
+  function makeLineIndex(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i += 1) {
+      if (text[i] === "\n") starts.push(i + 1);
+    }
+    return starts;
+  }
+  function indexToLineColumn(index, lineStarts) {
+    let line = 1;
+    for (let i = 0; i < lineStarts.length; i += 1) {
+      if (lineStarts[i] > index) break;
+      line = i + 1;
+    }
+    const lineStart = lineStarts[line - 1] ?? 0;
+    return {
+      line,
+      column: index - lineStart + 1
+    };
+  }
+  function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  function locateNodeInSource(xsdText, lineStarts, node) {
+    if (!xsdText || !node) return { line: null, column: null };
+    const localName3 = node.localName;
+    const name = node.getAttribute("name");
+    const ref = node.getAttribute("ref");
+    const base = node.getAttribute("base");
+    const type = node.getAttribute("type");
+    const candidates = [
+      name ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bname=(["'])${escapeRegExp(name)}\\1` : null,
+      ref ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bref=(["'])${escapeRegExp(ref)}\\1` : null,
+      base ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\bbase=(["'])${escapeRegExp(base)}\\1` : null,
+      type ? `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b[^>]*\\btype=(["'])${escapeRegExp(type)}\\1` : null,
+      `<(?:[\\w.-]+:)?${escapeRegExp(localName3)}\\b`
+    ].filter(Boolean);
+    for (const pattern of candidates) {
+      const regex = new RegExp(pattern, "m");
+      const match = regex.exec(xsdText);
+      if (match && typeof match.index === "number") {
+        return indexToLineColumn(match.index, lineStarts);
+      }
+    }
+    return { line: null, column: null };
+  }
+  function buildPath(parentPath, node) {
+    const kind = node.localName;
+    const name = node.getAttribute("name");
+    const ref = node.getAttribute("ref");
+    const base = node.getAttribute("base");
+    let qualifier = "";
+    if (name) qualifier = `[name="${name}"]`;
+    else if (ref) qualifier = `[ref="${ref}"]`;
+    else if (base) qualifier = `[base="${base}"]`;
+    return `${parentPath}/${kind}${qualifier}`;
+  }
+  function registerGlobal(schema, issues, bucketName, duplicateCode, decl) {
+    const localName3 = stripNamespacePrefix(decl.name);
+    if (!localName3) return;
+    const key = makeLookupKey(decl.namespaceUri, localName3);
+    if (schema.globals[bucketName][key]) {
+      issues.push(
+        createIssue({
+          code: duplicateCode,
+          severity: "error",
+          message: `Duplicate global ${decl.kind} declaration '${decl.name}'.`,
+          line: decl.line,
+          column: decl.column,
+          path: decl.path,
+          source: "xsd",
+          nodeKind: decl.kind,
+          name: decl.name,
+          details: { declarationName: decl.name }
+        })
+      );
+      return;
+    }
+    schema.globals[bucketName][key] = decl;
+  }
+  function collectReference(schema, kind, payload) {
+    schema.references[kind].push(payload);
+  }
+  function collectUnsupportedFeature(schema, feature) {
+    schema.unsupportedFeatures.push(feature);
+  }
+  function collectNodeDiagnostics(schema, issues, node, path, loc) {
+    const localName3 = node.localName;
+    schema.usedFeatures.add(localName3);
+    if (UNSUPPORTED_NODE_FEATURES.has(localName3)) {
+      collectUnsupportedFeature(schema, {
+        feature: `xs:${localName3}`,
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    if (node.hasAttribute("substitutionGroup")) {
+      collectUnsupportedFeature(schema, {
+        feature: "xs:substitutionGroup",
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    if (node.hasAttribute("type")) {
+      collectReference(schema, "types", {
+        typeName: node.getAttribute("type"),
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || node.getAttribute("ref") || null
+      });
+    }
+    if ((localName3 === "element" || localName3 === "attribute") && node.hasAttribute("ref")) {
+      collectReference(schema, "refs", {
+        refName: node.getAttribute("ref"),
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    if ((localName3 === "extension" || localName3 === "restriction") && node.hasAttribute("base")) {
+      collectReference(schema, "baseTypes", {
+        baseTypeName: node.getAttribute("base"),
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    if (localName3 === "group" && node.hasAttribute("ref")) {
+      collectReference(schema, "groupRefs", {
+        refName: node.getAttribute("ref"),
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    if (localName3 === "attributeGroup" && node.hasAttribute("ref")) {
+      collectReference(schema, "attributeGroupRefs", {
+        refName: node.getAttribute("ref"),
+        line: loc.line,
+        column: loc.column,
+        path,
+        nodeKind: localName3,
+        name: node.getAttribute("name") || null
+      });
+    }
+    const minOccurs = normalizeOccurs(node.getAttribute("minOccurs"), 1);
+    const maxOccurs = normalizeOccurs(node.getAttribute("maxOccurs"), 1);
+    if (typeof minOccurs === "number" && typeof maxOccurs === "number" && minOccurs > maxOccurs) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.INVALID_OCCURS_RANGE,
+          severity: "error",
+          message: `Invalid occurs range: minOccurs (${minOccurs}) is greater than maxOccurs (${maxOccurs}).`,
+          line: loc.line,
+          column: loc.column,
+          path,
+          source: "xsd",
+          nodeKind: localName3,
+          name: node.getAttribute("name") || null,
+          details: { minOccurs, maxOccurs }
+        })
+      );
+    }
+    if ((localName3 === "element" || localName3 === "attribute") && node.hasAttribute("default") && node.hasAttribute("fixed")) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.INVALID_DEFAULT_FIXED_COMBINATION,
+          severity: "error",
+          message: "Node cannot declare both default and fixed values.",
+          line: loc.line,
+          column: loc.column,
+          path,
+          source: "xsd",
+          nodeKind: localName3,
+          name: node.getAttribute("name") || node.getAttribute("ref") || null,
+          details: {
+            defaultValue: node.getAttribute("default"),
+            fixedValue: node.getAttribute("fixed")
+          }
+        })
+      );
+    }
+  }
+  function parseFacets(node) {
+    const facets = {};
+    const enumerations = [];
+    for (const child of elementChildren(node)) {
+      switch (child.localName) {
+        case "enumeration":
+          if (child.hasAttribute("value")) {
+            enumerations.push(child.getAttribute("value"));
+          }
+          break;
+        case "minLength":
+        case "maxLength":
+        case "length":
+        case "totalDigits":
+        case "fractionDigits":
+          if (child.hasAttribute("value")) {
+            const n = Number(child.getAttribute("value"));
+            if (Number.isFinite(n)) facets[child.localName] = n;
+          }
+          break;
+        case "minInclusive":
+        case "maxInclusive":
+        case "minExclusive":
+        case "maxExclusive":
+          if (child.hasAttribute("value")) {
+            facets[child.localName] = child.getAttribute("value");
+          }
+          break;
+        case "pattern":
+          if (!facets.pattern) facets.pattern = [];
+          if (child.hasAttribute("value")) {
+            facets.pattern.push(child.getAttribute("value"));
+          }
+          break;
+        case "whiteSpace":
+          if (child.hasAttribute("value")) {
+            facets.whiteSpace = child.getAttribute("value");
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    return { facets, enumerations };
+  }
+  function parseSimpleType(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    let baseTypeName = null;
+    let facets = {};
+    let enumerations = [];
+    const restriction = elementChildren(node).find(
+      (child) => child.localName === "restriction"
+    );
+    if (restriction) {
+      const restrictionPath = buildPath(path, restriction);
+      const restrictionLoc = locateNodeInSource(xsdText, lineStarts, restriction);
+      collectNodeDiagnostics(
+        schema,
+        issues,
+        restriction,
+        restrictionPath,
+        restrictionLoc
+      );
+      baseTypeName = restriction.getAttribute("base");
+      const parsed = parseFacets(restriction);
+      facets = parsed.facets;
+      enumerations = parsed.enumerations;
+    }
+    const qName = node.getAttribute("name");
+    const namespaceUri3 = schema.targetNamespace || null;
+    return createSimpleTypeDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceUri: namespaceUri3,
+      baseTypeName,
+      facets,
+      enumerations,
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  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(
+      (child) => child.localName === "simpleType"
+    );
+    const inlineType = inlineSimpleTypeNode ? parseSimpleType(
+      inlineSimpleTypeNode,
+      xsdText,
+      lineStarts,
+      path,
+      schema,
+      issues
+    ) : null;
+    const qName = node.getAttribute("name");
+    const namespaceURI = getDeclarationNamespaceUri(schema, node, "attribute");
+    return createAttributeDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceURI,
+      typeName: node.getAttribute("type"),
+      refName: node.getAttribute("ref"),
+      inlineType,
+      use: normalizeUse(node.getAttribute("use")),
+      defaultValue: node.getAttribute("default"),
+      fixedValue: node.getAttribute("fixed"),
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseAttributeGroupRef(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    return createAttributeGroupRef({
+      refName: node.getAttribute("ref"),
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseAttributesContainer(nodes, xsdText, lineStarts, parentPath, schema, issues) {
+    const attributes = [];
+    for (const child of nodes) {
+      if (child.localName === "attribute") {
+        attributes.push(
+          parseAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+        );
+      } else if (child.localName === "attributeGroup" && child.hasAttribute("ref")) {
+        attributes.push(
+          parseAttributeGroupRef(
+            child,
+            xsdText,
+            lineStarts,
+            parentPath,
+            schema,
+            issues
+          )
+        );
+      }
+    }
+    return attributes;
+  }
+  function parseElement(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    let inlineType = null;
+    const children = elementChildren(node);
+    const inlineComplexTypeNode = children.find(
+      (child) => child.localName === "complexType"
+    );
+    const inlineSimpleTypeNode = children.find(
+      (child) => child.localName === "simpleType"
+    );
+    if (inlineComplexTypeNode) {
+      inlineType = parseComplexType(
+        inlineComplexTypeNode,
+        xsdText,
+        lineStarts,
+        path,
+        schema,
+        issues
+      );
+    } else if (inlineSimpleTypeNode) {
+      inlineType = parseSimpleType(
+        inlineSimpleTypeNode,
+        xsdText,
+        lineStarts,
+        path,
+        schema,
+        issues
+      );
+    }
+    const qName = node.getAttribute("name");
+    const namespaceUri3 = getDeclarationNamespaceUri(schema, node, "element");
+    return createElementDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceUri: namespaceUri3,
+      typeName: node.getAttribute("type"),
+      refName: node.getAttribute("ref"),
+      inlineType,
+      minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+      maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+      defaultValue: node.getAttribute("default"),
+      fixedValue: node.getAttribute("fixed"),
+      nillable: node.getAttribute("nillable") === "true",
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseGroupRef(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    return createGroupRefNode({
+      refName: node.getAttribute("ref"),
+      minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+      maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  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"),
+      processContents: node.getAttribute("processContents"),
+      minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+      maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseContentNode(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    switch (node.localName) {
+      case "sequence":
+        return createSequenceNode({
+          children: parseContentChildren(
+            node,
+            xsdText,
+            lineStarts,
+            path,
+            schema,
+            issues
+          ),
+          minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+          maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+          line: loc.line,
+          column: loc.column,
+          path
+        });
+      case "choice":
+        return createChoiceNode({
+          children: parseContentChildren(
+            node,
+            xsdText,
+            lineStarts,
+            path,
+            schema,
+            issues
+          ),
+          minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+          maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+          line: loc.line,
+          column: loc.column,
+          path
+        });
+      case "all":
+        return createAllNode({
+          children: parseContentChildren(
+            node,
+            xsdText,
+            lineStarts,
+            path,
+            schema,
+            issues
+          ),
+          minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
+          maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+          line: loc.line,
+          column: loc.column,
+          path
+        });
+      case "element":
+        return parseElement(
+          node,
+          xsdText,
+          lineStarts,
+          parentPath,
+          schema,
+          issues
+        );
+      case "group":
+        if (node.hasAttribute("ref")) {
+          return parseGroupRef(
+            node,
+            xsdText,
+            lineStarts,
+            parentPath,
+            schema,
+            issues
+          );
+        }
+        return null;
+      case "any":
+        return parseAny(node, xsdText, lineStarts, parentPath, schema, issues);
+      default:
+        return null;
+    }
+  }
+  function parseContentChildren(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const children = [];
+    for (const child of elementChildren(node)) {
+      const parsed = parseContentNode(
+        child,
+        xsdText,
+        lineStarts,
+        parentPath,
+        schema,
+        issues
+      );
+      if (parsed) children.push(parsed);
+    }
+    return children;
+  }
+  function parseDerivationNode(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    let content = null;
+    const contentNode = elementChildren(node).find(
+      (child) => ["sequence", "choice", "all", "group", "element", "any"].includes(
+        child.localName
+      )
+    );
+    if (contentNode) {
+      content = parseContentNode(
+        contentNode,
+        xsdText,
+        lineStarts,
+        path,
+        schema,
+        issues
+      );
+    }
+    const attributes = parseAttributesContainer(
+      elementChildren(node).filter(
+        (child) => child.localName === "attribute" || child.localName === "attributeGroup"
+      ),
+      xsdText,
+      lineStarts,
+      path,
+      schema,
+      issues
+    );
+    return {
+      derivation: {
+        kind: node.localName,
+        baseTypeName: node.getAttribute("base")
+      },
+      content,
+      attributes,
+      line: loc.line,
+      column: loc.column,
+      path
+    };
+  }
+  function parseComplexType(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    let content = null;
+    let attributes = [];
+    let derivation = { kind: null, baseTypeName: null };
+    const children = elementChildren(node);
+    const directContentNode = children.find(
+      (child) => ["sequence", "choice", "all", "group", "element", "any"].includes(
+        child.localName
+      )
+    );
+    if (directContentNode) {
+      content = parseContentNode(
+        directContentNode,
+        xsdText,
+        lineStarts,
+        path,
+        schema,
+        issues
+      );
+    }
+    const complexContent = children.find(
+      (child) => child.localName === "complexContent"
+    );
+    const simpleContent = children.find(
+      (child) => child.localName === "simpleContent"
+    );
+    if (complexContent || simpleContent) {
+      const wrapper = complexContent || simpleContent;
+      const wrapperPath = buildPath(path, wrapper);
+      const wrapperLoc = locateNodeInSource(xsdText, lineStarts, wrapper);
+      collectNodeDiagnostics(schema, issues, wrapper, wrapperPath, wrapperLoc);
+      const derivationNode = elementChildren(wrapper).find(
+        (child) => child.localName === "extension" || child.localName === "restriction"
+      );
+      if (derivationNode) {
+        const parsed = parseDerivationNode(
+          derivationNode,
+          xsdText,
+          lineStarts,
+          wrapperPath,
+          schema,
+          issues
+        );
+        derivation = parsed.derivation;
+        if (parsed.content) content = parsed.content;
+        attributes = parsed.attributes;
+      }
+    }
+    if (attributes.length === 0) {
+      attributes = parseAttributesContainer(
+        children.filter(
+          (child) => child.localName === "attribute" || child.localName === "attributeGroup"
+        ),
+        xsdText,
+        lineStarts,
+        path,
+        schema,
+        issues
+      );
+    }
+    const qName = node.getAttribute("name");
+    const namespaceURI = schema.targetNamespace || null;
+    return createComplexTypeDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceURI,
+      content,
+      attributes,
+      derivation,
+      mixed: node.getAttribute("mixed") === "true",
+      abstract: node.getAttribute("abstract") === "true",
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseGroup(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    const contentNode = elementChildren(node).find(
+      (child) => ["sequence", "choice", "all"].includes(child.localName)
+    );
+    const qName = node.getAttribute("name");
+    const namespaceUri3 = schema.targetNamespace || null;
+    return createGroupDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceUri: namespaceUri3,
+      content: contentNode ? parseContentNode(contentNode, xsdText, lineStarts, path, schema, issues) : null,
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function parseAttributeGroup(node, xsdText, lineStarts, parentPath, schema, issues) {
+    const path = buildPath(parentPath, node);
+    const loc = locateNodeInSource(xsdText, lineStarts, node);
+    collectNodeDiagnostics(schema, issues, node, path, loc);
+    const attributes = parseAttributesContainer(
+      elementChildren(node).filter(
+        (child) => child.localName === "attribute" || child.localName === "attributeGroup"
+      ),
+      xsdText,
+      lineStarts,
+      path,
+      schema,
+      issues
+    );
+    const qName = node.getAttribute("name");
+    const namespaceUri3 = schema.targetNamespace || null;
+    return createAttributeGroupDecl({
+      name: qName ? parseQName(qName).localName : null,
+      qName,
+      namespaceUri: namespaceUri3,
+      attributes,
+      line: loc.line,
+      column: loc.column,
+      path
+    });
+  }
+  function buildSchemaModel(doc, options = {}) {
+    const issues = [];
+    const schema = createEmptySchemaModel();
+    const xsdText = options.xsdText || "";
+    const lineStarts = makeLineIndex(xsdText);
+    const schemaRoot = getSchemaRoot(doc);
+    if (!schemaRoot) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_SCHEMA_NODE_MISSING,
+          severity: "error",
+          message: "Document root is not an xs:schema node.",
+          source: "xsd"
+        })
+      );
+      return { schema: null, issues };
+    }
+    schema.targetNamespace = schemaRoot.getAttribute("targetNamespace");
+    schema.elementFormDefault = schemaRoot.getAttribute("elementFormDefault");
+    schema.attributeFormDefault = schemaRoot.getAttribute("attributeFormDefault");
+    extractNamespaces(schemaRoot, schema);
+    const rootPath = "/schema";
+    const rootLoc = locateNodeInSource(xsdText, lineStarts, schemaRoot);
+    collectNodeDiagnostics(schema, issues, schemaRoot, rootPath, rootLoc);
+    const children = elementChildren(schemaRoot);
+    for (const child of children) {
+      switch (child.localName) {
+        case "element": {
+          const decl = parseElement(
+            child,
+            xsdText,
+            lineStarts,
+            rootPath,
+            schema,
+            issues
+          );
+          registerGlobal(
+            schema,
+            issues,
+            "elements",
+            ISSUE_CODES.DUPLICATE_GLOBAL_ELEMENT,
+            decl
+          );
+          if (decl.name) {
+            schema.roots.push({
+              name: decl.name,
+              qName: decl.qName,
+              namespaceUri: decl.namespaceUri,
+              typeName: decl.typeName || decl.inlineType?.name || null,
+              line: decl.line,
+              column: decl.column,
+              path: decl.path
+            });
+          }
+          break;
+        }
+        case "complexType": {
+          const decl = parseComplexType(
+            child,
+            xsdText,
+            lineStarts,
+            rootPath,
+            schema,
+            issues
+          );
+          registerGlobal(
+            schema,
+            issues,
+            "complexTypes",
+            ISSUE_CODES.DUPLICATE_GLOBAL_COMPLEX_TYPE,
+            decl
+          );
+          break;
+        }
+        case "simpleType": {
+          const decl = parseSimpleType(
+            child,
+            xsdText,
+            lineStarts,
+            rootPath,
+            schema,
+            issues
+          );
+          registerGlobal(
+            schema,
+            issues,
+            "simpleTypes",
+            ISSUE_CODES.DUPLICATE_GLOBAL_SIMPLE_TYPE,
+            decl
+          );
+          break;
+        }
+        case "attribute": {
+          const decl = parseAttribute(
+            child,
+            xsdText,
+            lineStarts,
+            rootPath,
+            schema,
+            issues
+          );
+          registerGlobal(
+            schema,
+            issues,
+            "attributes",
+            ISSUE_CODES.DUPLICATE_GLOBAL_ATTRIBUTE,
+            decl
+          );
+          break;
+        }
+        case "group": {
+          if (child.hasAttribute("name")) {
+            const decl = parseGroup(
+              child,
+              xsdText,
+              lineStarts,
+              rootPath,
+              schema,
+              issues
+            );
+            registerGlobal(
+              schema,
+              issues,
+              "groups",
+              ISSUE_CODES.DUPLICATE_GLOBAL_GROUP,
+              decl
+            );
+          } else {
+            const path = buildPath(rootPath, child);
+            const loc = locateNodeInSource(xsdText, lineStarts, child);
+            collectNodeDiagnostics(schema, issues, child, path, loc);
+          }
+          break;
+        }
+        case "attributeGroup": {
+          if (child.hasAttribute("name")) {
+            const decl = parseAttributeGroup(
+              child,
+              xsdText,
+              lineStarts,
+              rootPath,
+              schema,
+              issues
+            );
+            registerGlobal(
+              schema,
+              issues,
+              "attributeGroups",
+              ISSUE_CODES.DUPLICATE_GLOBAL_ATTRIBUTE_GROUP,
+              decl
+            );
+          } else {
+            const path = buildPath(rootPath, child);
+            const loc = locateNodeInSource(xsdText, lineStarts, child);
+            collectNodeDiagnostics(schema, issues, child, path, loc);
+          }
+          break;
+        }
+        case "include": {
+          const path = buildPath(rootPath, child);
+          const loc = locateNodeInSource(xsdText, lineStarts, child);
+          collectNodeDiagnostics(schema, issues, child, path, loc);
+          recordExternalRef(schema, "include", child, path, loc);
+          break;
+        }
+        case "import": {
+          const path = buildPath(rootPath, child);
+          const loc = locateNodeInSource(xsdText, lineStarts, child);
+          collectNodeDiagnostics(schema, issues, child, path, loc);
+          recordExternalRef(schema, "import", child, path, loc);
+          break;
+        }
+        default: {
+          const path = buildPath(rootPath, child);
+          const loc = locateNodeInSource(xsdText, lineStarts, child);
+          collectNodeDiagnostics(schema, issues, child, path, loc);
+          break;
+        }
+      }
+    }
+    const externalDocuments = options.externalDocuments || {};
+    const createDuplicateIssue = (code, decl) => createIssue({
+      code: ISSUE_CODES[code] || code,
+      severity: "error",
+      message: `Duplicate global ${decl.kind} declaration '${decl.name}'.`,
+      line: decl.line,
+      column: decl.column,
+      path: decl.path,
+      source: "xsd",
+      nodeKind: decl.kind,
+      name: decl.name,
+      details: { declarationName: decl.name }
+    });
+    const allExternalRefs = [
+      ...schema.externalRefs.includes || [],
+      ...schema.externalRefs.imports || []
+    ];
+    for (const ref of allExternalRefs) {
+      if (!ref.schemaLocation) continue;
+      const externalXsdText = externalDocuments[ref.schemaLocation];
+      if (!externalXsdText) continue;
+      const parser = new DOMParser();
+      const externalDoc = parser.parseFromString(
+        externalXsdText,
+        "application/xml"
+      );
+      const parserError = externalDoc.querySelector("parsererror");
+      if (parserError) {
+        continue;
+      }
+      const externalBuild = buildSchemaModel(externalDoc, {
+        ...options,
+        xsdText: externalXsdText,
+        externalDocuments: {}
+      });
+      if (externalBuild.schema) {
+        mergeGlobalsIntoSchema(
+          schema,
+          externalBuild.schema,
+          issues,
+          createDuplicateIssue
+        );
+      }
+      issues.push(...externalBuild.issues || []);
+    }
+    return { schema, issues };
+  }
+
+  // src/diagnostics/schemaFacetDiagnostics.js
+  function toNumber(value) {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  function checkLengthConflicts(simpleType, issues, ctx) {
+    const f = simpleType.facets || {};
+    if (f.length != null) {
+      if (f.minLength != null && f.length < f.minLength) {
+        issues.push(ctx.issue("XSD_LENGTH_CONFLICT", `length (${f.length}) is less than minLength (${f.minLength}).`, simpleType));
+      }
+      if (f.maxLength != null && f.length > f.maxLength) {
+        issues.push(ctx.issue("XSD_LENGTH_CONFLICT", `length (${f.length}) exceeds maxLength (${f.maxLength}).`, simpleType));
+      }
+    }
+    if (f.minLength != null && f.maxLength != null && f.minLength > f.maxLength) {
+      issues.push(ctx.issue("XSD_LENGTH_CONFLICT", `minLength (${f.minLength}) is greater than maxLength (${f.maxLength}).`, simpleType));
+    }
+  }
+  function checkNumericConflicts(simpleType, issues, ctx) {
+    const f = simpleType.facets || {};
+    const minInc = toNumber(f.minInclusive);
+    const maxInc = toNumber(f.maxInclusive);
+    const minExc = toNumber(f.minExclusive);
+    const maxExc = toNumber(f.maxExclusive);
+    if (minInc != null && maxInc != null && minInc > maxInc) {
+      issues.push(ctx.issue("XSD_NUMERIC_RANGE_CONFLICT", `minInclusive (${minInc}) > maxInclusive (${maxInc}).`, simpleType));
+    }
+    if (minExc != null && maxExc != null && minExc >= maxExc) {
+      issues.push(ctx.issue("XSD_NUMERIC_RANGE_CONFLICT", `minExclusive (${minExc}) >= maxExclusive (${maxExc}).`, simpleType));
+    }
+    if (minInc != null && maxExc != null && minInc >= maxExc) {
+      issues.push(ctx.issue("XSD_NUMERIC_RANGE_CONFLICT", `minInclusive (${minInc}) >= maxExclusive (${maxExc}).`, simpleType));
+    }
+    if (minExc != null && maxInc != null && minExc >= maxInc) {
+      issues.push(ctx.issue("XSD_NUMERIC_RANGE_CONFLICT", `minExclusive (${minExc}) >= maxInclusive (${maxInc}).`, simpleType));
+    }
+  }
+  function checkDigitConflicts(simpleType, issues, ctx) {
+    const f = simpleType.facets || {};
+    if (f.totalDigits != null && f.totalDigits <= 0) {
+      issues.push(ctx.issue("XSD_DIGITS_INVALID", `totalDigits must be > 0.`, simpleType));
+    }
+    if (f.fractionDigits != null && f.fractionDigits < 0) {
+      issues.push(ctx.issue("XSD_DIGITS_INVALID", `fractionDigits must be >= 0.`, simpleType));
+    }
+    if (f.totalDigits != null && f.fractionDigits != null && f.fractionDigits > f.totalDigits) {
+      issues.push(
+        ctx.issue(
+          "XSD_DIGITS_CONFLICT",
+          `fractionDigits (${f.fractionDigits}) cannot exceed totalDigits (${f.totalDigits}).`,
+          simpleType
+        )
+      );
+    }
+  }
+  function checkEnumeration(simpleType, issues, ctx) {
+    const enums = simpleType.enumerations || [];
+    if (enums.length === 0) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const val of enums) {
+      if (seen.has(val)) {
+        issues.push(ctx.issue("XSD_ENUM_DUPLICATE", `Duplicate enumeration value '${val}'.`, simpleType));
+      }
+      seen.add(val);
+    }
+  }
+  function checkPattern(simpleType, issues, ctx) {
+    const patterns = simpleType.facets?.pattern || [];
+    for (const pattern of patterns) {
+      try {
+        new RegExp(pattern);
+      } catch {
+        issues.push(ctx.issue("XSD_PATTERN_INVALID", `Invalid regex pattern '${pattern}'.`, simpleType));
+      }
+    }
+  }
+  function allowedFacetMap() {
+    return {
+      string: ["length", "minLength", "maxLength", "pattern", "enumeration"],
+      normalizedString: ["length", "minLength", "maxLength", "pattern", "enumeration"],
+      token: ["length", "minLength", "maxLength", "pattern", "enumeration"],
+      anyURI: ["length", "minLength", "maxLength", "pattern", "enumeration"],
+      QName: ["length", "minLength", "maxLength", "pattern", "enumeration"],
+      decimal: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "totalDigits", "fractionDigits", "pattern", "enumeration"],
+      integer: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "totalDigits", "pattern", "enumeration"],
+      boolean: ["pattern", "enumeration"],
+      date: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      dateTime: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      time: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      gYear: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      gYearMonth: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      gMonth: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      gMonthDay: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"],
+      gDay: ["minInclusive", "maxInclusive", "minExclusive", "maxExclusive", "pattern", "enumeration"]
+    };
+  }
+  function checkFacetCompatibility(simpleType, issues, ctx) {
+    const base = simpleType.baseTypeName;
+    if (!base || !isBuiltinType(base)) return;
+    const local = stripNamespacePrefix(base);
+    const allowed = allowedFacetMap()[local];
+    if (!allowed) return;
+    for (const key of Object.keys(simpleType.facets || {})) {
+      if (!allowed.includes(key)) {
+        issues.push(
+          ctx.issue(
+            "XSD_FACET_NOT_ALLOWED",
+            `Facet '${key}' is not valid for base type '${local}'.`,
+            simpleType
+          )
+        );
+      }
+    }
+  }
+  function runFacetDiagnostics(schema, options = {}) {
+    const issues = [];
+    const ctx = {
+      issue: (code, message, node) => createIssue({
+        code,
+        severity: "warning",
+        message,
+        source: "xsd",
+        nodeKind: "simpleType",
+        name: node.name,
+        line: node.line,
+        column: node.column
+      })
+    };
+    for (const simpleType of Object.values(schema.globals.simpleTypes || {})) {
+      checkFacetCompatibility(simpleType, issues, ctx);
+      checkLengthConflicts(simpleType, issues, ctx);
+      checkNumericConflicts(simpleType, issues, ctx);
+      checkDigitConflicts(simpleType, issues, ctx);
+      checkEnumeration(simpleType, issues, ctx);
+      checkPattern(simpleType, issues, ctx);
+    }
+    return issues;
+  }
+
+  // src/diagnostics/schemaRestrictionDiagnostics.js
+  function asArray(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  function localDeclName(node) {
+    return node?.refName || node?.name || null;
+  }
+  function flattenContent(node, out = []) {
+    if (!node) return out;
+    switch (node.kind) {
+      case "sequence":
+      case "choice":
+      case "all":
+        for (const child of asArray(node.children)) {
+          flattenContent(child, out);
+        }
+        return out;
+      case "groupRef":
+        out.push({
+          kind: "groupRef",
+          name: node.refName,
+          minOccurs: node.minOccurs,
+          maxOccurs: node.maxOccurs,
+          line: node.line,
+          column: node.column,
+          path: node.path
+        });
+        return out;
+      case "element":
+        out.push({
+          kind: "element",
+          name: localDeclName(node),
+          minOccurs: node.minOccurs,
+          maxOccurs: node.maxOccurs,
+          line: node.line,
+          column: node.column,
+          path: node.path
+        });
+        return out;
+      default:
+        return out;
+    }
+  }
+  function maxToNumber(value) {
+    return value === "unbounded" ? Infinity : value;
+  }
+  function isWiderRestriction(derived, base) {
+    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 attributeUseRank(use) {
+    switch (use) {
+      case "required":
+        return 3;
+      case "optional":
+        return 2;
+      case "prohibited":
+        return 1;
+      default:
+        return 2;
+    }
+  }
+  function buildRestrictionIssue(code, message, node) {
+    return createIssue({
+      code,
+      severity: "warning",
+      message,
+      source: "xsd",
+      nodeKind: node?.kind || "complexType",
+      name: node?.name || null,
+      line: node?.line ?? null,
+      column: node?.column ?? null,
+      path: node?.path ?? null,
+      details: {}
+    });
+  }
+  function checkRestrictedContentSubset(schema, derivedType, baseType, issues) {
+    const derivedContent = flattenContent(getEffectiveContent(schema, derivedType), []);
+    const baseContent = flattenContent(getEffectiveContent(schema, baseType), []);
+    const baseMap = new Map(baseContent.map((item) => [item.name, item]));
+    for (const item of derivedContent) {
+      const baseItem = baseMap.get(item.name);
+      if (!baseItem) {
+        issues.push(
+          buildRestrictionIssue(
+            "XSD_RESTRICTION_NOT_SUBSET",
+            `Restricted type contains element/group '${item.name}' that does not exist in base type '${baseType.name}'.`,
+            item
+          )
+        );
+        continue;
+      }
+      if (isWiderRestriction(item, baseItem)) {
+        issues.push(
+          buildRestrictionIssue(
+            "XSD_RESTRICTION_OCCURS_WIDENED",
+            `Restricted type widens occurrence constraints for '${item.name}'.`,
+            item
+          )
+        );
+      }
+    }
+  }
+  function checkRestrictedAttributes(schema, derivedType, baseType, issues) {
+    const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+    const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+    const baseMap = 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 = baseMap.get(name);
+      if (!baseAttr) {
+        issues.push(
+          buildRestrictionIssue(
+            "XSD_RESTRICTION_NOT_SUBSET",
+            `Restricted type contains attribute '${name}' that does not exist in base type '${baseType.name}'.`,
+            attr
+          )
+        );
+        continue;
+      }
+      if (attributeUseRank(attr.use) > attributeUseRank(baseAttr.use)) {
+        issues.push(
+          buildRestrictionIssue(
+            "XSD_RESTRICTION_ATTRIBUTE_WIDENED",
+            `Restricted type widens attribute constraint for '${name}'.`,
+            attr
+          )
+        );
+      }
+    }
+  }
+  function runRestrictionDiagnostics(schema) {
+    const issues = [];
+    for (const complexType of Object.values(schema.globals.complexTypes || {})) {
+      if (complexType?.derivation?.kind !== "restriction") continue;
+      if (!complexType?.derivation?.baseTypeName) continue;
+      const baseType = resolveGlobalComplexType(schema, complexType.derivation.baseTypeName);
+      if (!baseType) continue;
+      checkRestrictedContentSubset(schema, complexType, baseType, issues);
+      checkRestrictedAttributes(schema, complexType, baseType, issues);
+    }
+    return issues;
+  }
+
+  // src/diagnostics/schemaDefaultFixedDiagnostics.js
+  function checkDefaultFixedConflict(node, issues) {
+    if (node.defaultValue != null && node.fixedValue != null) {
+      issues.push(
+        createIssue({
+          code: "XSD_DEFAULT_AND_FIXED_CONFLICT",
+          severity: "warning",
+          message: "Element/attribute cannot have both 'default' and 'fixed'.",
+          source: "xsd",
+          nodeKind: node.kind,
+          name: node.name || node.refName,
+          line: node.line,
+          column: node.column
+        })
+      );
+    }
+  }
+  function runDefaultFixedDiagnostics(schema) {
+    const issues = [];
+    for (const el of Object.values(schema.globals.elements || {})) {
+      checkDefaultFixedConflict(el, issues);
+    }
+    for (const type of Object.values(schema.globals.complexTypes || {})) {
+      for (const attr of type.attributes || []) {
+        if (attr.kind === "attribute") {
+          checkDefaultFixedConflict(attr, issues);
+        }
+      }
+    }
+    return issues;
+  }
+
+  // src/diagnostics/schemaImportDiagnostics.js
+  function runImportDiagnostics(schema, options = {}) {
+    const issues = [];
+    const externalDocuments = options.externalDocuments || {};
+    for (const ref of schema.externalRefs.includes || []) {
+      if (!ref.schemaLocation) continue;
+      if (externalDocuments[ref.schemaLocation]) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_INCLUDE_NOT_PROVIDED,
+          severity: "warning",
+          message: `Included schema '${ref.schemaLocation}' was referenced but not provided to the engine.`,
+          source: "xsd",
+          nodeKind: "include",
+          name: ref.schemaLocation,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          details: {
+            schemaLocation: ref.schemaLocation
+          }
+        })
+      );
+    }
+    for (const ref of schema.externalRefs.imports || []) {
+      if (!ref.schemaLocation) continue;
+      if (externalDocuments[ref.schemaLocation]) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_IMPORT_NOT_PROVIDED,
+          severity: "warning",
+          message: `Imported schema '${ref.schemaLocation}' was referenced but not provided to the engine.`,
+          source: "xsd",
+          nodeKind: "import",
+          name: ref.schemaLocation,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          details: {
+            schemaLocation: ref.schemaLocation,
+            namespace: ref.namespace
+          }
+        })
+      );
+    }
+    return issues;
+  }
+
+  // src/diagnostics/schemaDiagnostics.js
+  function buildStats(schema) {
+    return {
+      globalElementCount: Object.keys(schema.globals.elements).length,
+      globalComplexTypeCount: Object.keys(schema.globals.complexTypes).length,
+      globalSimpleTypeCount: Object.keys(schema.globals.simpleTypes).length,
+      globalAttributeCount: Object.keys(schema.globals.attributes).length,
+      globalGroupCount: Object.keys(schema.globals.groups).length,
+      globalAttributeGroupCount: Object.keys(schema.globals.attributeGroups).length
+    };
+  }
+  function sortUniqueStrings(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+  }
+  function getSupportedFeatures(schema) {
+    return sortUniqueStrings(
+      [...schema.usedFeatures].filter(
+        (name) => [
+          "all",
+          "attribute",
+          "attributeGroup",
+          "choice",
+          "complexContent",
+          "complexType",
+          "element",
+          "extension",
+          "group",
+          "restriction",
+          "schema",
+          "sequence",
+          "simpleContent",
+          "simpleType"
+        ].includes(name)
+      ).map((name) => `xs:${name}`)
+    );
+  }
+  function getUnsupportedFeatures(schema) {
+    return sortUniqueStrings(schema.unsupportedFeatures.map((item) => item.feature));
+  }
+  function checkUnknownTypes(schema, issues) {
+    for (const ref of schema.references.types) {
+      if (!ref.typeName) continue;
+      if (isBuiltinType(ref.typeName)) continue;
+      if (resolveType(schema, ref.typeName)) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.UNKNOWN_TYPE,
+          severity: "error",
+          message: `Type '${ref.typeName}' could not be resolved.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.nodeKind,
+          name: ref.name,
+          details: { typeName: ref.typeName }
+        })
+      );
+    }
+  }
+  function checkUnknownRefs(schema, issues) {
+    for (const ref of schema.references.refs) {
+      const targetName = ref.refName;
+      if (!targetName) continue;
+      const resolved = ref.nodeKind === "attribute" ? resolveGlobalAttribute(schema, targetName) : resolveGlobalElement(schema, targetName);
+      if (resolved) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.UNKNOWN_REF,
+          severity: "error",
+          message: `${ref.nodeKind === "attribute" ? "Attribute" : "Element"} reference '${targetName}' could not be resolved.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.nodeKind,
+          name: ref.name,
+          details: { refName: targetName }
+        })
+      );
+    }
+  }
+  function checkMissingBaseTypes(schema, issues) {
+    for (const ref of schema.references.baseTypes) {
+      const targetName = ref.baseTypeName;
+      if (!targetName) continue;
+      if (isBuiltinType(targetName)) continue;
+      if (resolveType(schema, targetName)) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.MISSING_BASE_TYPE,
+          severity: "error",
+          message: `Base type '${targetName}' could not be resolved.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.nodeKind,
+          name: ref.name,
+          details: { baseTypeName: targetName }
+        })
+      );
+    }
+  }
+  function checkUnknownGroups(schema, issues) {
+    for (const ref of schema.references.groupRefs) {
+      if (resolveGroup(schema, ref.refName)) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.UNKNOWN_GROUP,
+          severity: "error",
+          message: `Group reference '${ref.refName}' could not be resolved.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.nodeKind,
+          name: ref.name,
+          details: { refName: ref.refName }
+        })
+      );
+    }
+  }
+  function checkUnknownAttributeGroups(schema, issues) {
+    for (const ref of schema.references.attributeGroupRefs) {
+      if (resolveAttributeGroup(schema, ref.refName)) continue;
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.UNKNOWN_ATTRIBUTE_GROUP,
+          severity: "error",
+          message: `Attribute group reference '${ref.refName}' could not be resolved.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.nodeKind,
+          name: ref.name,
+          details: { refName: ref.refName }
+        })
+      );
+    }
+  }
+  function emitUnsupportedFeatureWarnings(schema, issues, options) {
+    if (options.includeWarnings === false) return;
+    for (const feature of schema.unsupportedFeatures) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.UNSUPPORTED_FEATURE,
+          severity: "warning",
+          message: `Feature '${feature.feature}' is recognized but not yet supported.`,
+          line: feature.line,
+          column: feature.column,
+          path: feature.path,
+          source: "engine",
+          nodeKind: feature.nodeKind,
+          name: feature.name,
+          details: { feature: feature.feature }
+        })
+      );
+    }
+  }
+  function runSchemaDiagnostics(schema, options = {}) {
+    const issues = [];
+    checkUnknownTypes(schema, issues);
+    checkUnknownRefs(schema, issues);
+    checkMissingBaseTypes(schema, issues);
+    checkUnknownGroups(schema, issues);
+    checkUnknownAttributeGroups(schema, issues);
+    emitUnsupportedFeatureWarnings(schema, issues, options);
+    const facetIssues = runFacetDiagnostics(schema, options);
+    issues.push(...facetIssues);
+    const restrictionIssues = runRestrictionDiagnostics(schema);
+    issues.push(...restrictionIssues);
+    const defaultFixedIssues = runDefaultFixedDiagnostics(schema);
+    issues.push(...defaultFixedIssues);
+    const importIssues = runImportDiagnostics(schema, options);
+    issues.push(...importIssues);
+    return {
+      data: {
+        roots: options.includeRoots === false ? [] : schema.roots,
+        supportedFeatures: options.includeFeatureSummary === false ? [] : getSupportedFeatures(schema),
+        unsupportedFeatures: options.includeFeatureSummary === false ? [] : getUnsupportedFeatures(schema),
+        schemaStats: buildStats(schema)
+      },
+      issues
+    };
+  }
+
+  // src/utils/result.js
+  function summarizeIssues(issues = []) {
+    return issues.reduce(
+      (acc, issue) => {
+        if (issue.severity === "error") acc.errorCount += 1;
+        else if (issue.severity === "warning") acc.warningCount += 1;
+        else if (issue.severity === "info") acc.infoCount += 1;
+        return acc;
+      },
+      { errorCount: 0, warningCount: 0, infoCount: 0 }
+    );
+  }
+  function hasErrors(issues = []) {
+    return issues.some((issue) => issue.severity === "error");
+  }
+  function makeResult({ data = null, issues = [] } = {}) {
+    return {
+      ok: !hasErrors(issues),
+      data,
+      issues,
+      summary: summarizeIssues(issues)
+    };
+  }
+
+  // src/api/getSchemaDiagnostics.js
+  function getSchemaDiagnostics({ xsdText, options = {} } = {}) {
+    const parseResult = parseXsd(xsdText);
+    if (!parseResult.ok || !parseResult.doc) {
+      return makeResult({
+        data: null,
+        issues: parseResult.issues
+      });
+    }
+    const modelResult = buildSchemaModel(parseResult.doc, {
+      ...options,
+      xsdText
+    });
+    const baseIssues = [
+      ...parseResult.issues || [],
+      ...modelResult.issues || []
+    ];
+    if (!modelResult.schema) {
+      return makeResult({
+        data: null,
+        issues: baseIssues
+      });
+    }
+    const diagnostics = runSchemaDiagnostics(modelResult.schema, options);
+    return makeResult({
+      data: diagnostics.data,
+      issues: [...baseIssues, ...diagnostics.issues || []]
+    });
+  }
+
+  // src/tree/treeNodeBuilders.js
+  function createTreeNode({
+    kind,
+    name = null,
+    label = null,
+    typeName = null,
+    refName = null,
+    baseTypeName = null,
+    derivation = null,
+    minOccurs = 1,
+    maxOccurs = 1,
+    use = null,
+    line = null,
+    column = null,
+    path = null,
+    children = []
+  } = {}) {
+    return {
+      kind,
+      name,
+      label: label ?? name ?? kind,
+      typeName,
+      refName,
+      baseTypeName,
+      derivation,
+      minOccurs,
+      maxOccurs,
+      use,
+      line,
+      column,
+      path,
+      children
+    };
+  }
+
+  // src/tree/extractTree.js
+  function asArray2(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  function makeVisitedKey(prefix, nameOrPath) {
+    return `${prefix}:${nameOrPath || "anonymous"}`;
+  }
+  function buildElementLabel(elementDecl) {
+    if (elementDecl.refName) return elementDecl.refName;
+    if (elementDecl.name) return elementDecl.name;
+    return "element";
+  }
+  function buildAttributeLabel(attributeDecl) {
+    if (attributeDecl.refName) return `@${attributeDecl.refName}`;
+    if (attributeDecl.name) return `@${attributeDecl.name}`;
+    return "@attribute";
+  }
+  function buildSimpleTypeChildren(schema, simpleTypeDecl) {
+    if (!simpleTypeDecl) return [];
+    const children = [];
+    if (simpleTypeDecl.baseTypeName) {
+      children.push(
+        createTreeNode({
+          kind: "baseType",
+          label: `base: ${simpleTypeDecl.baseTypeName}`,
+          baseTypeName: simpleTypeDecl.baseTypeName,
+          line: simpleTypeDecl.line,
+          column: simpleTypeDecl.column,
+          path: simpleTypeDecl.path,
+          children: []
+        })
+      );
+    }
+    const enumerations = asArray2(simpleTypeDecl.enumerations);
+    if (enumerations.length) {
+      children.push(
+        createTreeNode({
+          kind: "enumerations",
+          label: "enumerations",
+          line: simpleTypeDecl.line,
+          column: simpleTypeDecl.column,
+          path: simpleTypeDecl.path ? `${simpleTypeDecl.path}/enumerations` : null,
+          children: enumerations.map(
+            (value, index) => createTreeNode({
+              kind: "enumeration",
+              label: String(value),
+              line: simpleTypeDecl.line,
+              column: simpleTypeDecl.column,
+              path: simpleTypeDecl.path ? `${simpleTypeDecl.path}/enumeration[${index + 1}]` : null,
+              children: []
+            })
+          )
+        })
+      );
+    }
+    return children;
+  }
+  function buildAttributeNode(schema, attributeDecl, state) {
+    const node = createTreeNode({
+      kind: "attribute",
+      name: attributeDecl.name,
+      label: buildAttributeLabel(attributeDecl),
+      typeName: attributeDecl.typeName,
+      refName: attributeDecl.refName,
+      use: attributeDecl.use,
+      line: attributeDecl.line,
+      column: attributeDecl.column,
+      path: attributeDecl.path,
+      children: []
+    });
+    if (attributeDecl.inlineType?.kind === "simpleType") {
+      node.children.push(
+        createTreeNode({
+          kind: "simpleType",
+          name: attributeDecl.inlineType.name,
+          label: attributeDecl.inlineType.name || "simpleType",
+          baseTypeName: attributeDecl.inlineType.baseTypeName,
+          line: attributeDecl.inlineType.line,
+          column: attributeDecl.inlineType.column,
+          path: attributeDecl.inlineType.path,
+          children: buildSimpleTypeChildren(schema, attributeDecl.inlineType)
+        })
+      );
+    }
+    return node;
+  }
+  function buildAttributesNodes(schema, attributes, state) {
+    const nodes = [];
+    for (const attr of asArray2(attributes)) {
+      if (!attr) continue;
+      if (attr.kind === "attribute") {
+        nodes.push(buildAttributeNode(schema, attr, state));
+      } else if (attr.kind === "attributeGroupRef") {
+        const target = state.expandRefs ? state.resolveAttributeGroup?.(attr.refName) : null;
+        const refNode = createTreeNode({
+          kind: "attributeGroupRef",
+          refName: attr.refName,
+          label: `attributeGroup: ${attr.refName}`,
+          line: attr.line,
+          column: attr.column,
+          path: attr.path,
+          children: []
+        });
+        if (target) {
+          refNode.children.push(
+            createTreeNode({
+              kind: "attributeGroup",
+              name: target.name,
+              label: target.name || "attributeGroup",
+              line: target.line,
+              column: target.column,
+              path: target.path,
+              children: buildAttributesNodes(schema, target.attributes || [], state)
+            })
+          );
+        }
+        nodes.push(refNode);
+      }
+    }
+    return nodes;
+  }
+  function buildGroupRefNode(schema, groupRefNode, state) {
+    const node = createTreeNode({
+      kind: "groupRef",
+      refName: groupRefNode.refName,
+      label: `group: ${groupRefNode.refName}`,
+      minOccurs: groupRefNode.minOccurs,
+      maxOccurs: groupRefNode.maxOccurs,
+      line: groupRefNode.line,
+      column: groupRefNode.column,
+      path: groupRefNode.path,
+      children: []
+    });
+    if (!state.expandRefs) return node;
+    const target = resolveGroup(schema, groupRefNode.refName);
+    if (!target) return node;
+    const visitedKey = makeVisitedKey("group", target.name || target.path);
+    if (state.visited.has(visitedKey)) return node;
+    state.visited.add(visitedKey);
+    node.children.push(
+      createTreeNode({
+        kind: "group",
+        name: target.name,
+        label: target.name || "group",
+        line: target.line,
+        column: target.column,
+        path: target.path,
+        children: target.content ? [buildContentNode(schema, target.content, state)] : []
+      })
+    );
+    state.visited.delete(visitedKey);
+    return node;
+  }
+  function buildContentNode(schema, contentNode, state) {
+    if (!contentNode) return null;
+    switch (contentNode.kind) {
+      case "sequence":
+      case "choice":
+      case "all":
+        return createTreeNode({
+          kind: contentNode.kind,
+          label: contentNode.kind,
+          minOccurs: contentNode.minOccurs,
+          maxOccurs: contentNode.maxOccurs,
+          line: contentNode.line,
+          column: contentNode.column,
+          path: contentNode.path,
+          children: asArray2(contentNode.children).map((child) => buildContentNode(schema, child, state)).filter(Boolean)
+        });
+      case "element":
+        return buildElementNode(schema, contentNode, state);
+      case "groupRef":
+        return buildGroupRefNode(schema, contentNode, state);
+      case "any":
+        return createTreeNode({
+          kind: "any",
+          label: "any",
+          minOccurs: contentNode.minOccurs,
+          maxOccurs: contentNode.maxOccurs,
+          line: contentNode.line,
+          column: contentNode.column,
+          path: contentNode.path,
+          children: []
+        });
+      default:
+        return createTreeNode({
+          kind: contentNode.kind || "unknown",
+          label: contentNode.kind || "unknown",
+          line: contentNode.line,
+          column: contentNode.column,
+          path: contentNode.path,
+          children: []
+        });
+    }
+  }
+  function buildComplexTypeNode(schema, complexTypeDecl, state) {
+    const content = getEffectiveContent(schema, complexTypeDecl);
+    const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+    const children = [];
+    if (complexTypeDecl.derivation?.kind || complexTypeDecl.derivation?.baseTypeName) {
+      children.push(
+        createTreeNode({
+          kind: "derivation",
+          label: complexTypeDecl.derivation.kind || "derivation",
+          baseTypeName: complexTypeDecl.derivation.baseTypeName,
+          derivation: complexTypeDecl.derivation.kind,
+          line: complexTypeDecl.line,
+          column: complexTypeDecl.column,
+          path: complexTypeDecl.path ? `${complexTypeDecl.path}/derivation` : null,
+          children: []
+        })
+      );
+    }
+    if (content) {
+      const contentTree = buildContentNode(schema, content, state);
+      if (contentTree) children.push(contentTree);
+    }
+    const attributeNodes = buildAttributesNodes(schema, attributes, state);
+    children.push(...attributeNodes);
+    return createTreeNode({
+      kind: "complexType",
+      name: complexTypeDecl.name,
+      label: complexTypeDecl.name || "complexType",
+      baseTypeName: complexTypeDecl.derivation?.baseTypeName || null,
+      derivation: complexTypeDecl.derivation?.kind || null,
+      line: complexTypeDecl.line,
+      column: complexTypeDecl.column,
+      path: complexTypeDecl.path,
+      children
+    });
+  }
+  function buildSimpleTypeNode(schema, simpleTypeDecl) {
+    return createTreeNode({
+      kind: "simpleType",
+      name: simpleTypeDecl.name,
+      label: simpleTypeDecl.name || "simpleType",
+      baseTypeName: simpleTypeDecl.baseTypeName,
+      line: simpleTypeDecl.line,
+      column: simpleTypeDecl.column,
+      path: simpleTypeDecl.path,
+      children: buildSimpleTypeChildren(schema, simpleTypeDecl)
+    });
+  }
+  function buildReferencedGlobalElementNode(schema, refName, state) {
+    const target = resolveGlobalElement(schema, refName);
+    if (!target) return null;
+    const visitedKey = makeVisitedKey("element", target.name || target.path);
+    if (state.visited.has(visitedKey)) {
+      return createTreeNode({
+        kind: "elementRefTarget",
+        name: target.name,
+        label: target.name || refName,
+        typeName: target.typeName,
+        line: target.line,
+        column: target.column,
+        path: target.path,
+        children: []
+      });
+    }
+    state.visited.add(visitedKey);
+    const node = buildElementNode(schema, target, state);
+    state.visited.delete(visitedKey);
+    return node;
+  }
+  function buildElementNode(schema, elementDecl, state) {
+    const node = createTreeNode({
+      kind: "element",
+      name: elementDecl.name,
+      label: buildElementLabel(elementDecl),
+      typeName: elementDecl.typeName,
+      refName: elementDecl.refName,
+      minOccurs: elementDecl.minOccurs,
+      maxOccurs: elementDecl.maxOccurs,
+      line: elementDecl.line,
+      column: elementDecl.column,
+      path: elementDecl.path,
+      children: []
+    });
+    if (elementDecl.refName && state.expandRefs) {
+      const targetNode = buildReferencedGlobalElementNode(schema, elementDecl.refName, state);
+      if (targetNode) {
+        node.children.push(targetNode);
+        return node;
+      }
+    }
+    const resolvedType = resolveElementType(schema, elementDecl);
+    if (!resolvedType) {
+      return node;
+    }
+    if (resolvedType.kind === "builtinType") {
+      node.children.push(
+        createTreeNode({
+          kind: "builtinType",
+          label: resolvedType.name,
+          typeName: resolvedType.name,
+          line: elementDecl.line,
+          column: elementDecl.column,
+          path: elementDecl.path ? `${elementDecl.path}/builtinType` : null,
+          children: []
+        })
+      );
+      return node;
+    }
+    if (resolvedType.kind === "simpleType") {
+      node.children.push(buildSimpleTypeNode(schema, resolvedType));
+      return node;
+    }
+    if (resolvedType.kind === "complexType") {
+      const typeKey = makeVisitedKey("complexType", resolvedType.name || resolvedType.path);
+      if (state.visited.has(typeKey)) {
+        node.children.push(
+          createTreeNode({
+            kind: "complexType",
+            name: resolvedType.name,
+            label: resolvedType.name || "complexType",
+            line: resolvedType.line,
+            column: resolvedType.column,
+            path: resolvedType.path,
+            children: []
+          })
+        );
+        return node;
+      }
+      state.visited.add(typeKey);
+      node.children.push(buildComplexTypeNode(schema, resolvedType, state));
+      state.visited.delete(typeKey);
+      return node;
+    }
+    return node;
+  }
+  function selectRoots(schema, options = {}) {
+    if (options.rootElementName) {
+      const root = resolveGlobalElement(schema, options.rootElementName);
+      return root ? [root] : [];
+    }
+    return Object.values(schema.globals.elements || {});
+  }
+  function extractTreeFromSchema(schema, options = {}, helpers = {}) {
+    const roots = selectRoots(schema, options);
+    const state = {
+      expandRefs: options.expandRefs !== false,
+      visited: /* @__PURE__ */ new Set(),
+      resolveAttributeGroup: helpers.resolveAttributeGroup
+    };
+    const tree = roots.map((root) => buildElementNode(schema, root, state));
+    return {
+      roots: schema.roots,
+      tree
+    };
+  }
+
+  // src/api/extractSchemaTree.js
+  function extractSchemaTree({ xsdText, options = {} } = {}) {
+    const parseResult = parseXsd(xsdText);
+    if (!parseResult.ok || !parseResult.doc) {
+      return makeResult({
+        data: null,
+        issues: parseResult.issues
+      });
+    }
+    const modelResult = buildSchemaModel(parseResult.doc, {
+      ...options,
+      xsdText
+    });
+    const baseIssues = [
+      ...parseResult.issues || [],
+      ...modelResult.issues || []
+    ];
+    if (!modelResult.schema) {
+      return makeResult({
+        data: null,
+        issues: baseIssues
+      });
+    }
+    const diagnostics = runSchemaDiagnostics(modelResult.schema, {
+      ...options,
+      includeWarnings: true,
+      includeFeatureSummary: false,
+      includeRoots: true
+    });
+    const data = extractTreeFromSchema(modelResult.schema, options, {
+      resolveAttributeGroup: (name) => resolveAttributeGroup(modelResult.schema, name)
+    });
+    return makeResult({
+      data,
+      issues: [...baseIssues, ...diagnostics.issues || []]
+    });
+  }
+
+  // src/generator/sampleValueFactory.js
+  function firstEnumeration(simpleTypeDecl) {
+    const enums = simpleTypeDecl?.enumerations || [];
+    return enums.length ? String(enums[0]) : null;
+  }
+  function padToLength(text, targetLength) {
+    if (text.length >= targetLength) return text.slice(0, targetLength);
+    return text.padEnd(targetLength, "x");
+  }
+  function applyLengthFacet(baseValue, facets = {}) {
+    let value = String(baseValue);
+    if (typeof facets.length === "number") {
+      return padToLength(value, facets.length);
+    }
+    if (typeof facets.minLength === "number" && value.length < facets.minLength) {
+      value = padToLength(value, facets.minLength);
+    }
+    if (typeof facets.maxLength === "number" && value.length > facets.maxLength) {
+      value = value.slice(0, facets.maxLength);
+    }
+    return value;
+  }
+  function numericWithinFacets(defaultValue, facets = {}, isInteger = false) {
+    if (facets.minInclusive != null) return String(facets.minInclusive);
+    if (facets.minExclusive != null) {
+      const n = Number(facets.minExclusive);
+      if (Number.isFinite(n)) return String(isInteger ? Math.floor(n + 1) : n + 0.1);
+    }
+    if (facets.maxInclusive != null) return String(facets.maxInclusive);
+    if (facets.maxExclusive != null) {
+      const n = Number(facets.maxExclusive);
+      if (Number.isFinite(n)) return String(isInteger ? Math.ceil(n - 1) : n - 0.1);
+    }
+    return defaultValue;
+  }
+  function applyDigitFacets(value, facets = {}) {
+    let text = String(value);
+    if (typeof facets.fractionDigits === "number") {
+      const num = Number(text);
+      if (Number.isFinite(num)) {
+        text = num.toFixed(facets.fractionDigits);
+      }
+    }
+    if (typeof facets.totalDigits === "number") {
+      const stripped = text.replace(/^[-+]/, "").replace(".", "");
+      if (stripped.length > facets.totalDigits) {
+        const replacement = "1".repeat(facets.totalDigits);
+        text = typeof facets.fractionDigits === "number" && facets.fractionDigits > 0 ? `${replacement.slice(0, Math.max(1, facets.totalDigits - facets.fractionDigits))}.${replacement.slice(Math.max(1, facets.totalDigits - facets.fractionDigits))}` : replacement;
+      }
+    }
+    return text;
+  }
+  function patternSample(patterns = [], fallback = "example") {
+    const pattern = patterns[0];
+    if (!pattern) return fallback;
+    if (pattern === "[A-Z]+") return "ABC";
+    if (pattern === "[0-9]+") return "123";
+    if (pattern === "[A-Z0-9]+") return "ABC123";
+    if (pattern === "[a-z]+") return "abc";
+    return fallback;
+  }
+  function builtinSample(localTypeName) {
+    switch (localTypeName) {
+      case "string":
+      case "normalizedString":
+      case "token":
+      case "language":
+      case "Name":
+      case "NCName":
+      case "ID":
+      case "IDREF":
+      case "NMTOKEN":
+      case "anyURI":
+      case "QName":
+        return "example";
+      case "boolean":
+        return "true";
+      case "decimal":
+      case "float":
+      case "double":
+        return "0.0";
+      case "integer":
+      case "nonPositiveInteger":
+      case "negativeInteger":
+      case "long":
+      case "int":
+      case "short":
+      case "byte":
+      case "nonNegativeInteger":
+      case "unsignedLong":
+      case "unsignedInt":
+      case "unsignedShort":
+      case "unsignedByte":
+      case "positiveInteger":
+        return "0";
+      case "date":
+        return "2026-01-01";
+      case "time":
+        return "00:00:00";
+      case "dateTime":
+        return "2026-01-01T00:00:00Z";
+      case "duration":
+        return "P1D";
+      case "gYear":
+        return "2026";
+      case "gYearMonth":
+        return "2026-01";
+      case "gMonth":
+        return "--01";
+      case "gMonthDay":
+        return "--01-01";
+      case "gDay":
+        return "---01";
+      case "hexBinary":
+        return "0A";
+      case "base64Binary":
+        return "ZXhhbXBsZQ==";
+      default:
+        return "example";
+    }
+  }
+  function createSampleValueForType(schema, resolvedType) {
+    if (!resolvedType) return "example";
+    if (resolvedType.kind === "builtinType") {
+      return builtinSample(stripNamespacePrefix(resolvedType.name));
+    }
+    if (resolvedType.kind === "simpleType") {
+      const effective = getEffectiveSimpleType(schema, resolvedType);
+      const enumValue = firstEnumeration(effective);
+      if (enumValue != null) return enumValue;
+      const baseType = effective?.baseTypeName;
+      const facets = effective?.facets || {};
+      if (baseType && isBuiltinType(baseType)) {
+        const local = stripNamespacePrefix(baseType);
+        if (facets.pattern?.length) {
+          return applyLengthFacet(patternSample(facets.pattern, builtinSample(local)), facets);
+        }
+        let value = builtinSample(local);
+        if ([
+          "integer",
+          "nonPositiveInteger",
+          "negativeInteger",
+          "long",
+          "int",
+          "short",
+          "byte",
+          "nonNegativeInteger",
+          "unsignedLong",
+          "unsignedInt",
+          "unsignedShort",
+          "unsignedByte",
+          "positiveInteger"
+        ].includes(local)) {
+          value = numericWithinFacets(value, facets, true);
+          value = applyDigitFacets(value, facets);
+          return value;
+        }
+        if (["decimal", "float", "double"].includes(local)) {
+          value = numericWithinFacets(value, facets, false);
+          value = applyDigitFacets(value, facets);
+          return value;
+        }
+        return applyLengthFacet(value, facets);
+      }
+      if (facets.pattern?.length) {
+        return applyLengthFacet(patternSample(facets.pattern, "example"), facets);
+      }
+      return applyLengthFacet("example", facets);
+    }
+    return "example";
+  }
+
+  // src/generator/generateXml.js
+  function asArray3(value) {
+    return Array.isArray(value) ? value : [];
+  }
+  function repeatCount(minOccurs, maxOccurs, mode) {
+    if (mode === "minimal") {
+      return typeof minOccurs === "number" ? minOccurs : 1;
+    }
+    if (mode === "full") {
+      if (typeof maxOccurs === "number") {
+        return Math.max(typeof minOccurs === "number" ? minOccurs : 1, Math.min(maxOccurs, 2));
+      }
+      return Math.max(typeof minOccurs === "number" ? minOccurs : 1, 1);
+    }
+    return 1;
+  }
+  function pickChoiceChildren(children, mode) {
+    if (!children.length) return [];
+    if (mode === "minimal") return [children[0]];
+    return [children[0]];
+  }
+  function mergeAttributes(target, source) {
+    Object.assign(target, source);
+  }
+  function shouldQualifyElement(schema, elementDecl, isRoot = false) {
+    if (isRoot) return !!elementDecl.namespaceUri;
+    return schema.elementFormDefault === "qualified" && !!elementDecl.namespaceUri;
+  }
+  function qualifiedElementName(schema, elementDecl, state, isRoot = false) {
+    const localName3 = elementDecl.name || elementDecl.refName || "element";
+    if (!shouldQualifyElement(schema, elementDecl, isRoot)) {
+      return localName3.includes(":") ? localName3.split(":")[1] : localName3;
+    }
+    const prefix = state.targetPrefix || "tns";
+    const bare = localName3.includes(":") ? localName3.split(":")[1] : localName3;
+    return `${prefix}:${bare}`;
+  }
+  function buildRootNamespaceAttributes(schema, rootDecl, state) {
+    const attrs = {};
+    if (rootDecl.namespaceUri) {
+      attrs[`xmlns:${state.targetPrefix}`] = rootDecl.namespaceUri;
+    }
+    return attrs;
+  }
+  function buildAttributesObject(schema, attributes, options, state) {
+    const out = {};
+    for (const attr of asArray3(attributes)) {
+      if (!attr) continue;
+      if (attr.kind === "attribute") {
+        if (attr.use !== "required" && !options.includeOptionalAttributes) continue;
+        const attrName = attr.name || attr.refName || "attr";
+        const resolvedType = resolveAttributeType(schema, attr);
+        out[attrName] = attr.fixedValue ?? attr.defaultValue ?? createSampleValueForType(schema, resolvedType);
+      } else if (attr.kind === "attributeGroupRef") {
+        const group = state.resolveAttributeGroup?.(attr.refName);
+        if (!group) continue;
+        mergeAttributes(
+          out,
+          buildAttributesObject(schema, group.attributes || [], options, state)
+        );
+      }
+    }
+    return out;
+  }
+  function buildNodesFromContent(schema, contentNode, options, state) {
+    if (!contentNode) return [];
+    switch (contentNode.kind) {
+      case "sequence":
+      case "all": {
+        const result = [];
+        for (const child of asArray3(contentNode.children)) {
+          result.push(...buildNodesFromContent(schema, child, options, state));
+        }
+        return result;
+      }
+      case "choice": {
+        const selected = pickChoiceChildren(asArray3(contentNode.children), options.mode);
+        const result = [];
+        for (const child of selected) {
+          result.push(...buildNodesFromContent(schema, child, options, state));
+        }
+        return result;
+      }
+      case "groupRef": {
+        const group = resolveGroup(schema, contentNode.refName);
+        if (!group?.content) return [];
+        return buildNodesFromContent(schema, group.content, options, state);
+      }
+      case "element":
+        return buildElementInstances(schema, contentNode, options, state, false);
+      case "any":
+        return options.mode === "full" ? [{ name: "anyElement", attributes: {}, children: [], text: "example" }] : [];
+      default:
+        return [];
+    }
+  }
+  function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
+    const content = getEffectiveContent(schema, complexTypeDecl);
+    const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: content ? buildNodesFromContent(schema, content, options, state) : []
+    };
+  }
+  function buildSimpleTypeText(schema, simpleTypeDecl) {
+    return createSampleValueForType(schema, simpleTypeDecl);
+  }
+  function buildElementNode2(schema, elementDecl, options, state, isRoot = false) {
+    const resolvedType = resolveElementType(schema, elementDecl);
+    const node = {
+      name: qualifiedElementName(schema, elementDecl, state, isRoot),
+      attributes: isRoot ? buildRootNamespaceAttributes(schema, elementDecl, state) : {},
+      children: [],
+      text: null
+    };
+    if (resolvedType?.kind === "builtinType" || resolvedType?.kind === "simpleType") {
+      node.text = elementDecl.fixedValue ?? elementDecl.defaultValue ?? createSampleValueForType(schema, resolvedType);
+      return node;
+    }
+    if (resolvedType?.kind === "complexType") {
+      const built = buildComplexTypeContent(schema, resolvedType, options, state);
+      node.attributes = {
+        ...node.attributes,
+        ...built.attributes
+      };
+      node.children = built.children;
+      return node;
+    }
+    if (elementDecl.inlineType?.kind === "simpleType") {
+      node.text = elementDecl.fixedValue ?? elementDecl.defaultValue ?? buildSimpleTypeText(schema, elementDecl.inlineType);
+      return node;
+    }
+    node.text = elementDecl.fixedValue ?? elementDecl.defaultValue ?? "example";
+    return node;
+  }
+  function buildElementInstances(schema, elementDecl, options, state, isRoot = false) {
+    if (elementDecl.refName) {
+      const target = resolveGlobalElement(schema, elementDecl.refName);
+      if (target) {
+        const mergedDecl = {
+          ...target,
+          minOccurs: elementDecl.minOccurs,
+          maxOccurs: elementDecl.maxOccurs
+        };
+        return buildElementInstances(schema, mergedDecl, options, state, isRoot);
+      }
+    }
+    const count = repeatCount(elementDecl.minOccurs, elementDecl.maxOccurs, options.mode);
+    const result = [];
+    for (let i = 0; i < count; i += 1) {
+      result.push(buildElementNode2(schema, elementDecl, options, state, isRoot && i === 0));
+    }
+    return result;
+  }
+  function selectRoot(schema, options = {}) {
+    if (options.rootElementName) {
+      return resolveGlobalElement(schema, options.rootElementName);
+    }
+    return Object.values(schema.globals.elements || {})[0] || null;
+  }
+  function generateXmlFromSchema(schema, options = {}, helpers = {}) {
+    const normalizedOptions = {
+      mode: options.mode === "full" ? "full" : "minimal",
+      includeOptionalAttributes: options.includeOptionalAttributes === true
+    };
+    const root = selectRoot(schema, options);
+    if (!root) {
+      return {
+        rootElementName: null,
+        rootNode: null
+      };
+    }
+    const state = {
+      resolveAttributeGroup: helpers.resolveAttributeGroup,
+      targetPrefix: options.targetPrefix || "tns"
+    };
+    const [rootNode] = buildElementInstances(schema, root, normalizedOptions, state, true);
+    return {
+      rootElementName: root.name,
+      rootNode
+    };
+  }
+
+  // src/generator/xmlWriter.js
+  function escapeXml(value) {
+    return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+  }
+  function writeAttributes(attributes = {}) {
+    const entries = Object.entries(attributes).filter(([, value]) => value != null);
+    if (!entries.length) return "";
+    return entries.map(([key, value]) => ` ${key}="${escapeXml(value)}"`).join("");
+  }
+  function indent(level) {
+    return "  ".repeat(level);
+  }
+  function writeNode(node, level = 0) {
+    const attrs = writeAttributes(node.attributes);
+    if (!node.children?.length && (node.text == null || node.text === "")) {
+      return `${indent(level)}<${node.name}${attrs}/>`;
+    }
+    if (!node.children?.length) {
+      return `${indent(level)}<${node.name}${attrs}>${escapeXml(node.text)}</${node.name}>`;
+    }
+    const childXml = node.children.map((child) => writeNode(child, level + 1)).join("\n");
+    return `${indent(level)}<${node.name}${attrs}>
+${childXml}
+${indent(level)}</${node.name}>`;
+  }
+  function writeXmlDocument(rootNode) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+${writeNode(rootNode, 0)}`;
+  }
+
+  // src/api/generateSampleXml.js
+  function generateSampleXml({ xsdText, options = {} } = {}) {
+    const parseResult = parseXsd(xsdText);
+    if (!parseResult.ok || !parseResult.doc) {
+      return makeResult({
+        data: null,
+        issues: parseResult.issues
+      });
+    }
+    const modelResult = buildSchemaModel(parseResult.doc, {
+      ...options,
+      xsdText
+    });
+    const baseIssues = [
+      ...parseResult.issues || [],
+      ...modelResult.issues || []
+    ];
+    if (!modelResult.schema) {
+      return makeResult({
+        data: null,
+        issues: baseIssues
+      });
+    }
+    const diagnostics = runSchemaDiagnostics(modelResult.schema, {
+      ...options,
+      includeWarnings: true,
+      includeFeatureSummary: false,
+      includeRoots: true
+    });
+    const generated = generateXmlFromSchema(modelResult.schema, options, {
+      resolveAttributeGroup: (name) => resolveAttributeGroup(modelResult.schema, name)
+    });
+    if (!generated.rootNode) {
+      return makeResult({
+        data: {
+          rootElementName: null,
+          xmlText: ""
+        },
+        issues: [...baseIssues, ...diagnostics.issues || []]
+      });
+    }
+    return makeResult({
+      data: {
+        rootElementName: generated.rootElementName,
+        xmlText: writeXmlDocument(generated.rootNode)
+      },
+      issues: [...baseIssues, ...diagnostics.issues || []]
+    });
+  }
+
+  // src/validation/structureValidator.js
+  function elementChildren2(xmlNode) {
+    return Array.from(xmlNode?.children || []).filter((child) => child.nodeType === 1);
+  }
+  function directTextNodes(xmlNode) {
+    return Array.from(xmlNode?.childNodes || []).filter((node) => node.nodeType === 3);
+  }
+  function textContentTrimmed(xmlNode) {
+    return (xmlNode?.textContent || "").trim();
+  }
+  function localName(node) {
+    return node?.localName || node?.nodeName || null;
+  }
+  function namespaceUri(node) {
+    return node?.namespaceURI || null;
+  }
+  function repeatMin(minOccurs) {
+    return typeof minOccurs === "number" ? minOccurs : 1;
+  }
+  function repeatMax(maxOccurs) {
+    return maxOccurs === "unbounded" ? Infinity : maxOccurs;
+  }
+  function matchesElementDecl(xmlNode, elementDecl) {
+    const xmlName = localName(xmlNode);
+    const xmlNs = namespaceUri(xmlNode);
+    const declName = elementDecl.refName || elementDecl.name;
+    const declLocal = declName?.includes(":") ? declName.split(":")[1] : declName;
+    const declNs = elementDecl.namespaceUri || null;
+    if (xmlName !== declLocal) return false;
+    if (declNs == null) return true;
+    return xmlNs === declNs;
+  }
+  function buildXmlPath(pathParts) {
+    return "/" + pathParts.join("/");
+  }
+  function validateAttributes(xmlNode, attributes, context) {
+    const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts, validateAttributeValue: validateAttributeValue2 } = context;
+    const allowed = /* @__PURE__ */ new Map();
+    for (const attr of attributes || []) {
+      if (!attr) continue;
+      if (attr.kind === "attribute") {
+        const attrName = attr.name || attr.refName;
+        if (attrName) {
+          allowed.set(attrName, attr);
+        }
+      } else if (attr.kind === "attributeGroupRef") {
+        const group = context.resolveAttributeGroup?.(attr.refName);
+        if (!group) continue;
+        validateAttributes(xmlNode, group.attributes || [], context);
+      }
+    }
+    for (const attrDecl of allowed.values()) {
+      const attrName = attrDecl.name || attrDecl.refName;
+      const value = xmlNode.getAttribute(attrName);
+      if (attrDecl.use === "required" && value == null) {
+        issues.push(
+          createIssue2({
+            code: ISSUE_CODES2.XML_MISSING_REQUIRED_ATTRIBUTE,
+            severity: "error",
+            message: `Required attribute '${attrName}' is missing.`,
+            path: buildXmlPath(pathParts),
+            source: "xml",
+            nodeKind: "attribute",
+            name: attrName,
+            details: { attributeName: attrName }
+          })
+        );
+        continue;
+      }
+      if (value != null) {
+        const valueResult = validateAttributeValue2(schema, attrDecl, value);
+        if (!valueResult.ok) {
+          issues.push(
+            createIssue2({
+              code: ISSUE_CODES2[valueResult.code] || valueResult.code,
+              severity: "error",
+              message: valueResult.message,
+              path: buildXmlPath(pathParts),
+              source: "xml",
+              nodeKind: "attribute",
+              name: attrName,
+              details: { attributeName: attrName, value }
+            })
+          );
+        }
+      }
+    }
+    for (const attr of Array.from(xmlNode.attributes || [])) {
+      if (attr.name === "xmlns" || attr.name.startsWith("xmlns:") || attr.prefix === "xmlns") {
+        continue;
+      }
+      if (!allowed.has(attr.name)) {
+        issues.push(
+          createIssue2({
+            code: ISSUE_CODES2.XML_UNEXPECTED_ATTRIBUTE,
+            severity: "error",
+            message: `Unexpected attribute '${attr.name}'.`,
+            path: buildXmlPath(pathParts),
+            source: "xml",
+            nodeKind: "attribute",
+            name: attr.name,
+            details: { attributeName: attr.name }
+          })
+        );
+      }
+    }
+  }
+  function validateSimpleElement(xmlNode, elementDecl, context) {
+    const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts, validateElementValue: validateElementValue2 } = context;
+    const value = textContentTrimmed(xmlNode);
+    const valueResult = validateElementValue2(schema, elementDecl, value);
+    if (!valueResult.ok) {
+      issues.push(
+        createIssue2({
+          code: ISSUE_CODES2[valueResult.code] || valueResult.code,
+          severity: "error",
+          message: valueResult.message,
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "element",
+          name: elementDecl.name || elementDecl.refName,
+          details: { value }
+        })
+      );
+    }
+  }
+  function validateMixedContent(xmlNode, complexTypeDecl, context, pathParts) {
+    const { createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues } = context;
+    const hasDirectText = directTextNodes(xmlNode).some((node) => node.nodeValue?.trim());
+    if (!complexTypeDecl.mixed && hasDirectText) {
+      issues.push(
+        createIssue2({
+          code: ISSUE_CODES2.XML_MIXED_CONTENT_NOT_ALLOWED,
+          severity: "error",
+          message: "Mixed text content is not allowed for this complex type.",
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "element",
+          name: localName(xmlNode),
+          details: {}
+        })
+      );
+    }
+  }
+  function validateComplexElement(xmlNode, complexTypeDecl, context) {
+    const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts } = context;
+    const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+    validateAttributes(xmlNode, attributes, context);
+    validateMixedContent(xmlNode, complexTypeDecl, context, pathParts);
+    const text = textContentTrimmed(xmlNode);
+    const children = elementChildren2(xmlNode);
+    const content = getEffectiveContent(schema, complexTypeDecl);
+    if (!complexTypeDecl.mixed && children.length === 0 && text && content) {
+      issues.push(
+        createIssue2({
+          code: ISSUE_CODES2.XML_INVALID_TEXT_FOR_COMPLEX_TYPE,
+          severity: "error",
+          message: "Complex element contains text where structured child content is expected.",
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "element",
+          name: localName(xmlNode),
+          details: {}
+        })
+      );
+    }
+    if (content) {
+      const result = validateContentModel(children, content, context, pathParts);
+      if (result.nextIndex < children.length) {
+        for (let i = result.nextIndex; i < children.length; i += 1) {
+          issues.push(
+            createIssue2({
+              code: ISSUE_CODES2.XML_UNEXPECTED_ELEMENT,
+              severity: "error",
+              message: `Unexpected element '${localName(children[i])}'.`,
+              path: buildXmlPath([...pathParts, localName(children[i])]),
+              source: "xml",
+              nodeKind: "element",
+              name: localName(children[i]),
+              details: {}
+            })
+          );
+        }
+      }
+    }
+  }
+  function validateElementDecl(xmlNode, elementDecl, context, pathParts) {
+    const resolvedType = resolveElementType(context.schema, elementDecl);
+    if (!resolvedType) return;
+    const nextContext = {
+      ...context,
+      pathParts
+    };
+    if (resolvedType.kind === "builtinType" || resolvedType.kind === "simpleType") {
+      validateSimpleElement(xmlNode, elementDecl, nextContext);
+      return;
+    }
+    if (resolvedType.kind === "complexType") {
+      validateComplexElement(xmlNode, resolvedType, nextContext);
+    }
+  }
+  function consumeMatchingElement(children, startIndex, elementDecl, context, pathParts) {
+    const min = repeatMin(elementDecl.minOccurs);
+    const max = repeatMax(elementDecl.maxOccurs);
+    let count = 0;
+    let index = startIndex;
+    while (index < children.length && matchesElementDecl(children[index], elementDecl) && count < max) {
+      const childNode = children[index];
+      validateElementDecl(childNode, elementDecl, context, [...pathParts, localName(childNode)]);
+      count += 1;
+      index += 1;
+    }
+    if (count < min) {
+      context.issues.push(
+        context.createIssue({
+          code: context.ISSUE_CODES.XML_MISSING_REQUIRED_ELEMENT,
+          severity: "error",
+          message: `Required element '${elementDecl.name || elementDecl.refName}' is missing.`,
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "element",
+          name: elementDecl.name || elementDecl.refName,
+          details: {
+            minOccurs: elementDecl.minOccurs,
+            actualCount: count
+          }
+        })
+      );
+    }
+    return { nextIndex: index, matched: count >= min };
+  }
+  function validateGroupRef(children, startIndex, groupRefNode, context, pathParts) {
+    const group = resolveGroup(context.schema, groupRefNode.refName);
+    if (!group?.content) {
+      return { nextIndex: startIndex, matched: false };
+    }
+    const min = repeatMin(groupRefNode.minOccurs);
+    const max = repeatMax(groupRefNode.maxOccurs);
+    let count = 0;
+    let index = startIndex;
+    while (count < max) {
+      const result = validateContentModel(children, group.content, context, pathParts, index, true);
+      if (!result.matchedAny) break;
+      index = result.nextIndex;
+      count += 1;
+    }
+    if (count < min) {
+      context.issues.push(
+        context.createIssue({
+          code: context.ISSUE_CODES.XML_MISSING_REQUIRED_ELEMENT,
+          severity: "error",
+          message: `Required group '${groupRefNode.refName}' is missing.`,
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "groupRef",
+          name: groupRefNode.refName,
+          details: {}
+        })
+      );
+    }
+    return { nextIndex: index, matched: count >= min };
+  }
+  function validateChoice(children, startIndex, choiceNode, context, pathParts, silent = false) {
+    const min = repeatMin(choiceNode.minOccurs);
+    const max = repeatMax(choiceNode.maxOccurs);
+    let count = 0;
+    let index = startIndex;
+    while (count < max) {
+      let matchedBranches = [];
+      for (const childDecl of choiceNode.children || []) {
+        const snapshotIssuesLength = context.issues.length;
+        const result = validateContentModel(children, childDecl, context, pathParts, index, true);
+        if (result.matchedAny) {
+          context.issues.length = snapshotIssuesLength;
+          matchedBranches.push(result);
+        } else {
+          context.issues.length = snapshotIssuesLength;
+        }
+      }
+      if (matchedBranches.length === 0) break;
+      if (matchedBranches.length > 1 && !silent) {
+        context.issues.push(
+          context.createIssue({
+            code: context.ISSUE_CODES.XML_CHOICE_MULTIPLE_BRANCHES,
+            severity: "error",
+            message: "Multiple xs:choice branches appear to match at the same position.",
+            path: buildXmlPath(pathParts),
+            source: "xml",
+            nodeKind: "choice",
+            name: null,
+            details: {}
+          })
+        );
+      }
+      const matchedBranch = matchedBranches[0];
+      index = matchedBranch.nextIndex;
+      count += 1;
+    }
+    if (count < min && !silent) {
+      context.issues.push(
+        context.createIssue({
+          code: context.ISSUE_CODES.XML_CHOICE_NOT_SATISFIED,
+          severity: "error",
+          message: "No valid branch of xs:choice was satisfied.",
+          path: buildXmlPath(pathParts),
+          source: "xml",
+          nodeKind: "choice",
+          name: null,
+          details: {}
+        })
+      );
+    }
+    return { nextIndex: index, matched: count >= min, matchedAny: count > 0 };
+  }
+  function validateAll(children, startIndex, allNode, context, pathParts, silent = false) {
+    const members = allNode.children || [];
+    const matchedIndexes = /* @__PURE__ */ new Set();
+    let index = startIndex;
+    while (index < children.length) {
+      let matchedMemberIndex = -1;
+      for (let i = 0; i < members.length; i += 1) {
+        if (matchedIndexes.has(i)) continue;
+        const result = validateContentModel(children, members[i], context, pathParts, index, true);
+        if (result.matchedAny) {
+          matchedMemberIndex = i;
+          index = result.nextIndex;
+          break;
+        }
+      }
+      if (matchedMemberIndex < 0) break;
+      matchedIndexes.add(matchedMemberIndex);
+    }
+    if (!silent) {
+      for (let i = 0; i < members.length; i += 1) {
+        const member = members[i];
+        const min = repeatMin(member.minOccurs);
+        if (matchedIndexes.has(i) && maxOccursIsSingle(member)) {
+        }
+        if (!matchedIndexes.has(i) && min > 0) {
+          context.issues.push(
+            context.createIssue({
+              code: context.ISSUE_CODES.XML_ALL_MISSING_REQUIRED_ELEMENT,
+              severity: "error",
+              message: `Required xs:all child '${member.name || member.refName}' is missing.`,
+              path: buildXmlPath(pathParts),
+              source: "xml",
+              nodeKind: "all",
+              name: member.name || member.refName,
+              details: {}
+            })
+          );
+        }
+      }
+    }
+    return {
+      nextIndex: index,
+      matched: matchedIndexes.size > 0 || members.every((m) => repeatMin(m.minOccurs) === 0),
+      matchedAny: matchedIndexes.size > 0
+    };
+  }
+  function maxOccursIsSingle(member) {
+    return member.maxOccurs == null || member.maxOccurs === 1;
+  }
+  function flattenAllowedNames(node, out = /* @__PURE__ */ new Set()) {
+    if (!node) return out;
+    switch (node.kind) {
+      case "sequence":
+      case "choice":
+      case "all":
+        for (const child of node.children || []) {
+          flattenAllowedNames(child, out);
+        }
+        return out;
+      case "groupRef":
+        out.add(node.refName);
+        return out;
+      case "element":
+        out.add(node.refName || node.name);
+        return out;
+      default:
+        return out;
+    }
+  }
+  function validateRestrictionCompatibility(modelNode, context, pathParts, children = [], startIndex = 0) {
+    if (!context.currentComplexType?.derivation) return;
+    const derivation = context.currentComplexType.derivation;
+    if (derivation.kind !== "restriction") return;
+    const allowedNames = flattenAllowedNames(modelNode, /* @__PURE__ */ new Set());
+    for (let i = startIndex; i < children.length; i += 1) {
+      const childName = localName(children[i]);
+      if (!allowedNames.has(childName)) {
+        context.issues.push(
+          context.createIssue({
+            code: context.ISSUE_CODES.XML_RESTRICTED_ELEMENT_NOT_ALLOWED,
+            severity: "error",
+            message: `Element '${childName}' is not allowed by the restricted content model.`,
+            path: buildXmlPath([...pathParts, childName]),
+            source: "xml",
+            nodeKind: "element",
+            name: childName,
+            details: {}
+          })
+        );
+      }
+    }
+  }
+  function validateContentModel(children, modelNode, context, pathParts, startIndex = 0, silent = false) {
+    if (!modelNode) {
+      return { nextIndex: startIndex, matched: true, matchedAny: false };
+    }
+    validateRestrictionCompatibility(modelNode, context, pathParts, children, startIndex);
+    switch (modelNode.kind) {
+      case "element": {
+        const result = consumeMatchingElement(children, startIndex, modelNode, context, pathParts);
+        return {
+          nextIndex: result.nextIndex,
+          matched: result.matched,
+          matchedAny: result.nextIndex > startIndex
+        };
+      }
+      case "groupRef":
+        return validateGroupRef(children, startIndex, modelNode, context, pathParts);
+      case "sequence": {
+        let index = startIndex;
+        let matchedAny = false;
+        for (const childDecl of modelNode.children || []) {
+          const result = validateContentModel(children, childDecl, context, pathParts, index, silent);
+          if (!result.matched && !silent) {
+            return { nextIndex: index, matched: false, matchedAny };
+          }
+          index = result.nextIndex;
+          matchedAny = matchedAny || result.matchedAny;
+        }
+        return { nextIndex: index, matched: true, matchedAny };
+      }
+      case "choice":
+        return validateChoice(children, startIndex, modelNode, context, pathParts, silent);
+      case "all":
+        return validateAll(children, startIndex, modelNode, context, pathParts, silent);
+      case "any":
+        if (startIndex < children.length) {
+          return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        }
+        return { nextIndex: startIndex, matched: true, matchedAny: false };
+      default:
+        return { nextIndex: startIndex, matched: true, matchedAny: false };
+    }
+  }
+
+  // src/validation/builtinTypeValidators.js
+  function isIntegerString(value) {
+    return /^[-+]?\d+$/.test(value);
+  }
+  function isDecimalString(value) {
+    return /^[-+]?(?:\d+|\d*\.\d+)$/.test(value);
+  }
+  function isBooleanString(value) {
+    return value === "true" || value === "false" || value === "1" || value === "0";
+  }
+  function isDateString(value) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+  }
+  function isDateTimeString(value) {
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/.test(value);
+  }
+  function isTimeString(value) {
+    return /^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(value);
+  }
+  function validateBuiltinType(localTypeName, value) {
+    const text = String(value ?? "");
+    switch (localTypeName) {
+      case "string":
+      case "normalizedString":
+      case "token":
+      case "language":
+      case "Name":
+      case "NCName":
+      case "ID":
+      case "IDREF":
+      case "ENTITY":
+      case "NMTOKEN":
+      case "anyURI":
+      case "QName":
+      case "NOTATION":
+        return true;
+      case "boolean":
+        return isBooleanString(text);
+      case "decimal":
+      case "float":
+      case "double":
+        return isDecimalString(text);
+      case "integer":
+      case "nonPositiveInteger":
+      case "negativeInteger":
+      case "long":
+      case "int":
+      case "short":
+      case "byte":
+      case "nonNegativeInteger":
+      case "unsignedLong":
+      case "unsignedInt":
+      case "unsignedShort":
+      case "unsignedByte":
+      case "positiveInteger":
+        return isIntegerString(text);
+      case "date":
+        return isDateString(text);
+      case "dateTime":
+        return isDateTimeString(text);
+      case "time":
+        return isTimeString(text);
+      default:
+        return true;
+    }
+  }
+
+  // src/validation/facetUtils.js
+  function toNumber2(value) {
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+  }
+  function countDigits(value) {
+    const normalized = String(value).replace(/^[-+]/, "").replace(".", "");
+    return normalized.replace(/\D/g, "").length;
+  }
+  function countFractionDigits(value) {
+    const text = String(value);
+    const idx = text.indexOf(".");
+    if (idx < 0) return 0;
+    return text.slice(idx + 1).replace(/\D/g, "").length;
+  }
+  function testPatterns(patterns, value) {
+    for (const pattern of patterns || []) {
+      try {
+        const regex = new RegExp(pattern);
+        if (!regex.test(String(value))) {
+          return {
+            ok: false,
+            code: "XML_PATTERN_MISMATCH",
+            message: `Value '${value}' does not match required pattern '${pattern}'.`
+          };
+        }
+      } catch {
+        return {
+          ok: false,
+          code: "XML_PATTERN_MISMATCH",
+          message: `Value '${value}' could not be validated against pattern '${pattern}'.`
+        };
+      }
+    }
+    return { ok: true, code: null, message: null };
+  }
+  function validateLengthFacets(value, facets = {}) {
+    const text = String(value ?? "");
+    const len = text.length;
+    if (typeof facets.length === "number" && len !== facets.length) {
+      return {
+        ok: false,
+        code: "XML_LENGTH_MISMATCH",
+        message: `Value '${value}' must have length ${facets.length}.`
+      };
+    }
+    if (typeof facets.minLength === "number" && len < facets.minLength) {
+      return {
+        ok: false,
+        code: "XML_MIN_LENGTH_VIOLATION",
+        message: `Value '${value}' is shorter than minLength ${facets.minLength}.`
+      };
+    }
+    if (typeof facets.maxLength === "number" && len > facets.maxLength) {
+      return {
+        ok: false,
+        code: "XML_MAX_LENGTH_VIOLATION",
+        message: `Value '${value}' is longer than maxLength ${facets.maxLength}.`
+      };
+    }
+    return { ok: true, code: null, message: null };
+  }
+  function validateNumericFacets(value, facets = {}) {
+    const num = toNumber2(value);
+    if (num == null) {
+      return { ok: true, code: null, message: null };
+    }
+    if (facets.minInclusive != null) {
+      const min = toNumber2(facets.minInclusive);
+      if (min != null && num < min) {
+        return {
+          ok: false,
+          code: "XML_MIN_INCLUSIVE_VIOLATION",
+          message: `Value '${value}' is less than minInclusive ${facets.minInclusive}.`
+        };
+      }
+    }
+    if (facets.maxInclusive != null) {
+      const max = toNumber2(facets.maxInclusive);
+      if (max != null && num > max) {
+        return {
+          ok: false,
+          code: "XML_MAX_INCLUSIVE_VIOLATION",
+          message: `Value '${value}' is greater than maxInclusive ${facets.maxInclusive}.`
+        };
+      }
+    }
+    if (facets.minExclusive != null) {
+      const min = toNumber2(facets.minExclusive);
+      if (min != null && num <= min) {
+        return {
+          ok: false,
+          code: "XML_MIN_EXCLUSIVE_VIOLATION",
+          message: `Value '${value}' must be greater than minExclusive ${facets.minExclusive}.`
+        };
+      }
+    }
+    if (facets.maxExclusive != null) {
+      const max = toNumber2(facets.maxExclusive);
+      if (max != null && num >= max) {
+        return {
+          ok: false,
+          code: "XML_MAX_EXCLUSIVE_VIOLATION",
+          message: `Value '${value}' must be less than maxExclusive ${facets.maxExclusive}.`
+        };
+      }
+    }
+    return { ok: true, code: null, message: null };
+  }
+  function validateDigitFacets(value, facets = {}) {
+    const text = String(value ?? "");
+    if (typeof facets.totalDigits === "number") {
+      const total = countDigits(text);
+      if (total > facets.totalDigits) {
+        return {
+          ok: false,
+          code: "XML_TOTAL_DIGITS_VIOLATION",
+          message: `Value '${value}' exceeds totalDigits ${facets.totalDigits}.`
+        };
+      }
+    }
+    if (typeof facets.fractionDigits === "number") {
+      const fraction = countFractionDigits(text);
+      if (fraction > facets.fractionDigits) {
+        return {
+          ok: false,
+          code: "XML_FRACTION_DIGITS_VIOLATION",
+          message: `Value '${value}' exceeds fractionDigits ${facets.fractionDigits}.`
+        };
+      }
+    }
+    return { ok: true, code: null, message: null };
+  }
+  function validatePatternFacets(value, facets = {}) {
+    if (!facets.pattern?.length) {
+      return { ok: true, code: null, message: null };
+    }
+    return testPatterns(facets.pattern, value);
+  }
+  function validateFacets(value, facets = {}) {
+    const checks = [
+      validateLengthFacets(value, facets),
+      validateNumericFacets(value, facets),
+      validateDigitFacets(value, facets),
+      validatePatternFacets(value, facets)
+    ];
+    return checks.find((item) => !item.ok) || { ok: true, code: null, message: null };
+  }
+
+  // src/validation/valueValidator.js
+  function validateByDeclType(schema, decl, value, kindLabel) {
+    const resolvedType = kindLabel === "attribute" ? resolveAttributeType(schema, decl) : resolveElementType(schema, decl);
+    return validateResolvedValue(schema, resolvedType, value);
+  }
+  function validateElementValue(schema, elementDecl, value) {
+    const fixed = elementDecl.fixedValue;
+    if (fixed != null) {
+      if (value !== fixed) {
+        return {
+          ok: false,
+          code: "XML_FIXED_VALUE_MISMATCH",
+          message: `Element '${elementDecl.name || elementDecl.refName}' must have fixed value '${fixed}'.`
+        };
+      }
+      return { ok: true, code: null, message: null };
+    }
+    return validateByDeclType(schema, elementDecl, value, "element");
+  }
+  function validateAttributeValue(schema, attrDecl, value) {
+    const fixed = attrDecl.fixedValue;
+    if (fixed != null) {
+      if (value !== fixed) {
+        return {
+          ok: false,
+          code: "XML_FIXED_VALUE_MISMATCH",
+          message: `Attribute '${attrDecl.name || attrDecl.refName}' must have fixed value '${fixed}'.`
+        };
+      }
+      return { ok: true, code: null, message: null };
+    }
+    return validateByDeclType(schema, attrDecl, value, "attribute");
+  }
+  function validateResolvedValue(schema, resolvedType, value) {
+    if (!resolvedType) {
+      return { ok: true, code: null, message: null };
+    }
+    if (resolvedType.kind === "builtinType") {
+      const local = stripNamespacePrefix(resolvedType.name);
+      const ok = validateBuiltinType(local, value);
+      return ok ? { ok: true, code: null, message: null } : {
+        ok: false,
+        code: "XML_VALUE_INVALID",
+        message: `Value '${value}' is not valid for type '${local}'.`
+      };
+    }
+    if (resolvedType.kind === "simpleType") {
+      const effective = getEffectiveSimpleType(schema, resolvedType);
+      if (effective.enumerations?.length) {
+        const allowed = effective.enumerations.map(String);
+        if (!allowed.includes(String(value))) {
+          return {
+            ok: false,
+            code: "XML_ENUMERATION_MISMATCH",
+            message: `Value '${value}' is not one of the allowed enumeration values: ${allowed.join(", ")}.`
+          };
+        }
+      }
+      if (effective.baseTypeName && isBuiltinType(effective.baseTypeName, schema)) {
+        const local = stripNamespacePrefix(effective.baseTypeName);
+        const builtinOk = validateBuiltinType(local, value);
+        if (!builtinOk) {
+          return {
+            ok: false,
+            code: "XML_VALUE_INVALID",
+            message: `Value '${value}' is not valid for base type '${local}'.`
+          };
+        }
+      }
+      const facetResult = validateFacets(value, effective.facets || {});
+      if (!facetResult.ok) {
+        return facetResult;
+      }
+      return { ok: true, code: null, message: null };
+    }
+    return { ok: true, code: null, message: null };
+  }
+
+  // src/validation/validateXmlAgainstSchema.js
+  function elementChildren3(xmlNode) {
+    return Array.from(xmlNode?.children || []).filter((child) => child.nodeType === 1);
+  }
+  function localName2(node) {
+    return node?.localName || node?.nodeName || null;
+  }
+  function namespaceUri2(node) {
+    return node?.namespaceURI || null;
+  }
+  function parseXml(xmlText) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(xmlText, "application/xml");
+    const parserError = doc.querySelector("parsererror");
+    if (parserError) {
+      return {
+        ok: false,
+        doc: null,
+        issues: [
+          createIssue({
+            code: ISSUE_CODES.XML_PARSE_ERROR,
+            severity: "error",
+            message: parserError.textContent?.trim() || "Failed to parse XML.",
+            source: "xml"
+          })
+        ]
+      };
+    }
+    return { ok: true, doc, issues: [] };
+  }
+  function determineRootElement(schema, xmlRootName, xmlRootNs, options) {
+    if (options.rootElementName) {
+      return resolveGlobalElement(schema, options.rootElementName);
+    }
+    const candidates = Object.values(schema?.globals?.elements || {});
+    return candidates.find(
+      (decl) => decl.name === xmlRootName && (decl.namespaceUri || null) === (xmlRootNs || null)
+    ) || candidates.find(
+      (decl) => decl.name === xmlRootName && (decl.namespaceUri == null || decl.namespaceUri === "")
+    ) || null;
+  }
+  function validateXmlAgainstSchema(schema, xmlText, options = {}, helpers = {}) {
+    const xmlParse = parseXml(xmlText);
+    if (!xmlParse.ok || !xmlParse.doc) {
+      return {
+        data: { xmlValid: false },
+        issues: xmlParse.issues
+      };
+    }
+    const xmlRoot = xmlParse.doc.documentElement;
+    const xmlRootName = localName2(xmlRoot);
+    const xmlRootNs = namespaceUri2(xmlRoot);
+    const issues = [...xmlParse.issues];
+    if (!xmlRoot) {
+      return {
+        data: { xmlValid: false },
+        issues: [
+          ...issues,
+          createIssue({
+            code: ISSUE_CODES.XML_PARSE_ERROR,
+            severity: "error",
+            message: "XML document has no document element.",
+            source: "xml"
+          })
+        ]
+      };
+    }
+    const schemaRoot = determineRootElement(schema, xmlRootName, xmlRootNs, options);
+    if (!schemaRoot) {
+      issues.push(
+        createIssue({
+          code: options.rootElementName ? ISSUE_CODES.XML_ROOT_ELEMENT_MISMATCH : ISSUE_CODES.XML_UNKNOWN_ROOT_ELEMENT,
+          severity: "error",
+          message: options.rootElementName ? `XML root '${xmlRootName}' does not match requested schema root '${options.rootElementName}'.` : `No matching global schema root found for XML root '${xmlRootName}'.`,
+          source: "xml",
+          nodeKind: "element",
+          name: xmlRootName,
+          details: { xmlRootName, xmlRootNamespace: xmlRootNs }
+        })
+      );
+      return {
+        data: { xmlValid: false },
+        issues
+      };
+    }
+    if ((schemaRoot.name || schemaRoot.refName) !== xmlRootName) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XML_ROOT_ELEMENT_MISMATCH,
+          severity: "error",
+          message: `Expected XML root '${schemaRoot.name || schemaRoot.refName}' but found '${xmlRootName}'.`,
+          source: "xml",
+          nodeKind: "element",
+          name: xmlRootName,
+          details: {
+            expectedRoot: schemaRoot.name || schemaRoot.refName,
+            actualRoot: xmlRootName
+          }
+        })
+      );
+      return {
+        data: { xmlValid: false },
+        issues
+      };
+    }
+    if (schemaRoot.namespaceUri && xmlRootNs && schemaRoot.namespaceUri !== xmlRootNs) {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XML_ROOT_ELEMENT_MISMATCH,
+          severity: "error",
+          message: "XML root namespace does not match schema root namespace.",
+          source: "xml",
+          nodeKind: "element",
+          name: xmlRootName,
+          details: {
+            expectedNamespace: schemaRoot.namespaceUri,
+            actualNamespace: xmlRootNs
+          }
+        })
+      );
+      return {
+        data: { xmlValid: false },
+        issues
+      };
+    }
+    const context = {
+      schema,
+      issues,
+      createIssue,
+      ISSUE_CODES,
+      validateElementValue,
+      validateAttributeValue,
+      resolveAttributeGroup: helpers.resolveAttributeGroup
+    };
+    const resolvedRootType = resolveType(schema, schemaRoot.typeName) || schemaRoot.inlineType;
+    if (resolvedRootType?.kind === "complexType") {
+      const rootContext = {
+        ...context,
+        pathParts: [xmlRootName],
+        currentComplexType: resolvedRootType
+      };
+      validateAttributes(xmlRoot, getEffectiveAttributes(schema, resolvedRootType), rootContext);
+      const hasDirectText = Array.from(xmlRoot.childNodes || []).some(
+        (node) => node.nodeType === 3 && node.nodeValue?.trim()
+      );
+      if (!resolvedRootType.mixed && hasDirectText) {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.XML_MIXED_CONTENT_NOT_ALLOWED,
+            severity: "error",
+            message: "Mixed text content is not allowed for this complex type.",
+            path: `/${xmlRootName}`,
+            source: "xml",
+            nodeKind: "element",
+            name: xmlRootName,
+            details: {}
+          })
+        );
+      }
+      const children = elementChildren3(xmlRoot);
+      const content = resolvedRootType?.kind === "complexType" ? getEffectiveContent(schema, resolvedRootType) : null;
+      if (content) {
+        const result = validateContentModel(
+          children,
+          content,
+          rootContext,
+          [xmlRootName],
+          0,
+          false
+        );
+        if (result.nextIndex < children.length) {
+          for (let i = result.nextIndex; i < children.length; i += 1) {
+            const childName = localName2(children[i]);
+            issues.push(
+              createIssue({
+                code: ISSUE_CODES.XML_UNEXPECTED_ELEMENT,
+                severity: "error",
+                message: `Unexpected element '${childName}'.`,
+                path: `/${xmlRootName}/${childName}`,
+                source: "xml",
+                nodeKind: "element",
+                name: childName,
+                details: {
+                  namespaceUri: namespaceUri2(children[i])
+                }
+              })
+            );
+          }
+        }
+      }
+    } else {
+      const valueResult = validateElementValue(schema, schemaRoot, (xmlRoot.textContent || "").trim());
+      if (!valueResult.ok) {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES[valueResult.code] || valueResult.code,
+            severity: "error",
+            message: valueResult.message,
+            path: `/${xmlRootName}`,
+            source: "xml",
+            nodeKind: "element",
+            name: xmlRootName,
+            details: {}
+          })
+        );
+      }
+    }
+    return {
+      data: {
+        xmlValid: !issues.some((issue) => issue.severity === "error")
+      },
+      issues
+    };
+  }
+
+  // src/api/validateXml.js
+  function validateXml({ xsdText, xmlText, options = {} } = {}) {
+    const parseResult = parseXsd(xsdText);
+    if (!parseResult.ok || !parseResult.doc) {
+      return makeResult({
+        data: { xmlValid: false },
+        issues: parseResult.issues
+      });
+    }
+    const modelResult = buildSchemaModel(parseResult.doc, {
+      ...options,
+      xsdText
+    });
+    const baseIssues = [
+      ...parseResult.issues || [],
+      ...modelResult.issues || []
+    ];
+    if (!modelResult.schema) {
+      return makeResult({
+        data: { xmlValid: false },
+        issues: baseIssues
+      });
+    }
+    const diagnostics = runSchemaDiagnostics(modelResult.schema, {
+      ...options,
+      includeWarnings: true,
+      includeFeatureSummary: false,
+      includeRoots: true
+    });
+    const validation = validateXmlAgainstSchema(modelResult.schema, xmlText, options, {
+      resolveAttributeGroup: (name) => resolveAttributeGroup(modelResult.schema, name)
+    });
+    return makeResult({
+      data: validation.data,
+      issues: [...baseIssues, ...diagnostics.issues || [], ...validation.issues || []]
+    });
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=uss-xsd-engine.standalone.js.map