uss-xsd-engine 0.1.0-beta.2

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

@@ -0,0 +1,4149 @@
+/*!
+ * uss-xsd-engine v0.1.0-beta.2
+ * (c) 2026 Bernard Mumble
+ * MIT License
+ */
+
+// 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 || []]
+  });
+}
+export {
+  extractSchemaTree,
+  generateSampleXml,
+  getSchemaDiagnostics,
+  validateXml
+};
+//# sourceMappingURL=uss-xsd-engine.esm.js.map