@dialecte/create 0.0.1

package/python/generate/deriver.py

@@ -0,0 +1,117 @@
+"""Deriver — compute transitive graphs and derived constants from collected IR.
+
+Phase 3 of the pipeline: Parse → Collect → **Derive** → Emit.
+"""
+from generate.ir import ElementDef, IdentityConstraint
+def derive_graph(
+    elements: dict[str, ElementDef],
+) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
+    """Compute transitive DESCENDANTS and ANCESTORS from CHILDREN/PARENTS.
+
+    Returns:
+        (descendants, ancestors) — each is a dict mapping element name to sorted list.
+    """
+    children_map = {name: list(e.children.keys()) for name, e in elements.items()}
+    parents_map = {name: list(e.parents) for name, e in elements.items()}
+
+    def transitive(graph: dict[str, list[str]], start: str) -> list[str]:
+        result: list[str] = []
+        visited: set[str] = set()
+        queue = list(graph.get(start, []))
+        while queue:
+            node = queue.pop(0)
+            if node in visited:
+                continue
+            visited.add(node)
+            result.append(node)
+            queue.extend(graph.get(node, []))
+        return sorted(result)
+
+    descendants = {name: transitive(children_map, name) for name in elements}
+    ancestors = {name: transitive(parents_map, name) for name in elements}
+    return descendants, ancestors
+def derive_root_element(elements: dict[str, ElementDef], override: str | None = None) -> str:
+    """Find the document root element.
+
+    If *override* is provided, use it directly (raising if absent).
+    Otherwise expect exactly one parentless element.
+    """
+    if override:
+        if override not in elements:
+            raise ValueError(f'Root override {override!r} not found in elements')
+        return override
+
+    roots = sorted(name for name, e in elements.items() if not e.parents)
+    if len(roots) != 1:
+        raise ValueError(f'Expected exactly 1 root element, found: {roots}')
+    return roots[0]
+def derive_singleton_elements(elements: dict[str, ElementDef], root_name: str) -> list[str]:
+    """Find elements that can appear at most once in the entire document.
+
+    An element is a document singleton if:
+      - It has maxOccurs <= 1 in every parent context (local singleton), AND
+      - All of its parents are also document singletons (transitive).
+
+    Computed via fixpoint: start from root, propagate singleton status downward.
+    """
+    # Step 1: local singletons — maxOccurs <= 1 everywhere
+    local_singleton: set[str] = set(elements.keys())
+    for elem in elements.values():
+        for child_name, child_def in elem.children.items():
+            if child_def.max_occurs is None or child_def.max_occurs > 1:
+                local_singleton.discard(child_name)
+
+    # Step 2: fixpoint — only keep elements whose entire parent chain is singleton
+    doc_singletons: set[str] = {root_name}
+    changed = True
+    while changed:
+        changed = False
+        for name, elem in elements.items():
+            if name in doc_singletons or name not in local_singleton:
+                continue
+            if elem.parents and all(p in doc_singletons for p in elem.parents):
+                doc_singletons.add(name)
+                changed = True
+
+    return sorted(doc_singletons)
+
+
+def derive_identity_fields(elements: dict[str, ElementDef]) -> dict[str, list[str]]:
+    """Precompute which attributes participate in identity constraints per element.
+
+    Scans all element-level constraints, resolves selector targets,
+    and assigns field attributes to targeted elements.
+    Returns element name -> sorted list of attribute names used in unique/key fields.
+    """
+    result: dict[str, set[str]] = {}
+    for element in elements.values():
+        for constraint in element.constraints:
+            for target in _resolve_constraint_targets(constraint, elements):
+                result.setdefault(target, set())
+                result[target] |= _extract_attribute_fields(constraint)
+    return {name: sorted(fields) for name, fields in result.items() if fields}
+
+
+def _resolve_constraint_targets(
+    constraint: IdentityConstraint, elements: dict[str, ElementDef]
+) -> set[str]:
+    """Find which element names a constraint's selector targets."""
+    if constraint.kind == 'keyref':
+        return set()
+    targets: set[str] = set()
+    for path in constraint.selector:
+        for step in path.steps:
+            if step.kind == 'name' and step.value in elements:
+                targets.add(step.value)
+    return targets
+
+
+def _extract_attribute_fields(constraint: IdentityConstraint) -> set[str]:
+    """Extract attribute names from a constraint's field targets."""
+    if constraint.kind == 'keyref':
+        return set()
+    return {
+        f.target.value
+        for f in constraint.fields
+        if f.target.is_attribute and f.target.value
+    }

package/python/generate/emitters/__init__.py

@@ -0,0 +1 @@
+# Emitters — one per output file

package/python/generate/emitters/constants.py

@@ -0,0 +1,69 @@
+"""Emit constants.generated.ts — lookup tables and derived constants."""
+from pathlib import Path
+
+from generate.emitters.ts_helpers import ts_key, ts_record, ts_string_array
+from generate.ir import ElementDef
+def emit_constants(
+    elements: dict[str, ElementDef],
+    descendants: dict[str, list[str]],
+    ancestors: dict[str, list[str]],
+    root_element: str,
+    singleton_elements: list[str],
+    out: Path,
+) -> None:
+    """Write constants.generated.ts with all lookup tables."""
+    names = sorted(elements.keys())
+
+    lines = [
+        '// Auto-generated by generate.py — do not edit',
+        '',
+        "import type { AvailableElement, AttributesOf } from './types.generated'",
+        '',
+        f'export const ELEMENT_NAMES = {ts_string_array(names)} as const',
+        '',
+        f'export const CHILDREN = {ts_record(_child_map(elements))} as const',
+        '',
+        f'export const PARENTS = {ts_record(_parent_map(elements))} as const',
+        '',
+        f'export const DESCENDANTS = {ts_record(descendants)} as const',
+        '',
+        f'export const ANCESTORS = {ts_record(ancestors)} as const',
+        '',
+        f"export const ROOT_ELEMENT = '{root_element}' as const",
+        '',
+        f'export const SINGLETON_ELEMENTS = {ts_string_array(singleton_elements)} as const',
+        '',
+        f'export const ATTRIBUTES = {_attr_obj_ts(elements)} as const',
+        '',
+        f'export const REQUIRED_ATTRIBUTES = {ts_record(_required_attr_map(elements))} as const satisfies Record<AvailableElement, readonly string[]>',
+        '',
+    ]
+
+    out.write_text('\n'.join(lines), encoding='utf-8')
+def _child_map(elements: dict[str, ElementDef]) -> dict[str, list[str]]:
+    """Element name → sorted child element names."""
+    return {name: list(e.child_sequence) for name, e in elements.items()}
+def _parent_map(elements: dict[str, ElementDef]) -> dict[str, list[str]]:
+    """Element name → sorted parent element names."""
+    return {name: sorted(e.parents) for name, e in elements.items()}
+def _attr_obj_ts(elements: dict[str, ElementDef]) -> str:
+    """Generate ATTRIBUTES runtime object: each element → keyed record with '' values cast via AttributesOf."""
+    lines = ['{']
+    for name in sorted(elements.keys()):
+        elem = elements[name]
+        if not elem.attr_sequence:
+            lines.append(f"\t{name}: {{}} as AttributesOf<'{name}'>,")
+        else:
+            lines.append(f'\t{name}: {{')
+            for attr_name in elem.attr_sequence:
+                key = ts_key(attr_name)
+                lines.append(f"\t\t{key}: '' as string,")
+            lines.append(f"\t}} as AttributesOf<'{name}'>,")
+    lines.append('}')
+    return '\n'.join(lines)
+def _required_attr_map(elements: dict[str, ElementDef]) -> dict[str, list[str]]:
+    """Element name → required attribute names (sorted)."""
+    return {
+        name: sorted(aname for aname, adef in e.attributes.items() if adef.required)
+        for name, e in elements.items()
+    }

package/python/generate/emitters/definition.py

@@ -0,0 +1,49 @@
+"""Emit definition.generated.ts — the DEFINITION constant."""
+from pathlib import Path
+
+from generate.emitters.ts_helpers import (
+    ts_attr_block,
+    ts_child_block,
+    ts_constraints,
+    ts_namespace,
+    ts_string,
+    ts_text_content,
+)
+from generate.ir import ElementDef
+def emit_definition(elements: dict[str, ElementDef], out: Path) -> None:
+    """Write the DEFINITION constant to definition.generated.ts.
+
+    Sparse — only non-default fields emitted per element.
+    """
+    lines = [
+        '// Auto-generated by generate.py — do not edit',
+        '',
+        'export const DEFINITION = {',
+    ]
+
+    for name in sorted(elements):
+        elem = elements[name]
+        lines.append(f'\t{name}: {{')
+        lines.append(f"\t\ttag: '{name}',")
+        lines.append(f'\t\tnamespace: {ts_namespace(elem.namespace)},')
+        if elem.documentation:
+            lines.append(f'\t\tdocumentation: {ts_string(elem.documentation)},')
+        lines.append(f'\t\tparents: {_inline_string_array(elem.parents)},')
+        lines.append(f'\t\tattributes: {ts_attr_block(elem, "\t\t\t")},')
+        lines.append(f'\t\tchildren: {ts_child_block(elem, "\t\t\t")},')
+        if elem.constraints:
+            lines.append(f'\t\tconstraints: {ts_constraints(elem.constraints, "\t\t\t")},')
+        if elem.text_content:
+            lines.append(f'\t\ttextContent: {ts_text_content(elem.text_content, "\t\t\t")},')
+        lines.append('\t},')
+
+    lines.append('} as const')
+    lines.append('')
+
+    out.write_text('\n'.join(lines), encoding='utf-8')
+def _inline_string_array(items: list[str]) -> str:
+    """Short array on one line."""
+    if not items:
+        return '[]'
+    inner = ', '.join(f"'{i}'" for i in items)
+    return f'[{inner}]'

package/python/generate/emitters/ts_helpers.py

@@ -0,0 +1,283 @@
+"""Shared emission helpers for converting IR to TypeScript literals."""
+import json
+from typing import Any
+
+from generate.ir import (
+    AttributeDef,
+    ChildDef,
+    ChoiceGroup,
+    ElementDef,
+    Facets,
+    IdentityConstraint,
+    Namespace,
+    TextContent,
+)
+from generate.xpath_parser import FieldPath, FieldTarget, SelectorPath, XPathStep
+def sparse(d: dict[str, Any]) -> dict[str, Any]:
+    """Drop keys whose values are default (None, False, [], 0, {})."""
+    return {
+        k: v
+        for k, v in d.items()
+        if v is not None and v is not False and v != [] and v != 0 and v != {}
+    }
+def ts_string(s: str) -> str:
+    """Emit a TS string literal, escaping quotes and backslashes."""
+    return json.dumps(s, ensure_ascii=False)
+def ts_string_array(items: list[str], indent: str = '') -> str:
+    """Emit a TS readonly string array literal."""
+    if not items:
+        return '[]'
+    inner = ', '.join(ts_string(i) for i in items)
+    return f'[{inner}]'
+def ts_record(data: dict[str, list[str]], indent: str = '\t') -> str:
+    """Emit a TS Record<string, string[]> literal."""
+    if not data:
+        return '{}'
+    lines = ['{']
+    for key in sorted(data.keys()):
+        arr = ts_string_array(data[key])
+        lines.append(f'{indent}{ts_key(key)}: {arr},')
+    lines.append('}')
+    return '\n'.join(lines)
+def ts_key(name: str) -> str:
+    """Quote a TS object key if it contains special characters."""
+    if ':' in name or '-' in name or ' ' in name or not name.isidentifier():
+        return ts_string(name)
+    return name
+def ts_namespace(ns: Namespace) -> str:
+    """Emit a Namespace object literal."""
+    return f"{{ prefix: {ts_string(ns.prefix)}, uri: {ts_string(ns.uri)} }}"
+def ts_facets(facets: Facets | None, indent: str = '\t\t\t') -> str:
+    """Emit a sparse Facets literal."""
+    if facets is None or facets.is_empty():
+        return 'undefined'
+
+    fields: dict[str, Any] = {}
+    if facets.enumeration is not None:
+        fields['enumeration'] = facets.enumeration
+    if facets.pattern is not None:
+        fields['pattern'] = facets.pattern
+    if facets.min_length is not None:
+        fields['minLength'] = facets.min_length
+    if facets.max_length is not None:
+        fields['maxLength'] = facets.max_length
+    if facets.length is not None:
+        fields['length'] = facets.length
+    if facets.min_inclusive is not None:
+        fields['minInclusive'] = facets.min_inclusive
+    if facets.max_inclusive is not None:
+        fields['maxInclusive'] = facets.max_inclusive
+    if facets.min_exclusive is not None:
+        fields['minExclusive'] = facets.min_exclusive
+    if facets.max_exclusive is not None:
+        fields['maxExclusive'] = facets.max_exclusive
+    if facets.total_digits is not None:
+        fields['totalDigits'] = facets.total_digits
+    if facets.fraction_digits is not None:
+        fields['fractionDigits'] = facets.fraction_digits
+    if facets.white_space is not None:
+        fields['whiteSpace'] = facets.white_space
+
+    if not fields:
+        return 'undefined'
+
+    return _emit_object(fields, indent)
+def ts_attr_block(elem: ElementDef, indent: str = '\t\t') -> str:
+    """Emit the attributes block for an element."""
+    lines = ['{']
+    lines.append(f'{indent}sequence: {ts_string_array(elem.attr_sequence)},')
+    if elem.attr_any:
+        lines.append(f'{indent}any: true,')
+    lines.append(f'{indent}details: {{')
+    for key in elem.attr_sequence:
+        attr = elem.attributes[key]
+        lines.append(f'{indent}\t{ts_key(key)}: {_ts_attr_def(attr, indent + "\t\t")},')
+    lines.append(f'{indent}}},')
+    if elem.identity_fields:
+        lines.append(f'{indent}identityFields: {ts_string_array(elem.identity_fields)},')
+    lines.append(f'{indent[:-1]}}}')
+    return '\n'.join(lines)
+def ts_child_block(elem: ElementDef, indent: str = '\t\t') -> str:
+    """Emit the children block for an element."""
+    lines = ['{']
+    lines.append(f'{indent}sequence: {ts_string_array(elem.child_sequence)},')
+    if elem.child_any:
+        lines.append(f'{indent}any: true,')
+    lines.append(f'{indent}details: {{')
+    for key in elem.child_sequence:
+        child = elem.children[key]
+        lines.append(f'{indent}\t{ts_key(key)}: {_ts_child_def(child, indent + "\t\t")},')
+    lines.append(f'{indent}}},')
+    if elem.choices:
+        lines.append(f'{indent}choices: {_ts_choices(elem.choices, indent + "\t")},')
+    lines.append(f'{indent[:-1]}}}')
+    return '\n'.join(lines)
+def ts_constraints(constraints: list[IdentityConstraint], indent: str = '\t\t') -> str:
+    """Emit an array of constraints."""
+    if not constraints:
+        return '[]'
+    lines = ['[']
+    for c in constraints:
+        lines.append(f'{indent}{_ts_constraint(c, indent + "\t")},')
+    lines.append(f'{indent[:-1]}]')
+    return '\n'.join(lines)
+def ts_text_content(tc: TextContent, indent: str = '\t\t') -> str:
+    """Emit a TextContent literal."""
+    f = ts_facets(tc.facets, indent + '\t')
+    if f == 'undefined':
+        return '{}'
+    return f'{{ facets: {f} }}'
+# --- Private helpers ---
+def _ts_attr_def(attr: AttributeDef, indent: str) -> str:
+    """Emit a sparse AttributeDefinition literal."""
+    fields: dict[str, Any] = {}
+    if attr.required:
+        fields['required'] = True
+    if attr.default is not None:
+        fields['default'] = attr.default
+    if attr.fixed is not None:
+        fields['fixed'] = attr.fixed
+    if attr.namespace is not None:
+        fields['namespace'] = attr.namespace
+    if attr.facets is not None and not attr.facets.is_empty():
+        fields['facets'] = attr.facets
+
+    if not fields:
+        return '{}'
+    return _emit_object(fields, indent)
+def _ts_child_def(child: ChildDef, indent: str) -> str:
+    """Emit a sparse ChildDefinition literal."""
+    fields: dict[str, Any] = {}
+    if child.required:
+        fields['required'] = True
+    if child.min_occurs != 0:
+        fields['minOccurs'] = child.min_occurs
+    if child.max_occurs is not None:
+        fields['maxOccurs'] = child.max_occurs
+    if child.constraints:
+        fields['constraints'] = child.constraints
+
+    if not fields:
+        return '{}'
+    return _emit_object(fields, indent)
+def _ts_constraint(c: IdentityConstraint, indent: str) -> str:
+    """Emit a single IdentityConstraint literal."""
+    fields: dict[str, Any] = {'kind': c.kind, 'name': c.name}
+    if c.refer:
+        fields['refer'] = c.refer
+    if c.deep:
+        fields['deep'] = True
+    # Emit as raw TS — handled below for structured types
+    parts: list[str] = []
+    for key, value in fields.items():
+        parts.append(f'{ts_key(key)}: {_emit_value(value, indent)}')
+    parts.append(f'selector: {_ts_selector_paths(c.selector)}')
+    parts.append(f'fields: {_ts_field_paths(c.fields)}')
+    inner = ', '.join(parts)
+    return '{ ' + inner + ' }'
+
+
+def _ts_selector_paths(paths: list[SelectorPath]) -> str:
+    """Emit selector paths array."""
+    if not paths:
+        return '[]'
+    items = [_ts_selector_path(p) for p in paths]
+    return '[' + ', '.join(items) + ']'
+
+
+def _ts_selector_path(p: SelectorPath) -> str:
+    """Emit a single SelectorPath literal."""
+    parts: list[str] = []
+    if p.deep:
+        parts.append('deep: true')
+    parts.append(f'steps: {_ts_xpath_steps(p.steps)}')
+    return '{ ' + ', '.join(parts) + ' }'
+
+
+def _ts_field_paths(fields: list[FieldPath]) -> str:
+    """Emit field paths array."""
+    if not fields:
+        return '[]'
+    items = [_ts_field_path(f) for f in fields]
+    return '[' + ', '.join(items) + ']'
+
+
+def _ts_field_path(f: FieldPath) -> str:
+    """Emit a single FieldPath literal."""
+    parts: list[str] = []
+    if f.deep:
+        parts.append('deep: true')
+    if f.steps:
+        parts.append(f'steps: {_ts_xpath_steps(f.steps)}')
+    parts.append(f'target: {_ts_field_target(f.target)}')
+    return '{ ' + ', '.join(parts) + ' }'
+
+
+def _ts_xpath_steps(steps: tuple[XPathStep, ...]) -> str:
+    """Emit an array of XPathStep literals."""
+    if not steps:
+        return '[]'
+    items = [_ts_xpath_step(s) for s in steps]
+    return '[' + ', '.join(items) + ']'
+
+
+def _ts_xpath_step(s: XPathStep) -> str:
+    """Emit a single XPathStep."""
+    if s.value is not None:
+        return '{ ' + f"kind: '{s.kind}', value: {ts_string(s.value)}" + ' }'
+    return '{ ' + f"kind: '{s.kind}'" + ' }'
+
+
+def _ts_field_target(t: FieldTarget) -> str:
+    """Emit a FieldTarget literal."""
+    parts = [f"kind: '{t.kind}'"]
+    if t.value is not None:
+        parts.append(f'value: {ts_string(t.value)}')
+    if t.is_attribute:
+        parts.append('isAttribute: true')
+    return '{ ' + ', '.join(parts) + ' }'
+def _ts_choices(choices: list[ChoiceGroup], indent: str) -> str:
+    """Emit ChoiceGroup array."""
+    lines = ['[']
+    for cg in choices:
+        fields: dict[str, Any] = {'options': cg.options}
+        if cg.min_occurs != 0:
+            fields['minOccurs'] = cg.min_occurs
+        if cg.max_occurs is not None:
+            fields['maxOccurs'] = cg.max_occurs
+        lines.append(f'{indent}{_emit_object(fields, indent + "\t")},')
+    lines.append(f'{indent[:-1]}]')
+    return '\n'.join(lines)
+def _emit_object(fields: dict[str, Any], indent: str) -> str:
+    """Emit a TS object literal from a dict, handling typed values."""
+    if not fields:
+        return '{}'
+
+    parts: list[str] = []
+    for key, value in fields.items():
+        ts_val = _emit_value(value, indent)
+        parts.append(f'{ts_key(key)}: {ts_val}')
+
+    if len(parts) == 1:
+        return '{ ' + parts[0] + ' }'
+    inner = ', '.join(parts)
+    return '{ ' + inner + ' }'
+def _emit_value(value: Any, indent: str) -> str:
+    """Emit a TS value from a Python value."""
+    if isinstance(value, bool):
+        return 'true' if value else 'false'
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, str):
+        return ts_string(value)
+    if isinstance(value, list):
+        if all(isinstance(v, str) for v in value):
+            return ts_string_array(value)
+        if all(isinstance(v, IdentityConstraint) for v in value):
+            return ts_constraints(value, indent)
+        return ts_string_array([str(v) for v in value])
+    if isinstance(value, Namespace):
+        return ts_namespace(value)
+    if isinstance(value, Facets):
+        return ts_facets(value, indent)
+    return str(value)

package/python/generate/emitters/types.py

@@ -0,0 +1,67 @@
+"""Emit types.generated.ts — per-element attribute type interfaces."""
+from pathlib import Path
+
+from generate.emitters.ts_helpers import ts_key
+from generate.ir import AttributeDef, ElementDef
+def emit_types(elements: dict[str, ElementDef], out: Path) -> None:
+    """Write types.generated.ts with attribute type interfaces.
+
+    Namespace-qualified keys (e.g. 'eIEC61850-6-100:version') are quoted in the TS interface.
+    Enumeration facets generate union types.
+    """
+    lines = [
+        '// Auto-generated by generate.py — do not edit',
+        '',
+        "import type { ELEMENT_NAMES, REQUIRED_ATTRIBUTES } from './constants.generated'",
+        '',
+        'export type AvailableElement = (typeof ELEMENT_NAMES)[number]',
+        '',
+    ]
+
+    sorted_names = sorted(elements)
+
+    for name in sorted_names:
+        elem = elements[name]
+        lines.append(f'export type Attributes{name} = {{')
+        for attr_name in elem.attr_sequence:
+            attr = elem.attributes[attr_name]
+            ts_type = _attr_to_ts_type(attr)
+            optional = '?' if not attr.required else ''
+            key = ts_key(attr_name)
+            lines.append(f'\t{key}{optional}: {ts_type}')
+        lines.append('}')
+        lines.append('')
+
+    lines.append('export type AttributesMap = {')
+    for name in sorted_names:
+        lines.append(f'\t{name}: Attributes{name}')
+    lines.append('}')
+    lines.append('')
+    lines.append('export type AttributesOf<T extends AvailableElement> = AttributesMap[T]')
+    lines.append('')
+    lines.append('export type RequiredAttributeNames<T extends AvailableElement> =')
+    lines.append('\t(typeof REQUIRED_ATTRIBUTES)[T][number]')
+    lines.append('export type OptionalAttributeNames<T extends AvailableElement> = Exclude<')
+    lines.append('\tkeyof AttributesOf<T>,')
+    lines.append('\tRequiredAttributeNames<T>')
+    lines.append('>')
+    lines.append('')
+
+    out.write_text('\n'.join(lines), encoding='utf-8')
+def _attr_to_ts_type(attr: AttributeDef) -> str:
+    """Generate a TS type annotation from an attribute definition.
+
+    - Enumerations → union of literal strings + (string & {}) for extensibility
+    - Fixed values → literal string type
+    - Default → string
+    """
+    facets = attr.facets
+
+    if facets and facets.enumeration:
+        literals = ' | '.join(f"'{v}'" for v in facets.enumeration)
+        return f'{literals} | (string & {{}})'
+
+    if attr.fixed:
+        return f"'{attr.fixed}'"
+
+    return 'string'

package/python/generate/extractors/__init__.py

@@ -0,0 +1 @@
+# Extractors — one per XSD concern

package/python/generate/extractors/attributes.py

@@ -0,0 +1,83 @@
+"""Extract attributes from an XSD element."""
+from typing import Any
+
+from generate.extractors.facets import extract_facets
+from generate.extractors.namespace import extract_attr_namespace
+from generate.helpers import local_name
+from generate.ir import AttributeDef, Namespace
+
+# W3C XML namespace attrs (xml:base, xml:lang, xml:space, xml:id, etc.) are
+# implicitly valid on every XML element and have no meaning in IEC schemas.
+_XML_NS_URI = 'http://www.w3.org/XML/1998/namespace'
+
+
+def extract_attributes(xsd_elem: Any) -> tuple[list[str], bool, dict[str, AttributeDef]]:
+    """Extract attributes from an XSD element.
+
+    Uses qualify-on-collision keying: bare local name by default; a namespace-prefixed
+    key (``prefix:local``) only when two or more attributes on the same element share
+    the same local name (e.g. SCL ``version`` and 6-100 ``version``).
+
+    Returns:
+        (attr_sequence, has_any_attribute, attribute_details)
+
+    xmlschema API:
+      XsdElement.attributes: XsdAttributeGroup (dict-like, name → XsdAttribute)
+      XsdAttribute.use: str ('optional' | 'required' | 'prohibited')
+      XsdAttribute.default: str | None
+      XsdAttribute.fixed: str | None
+      XsdAttribute.type: XsdSimpleType
+      XsdAttributeGroup[attr_name]: XsdAttribute
+
+      Wildcards:
+      XsdElement.attributes.wildcard → XsdAnyAttribute | None (xs:anyAttribute)
+    """
+    sequence: list[str] = []
+    details: dict[str, AttributeDef] = {}
+    any_attr = False
+
+    attributes = getattr(xsd_elem, 'attributes', None)
+    if attributes is None:
+        return sequence, any_attr, details
+
+    # Pass 1: collect raw (local_name, namespace, xsd_attr) for collision detection
+    raw: list[tuple[str, Namespace | None, Any]] = []
+    for attr_name, xsd_attr in attributes.items():
+        if attr_name is None:
+            continue
+        ns = extract_attr_namespace(xsd_attr)
+        if ns and ns.uri == _XML_NS_URI:
+            continue  # skip W3C XML namespace attrs (xml:base, xml:lang, xml:space, xml:id)
+        raw.append((local_name(attr_name), ns, xsd_attr))
+
+    # Detect local-name collisions
+    local_count: dict[str, int] = {}
+    for ln, _, _ in raw:
+        local_count[ln] = local_count.get(ln, 0) + 1
+    collision_locals = {ln for ln, cnt in local_count.items() if cnt > 1}
+
+    # Pass 2: build keys and AttributeDefs
+    for ln, ns, xsd_attr in raw:
+        key = f'{ns.prefix}:{ln}' if (ln in collision_locals and ns and ns.prefix) else ln
+
+        fixed = getattr(xsd_attr, 'fixed', None)
+        default = getattr(xsd_attr, 'default', None) if fixed is None else None
+        use = getattr(xsd_attr, 'use', 'optional')
+        attr_type = getattr(xsd_attr, 'type', None)
+
+        details[key] = AttributeDef(
+            required=use == 'required',
+            default=default,
+            fixed=fixed,
+            namespace=ns,
+            facets=extract_facets(attr_type),
+        )
+        sequence.append(key)
+
+    sequence.sort()
+
+    # Check xs:anyAttribute
+    wildcard = getattr(attributes, 'wildcard', None)
+    any_attr = wildcard is not None
+
+    return sequence, any_attr, details