Auto-build: copilot (python) from 7fa279c

.github/skills/form-validate/scripts/form-validate.py

@@ -0,0 +1,730 @@
+#!/usr/bin/env python3
+# form-validate v1.6 — Validate 1C managed form
+# Source: https://github.com/Nikolay-Shirokov/cc-1c-skills
+
+import argparse
+import os
+import re
+import sys
+from lxml import etree
+
+F_NS = "http://v8.1c.ru/8.3/xcf/logform"
+V8_NS = "http://v8.1c.ru/8.1/data/core"
+
+NSMAP = {"f": F_NS, "v8": V8_NS}
+
+KNOWN_INVALID_TYPES = {
+    'FormDataStructure', 'FormDataCollection', 'FormDataTree',
+    'FormDataTreeItem', 'FormDataCollectionItem',
+    'FormGroup', 'FormField', 'FormButton', 'FormDecoration', 'FormTable',
+}
+
+VALID_CLOSED_TYPES = {
+    'xs:boolean', 'xs:string', 'xs:decimal', 'xs:dateTime', 'xs:binary',
+    'v8:FillChecking', 'v8:Null', 'v8:StandardPeriod', 'v8:StandardBeginningDate', 'v8:Type',
+    'v8:TypeDescription', 'v8:UUID', 'v8:ValueListType', 'v8:ValueTable', 'v8:ValueTree',
+    'v8:Universal', 'v8:FixedArray', 'v8:FixedStructure',
+    'v8ui:Color', 'v8ui:Font', 'v8ui:FormattedString', 'v8ui:HorizontalAlign',
+    'v8ui:Picture', 'v8ui:SizeChangeMode', 'v8ui:VerticalAlign',
+    'dcsset:DataCompositionComparisonType', 'dcsset:DataCompositionFieldPlacement',
+    'dcsset:Filter', 'dcsset:SettingsComposer', 'dcsset:DataCompositionSettings',
+    'dcssch:DataCompositionSchema',
+    'dcscor:DataCompositionComparisonType', 'dcscor:DataCompositionGroupType',
+    'dcscor:DataCompositionPeriodAdditionType', 'dcscor:DataCompositionSortDirection', 'dcscor:Field',
+    'ent:AccountType', 'ent:AccumulationRecordType', 'ent:AccountingRecordType',
+}
+
+VALID_CFG_PREFIXES = {
+    'AccountingRegisterRecordSet', 'AccumulationRegisterRecordSet',
+    'BusinessProcessObject', 'BusinessProcessRef',
+    'CatalogObject', 'CatalogRef',
+    'ChartOfAccountsObject', 'ChartOfAccountsRef',
+    'ChartOfCalculationTypesObject', 'ChartOfCalculationTypesRef',
+    'ChartOfCharacteristicTypesObject', 'ChartOfCharacteristicTypesRef',
+    'ConstantsSet', 'DataProcessorObject', 'DocumentObject', 'DocumentRef',
+    'DynamicList', 'EnumRef', 'ExchangePlanObject', 'ExchangePlanRef',
+    'ExternalDataProcessorObject', 'ExternalReportObject',
+    'InformationRegisterRecordManager', 'InformationRegisterRecordSet',
+    'ReportObject', 'TaskObject', 'TaskRef',
+}
+
+
+def localname(el):
+    return etree.QName(el.tag).localname
+
+
+def main():
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+    parser = argparse.ArgumentParser(description="Validate 1C managed form", allow_abbrev=False)
+    parser.add_argument("-FormPath", "-Path", required=True)
+    parser.add_argument("-Detailed", action="store_true")
+    parser.add_argument("-MaxErrors", type=int, default=30)
+    args = parser.parse_args()
+
+    form_path = args.FormPath
+    detailed = args.Detailed
+    max_errors = args.MaxErrors
+
+    if not os.path.isabs(form_path):
+        form_path = os.path.join(os.getcwd(), form_path)
+
+    # A: Directory → Ext/Form.xml
+    if os.path.isdir(form_path):
+        form_path = os.path.join(form_path, 'Ext', 'Form.xml')
+    # B1: Missing Ext/ (e.g. Forms/Форма/Form.xml → Forms/Форма/Ext/Form.xml)
+    if not os.path.exists(form_path):
+        fn = os.path.basename(form_path)
+        if fn == 'Form.xml':
+            c = os.path.join(os.path.dirname(form_path), 'Ext', fn)
+            if os.path.exists(c):
+                form_path = c
+    # B2: Descriptor (Forms/Форма.xml → Forms/Форма/Ext/Form.xml)
+    if not os.path.exists(form_path) and form_path.endswith('.xml'):
+        stem = os.path.splitext(os.path.basename(form_path))[0]
+        parent = os.path.dirname(form_path)
+        c = os.path.join(parent, stem, 'Ext', 'Form.xml')
+        if os.path.exists(c):
+            form_path = c
+
+    if not os.path.isfile(form_path):
+        print(f"File not found: {form_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # --- Load XML ---
+    try:
+        xml_parser = etree.XMLParser(remove_blank_text=True)
+        tree = etree.parse(form_path, xml_parser)
+    except Exception as e:
+        print(f"[ERROR] XML parse error: {e}")
+        print()
+        print("---")
+        print("Errors: 1, Warnings: 0")
+        sys.exit(1)
+
+    root = tree.getroot()
+
+    # Detect context: config vs EPF/ERF
+    is_config_context = False
+    walk_dir = os.path.dirname(os.path.abspath(form_path))
+    for _ in range(15):
+        parent = os.path.dirname(walk_dir)
+        if parent == walk_dir:
+            break
+        if os.path.isfile(os.path.join(walk_dir, 'Configuration.xml')):
+            is_config_context = True
+            break
+        walk_dir = parent
+
+    errors = 0
+    warnings = 0
+    ok_count = 0
+    stopped = False
+    output_lines = []
+
+    def report_ok(msg):
+        nonlocal ok_count
+        ok_count += 1
+        if detailed:
+            output_lines.append(f"[OK]    {msg}")
+
+    def report_error(msg):
+        nonlocal errors, stopped
+        errors += 1
+        output_lines.append(f"[ERROR] {msg}")
+        if errors >= max_errors:
+            stopped = True
+
+    def report_warn(msg):
+        nonlocal warnings
+        warnings += 1
+        output_lines.append(f"[WARN]  {msg}")
+
+    # --- Form name from path ---
+    form_name = os.path.splitext(os.path.basename(form_path))[0]
+    parent_dir = os.path.dirname(form_path)
+    if parent_dir:
+        ext_dir = os.path.basename(parent_dir)
+        if ext_dir == "Ext":
+            form_dir = os.path.dirname(parent_dir)
+            if form_dir:
+                form_name = os.path.basename(form_dir)
+
+    output_lines.append(f"=== Validation: Form.{form_name} ===")
+    output_lines.append("")
+
+    # Early BaseForm detection
+    has_base_form = root.find(f"{{{F_NS}}}BaseForm") is not None
+
+    # --- Check 1: Root element and version ---
+    if localname(root) != "Form":
+        report_error(f"Root element is '{localname(root)}', expected 'Form'")
+    else:
+        version = root.get("version", "")
+        if version in ("2.17", "2.20"):
+            report_ok(f"Root element: Form version={version}")
+        elif version:
+            report_warn(f"Form version='{version}' (expected 2.17 or 2.20)")
+        else:
+            report_warn("Form version attribute missing")
+
+    # --- Check 2: AutoCommandBar ---
+    if not stopped:
+        acb = root.find(f"{{{F_NS}}}AutoCommandBar")
+        if acb is not None:
+            acb_name = acb.get("name", "")
+            acb_id = acb.get("id", "")
+            if acb_id == "-1":
+                report_ok(f"AutoCommandBar: name='{acb_name}', id={acb_id}")
+            else:
+                report_error(f"AutoCommandBar id='{acb_id}', expected '-1'")
+        else:
+            report_error("AutoCommandBar element missing")
+
+    # --- Collect all elements with IDs ---
+    element_ids = {}  # id -> name
+    all_elements = []  # list of dicts {Name, Tag, Id, ParentName, Node}
+
+    def collect_elements(node, parent_name):
+        nonlocal stopped
+        for child in node:
+            if not isinstance(child.tag, str):
+                continue
+
+            name = child.get("name", "")
+            eid = child.get("id", "")
+
+            if name and eid:
+                tag = localname(child)
+
+                all_elements.append({
+                    "Name": name,
+                    "Tag": tag,
+                    "Id": eid,
+                    "ParentName": parent_name,
+                    "Node": child,
+                })
+
+                if eid != "-1":
+                    if eid in element_ids:
+                        report_error(f"Duplicate element id={eid}: '{name}' and '{element_ids[eid]}'")
+                    else:
+                        element_ids[eid] = name
+
+                child_items = child.find(f"{{{F_NS}}}ChildItems")
+                if child_items is not None:
+                    collect_elements(child_items, name)
+
+    child_items_root = root.find(f"{{{F_NS}}}ChildItems")
+    if child_items_root is not None:
+        collect_elements(child_items_root, "(root)")
+
+    acb = root.find(f"{{{F_NS}}}AutoCommandBar")
+    if acb is not None:
+        acb_children = acb.find(f"{{{F_NS}}}ChildItems")
+        if acb_children is not None:
+            collect_elements(acb_children, "\u0424\u043e\u0440\u043c\u0430\u041a\u043e\u043c\u0430\u043d\u0434\u043d\u0430\u044f\u041f\u0430\u043d\u0435\u043b\u044c")
+
+    # --- Check 3: Unique element IDs ---
+    if not stopped:
+        # Duplicates already reported during collection
+        dup_count = 0
+        id_counts = {}
+        for el in all_elements:
+            eid = el["Id"]
+            if eid == "-1":
+                continue
+            id_counts[eid] = id_counts.get(eid, 0) + 1
+        dup_count = sum(1 for v in id_counts.values() if v > 1)
+        if dup_count == 0:
+            report_ok(f"Unique element IDs: {len(element_ids)} elements")
+
+    # --- Collect attributes (separate ID pool) ---
+    attr_map = {}   # name -> node
+    attr_ids = {}   # id -> name
+
+    attr_nodes_parent = root.find(f"{{{F_NS}}}Attributes")
+    attr_nodes = []
+    if attr_nodes_parent is not None:
+        attr_nodes = attr_nodes_parent.findall(f"{{{F_NS}}}Attribute")
+
+    for attr in attr_nodes:
+        attr_name = attr.get("name", "")
+        attr_id = attr.get("id", "")
+        if attr_name:
+            attr_map[attr_name] = attr
+        if attr_id:
+            if attr_id in attr_ids:
+                report_error(f"Duplicate attribute id={attr_id}: '{attr_name}' and '{attr_ids[attr_id]}'")
+            else:
+                attr_ids[attr_id] = attr_name
+
+        # Column IDs uniqueness within parent
+        col_ids = {}
+        columns = attr.find(f"{{{F_NS}}}Columns")
+        if columns is not None:
+            for col in columns.findall(f"{{{F_NS}}}Column"):
+                col_id = col.get("id", "")
+                col_name = col.get("name", "")
+                if col_id:
+                    if col_id in col_ids:
+                        report_error(f"Duplicate column id={col_id} in '{attr_name}': '{col_name}' and '{col_ids[col_id]}'")
+                    else:
+                        col_ids[col_id] = col_name
+
+    if not stopped:
+        if attr_ids:
+            report_ok(f"Unique attribute IDs: {len(attr_ids)} entries")
+
+    # --- Collect commands (separate ID pool) ---
+    cmd_map = {}   # name -> node
+    cmd_ids = {}   # id -> name
+
+    cmd_nodes_parent = root.find(f"{{{F_NS}}}Commands")
+    cmd_nodes = []
+    if cmd_nodes_parent is not None:
+        cmd_nodes = cmd_nodes_parent.findall(f"{{{F_NS}}}Command")
+
+    for cmd in cmd_nodes:
+        cmd_name = cmd.get("name", "")
+        cmd_id = cmd.get("id", "")
+        if cmd_name:
+            cmd_map[cmd_name] = cmd
+        if cmd_id:
+            if cmd_id in cmd_ids:
+                report_error(f"Duplicate command id={cmd_id}: '{cmd_name}' and '{cmd_ids[cmd_id]}'")
+            else:
+                cmd_ids[cmd_id] = cmd_name
+
+    if not stopped:
+        if cmd_ids:
+            report_ok(f"Unique command IDs: {len(cmd_ids)} entries")
+
+    # --- Check 4: Companion elements ---
+    companion_rules = {
+        "InputField": ["ContextMenu", "ExtendedTooltip"],
+        "CheckBoxField": ["ContextMenu", "ExtendedTooltip"],
+        "LabelDecoration": ["ContextMenu", "ExtendedTooltip"],
+        "LabelField": ["ContextMenu", "ExtendedTooltip"],
+        "PictureDecoration": ["ContextMenu", "ExtendedTooltip"],
+        "PictureField": ["ContextMenu", "ExtendedTooltip"],
+        "CalendarField": ["ContextMenu", "ExtendedTooltip"],
+        "UsualGroup": ["ExtendedTooltip"],
+        "Pages": ["ExtendedTooltip"],
+        "Page": ["ExtendedTooltip"],
+        "Button": ["ExtendedTooltip"],
+        "Table": ["ContextMenu", "AutoCommandBar", "SearchStringAddition", "ViewStatusAddition", "SearchControlAddition"],
+    }
+
+    if not stopped:
+        companion_errors = 0
+        companion_checked = 0
+
+        for el in all_elements:
+            if stopped:
+                break
+            tag = el["Tag"]
+            el_name = el["Name"]
+            node = el["Node"]
+
+            if tag not in companion_rules:
+                continue
+
+            required = companion_rules[tag]
+            companion_checked += 1
+
+            for comp_tag in required:
+                comp_node = node.find(f"{{{F_NS}}}{comp_tag}")
+                if comp_node is None:
+                    report_error(f"[{tag}] '{el_name}': missing companion <{comp_tag}>")
+                    companion_errors += 1
+
+        if companion_errors == 0 and companion_checked > 0:
+            report_ok(f"Companion elements: {companion_checked} elements checked")
+
+    # --- Check 5: DataPath -> Attribute references ---
+    if not stopped:
+        path_errors = 0
+        path_checked = 0
+        path_base_skipped = 0
+
+        skip_tags = {"ContextMenu", "ExtendedTooltip", "AutoCommandBar", "SearchStringAddition", "ViewStatusAddition", "SearchControlAddition"}
+
+        for el in all_elements:
+            if stopped:
+                break
+            tag = el["Tag"]
+            el_name = el["Name"]
+            node = el["Node"]
+
+            if tag in skip_tags:
+                continue
+
+            if has_base_form and el["Id"]:
+                try:
+                    if int(el["Id"]) < 1000000:
+                        path_base_skipped += 1
+                        continue
+                except (ValueError, TypeError):
+                    pass
+
+            dp_node = node.find(f"{{{F_NS}}}DataPath")
+            if dp_node is None:
+                continue
+
+            data_path = (dp_node.text or "").strip()
+            if not data_path:
+                continue
+
+            # Opaque platform-internal DataPath shapes — not validatable from Form.xml alone:
+            #   - bare numeric (e.g. "10", "1000003") — internal index
+            #   - "N/M:<uuid>" — metadata reference by UUID
+            if re.match(r'^\d+$', data_path) or re.match(r'^\d+/\d+:[0-9a-fA-F-]+$', data_path):
+                continue
+
+            path_checked += 1
+
+            clean_path = re.sub(r'\[\d+\]', '', data_path)
+            # Strip leading '~' (current row of DynamicList: ~\u0421\u043f\u0438\u0441\u043e\u043a.\u041f\u043e\u043b\u0435)
+            if clean_path.startswith('~'):
+                clean_path = clean_path[1:]
+            segments = clean_path.split(".")
+            root_attr = segments[0]
+
+            # Resolve Items.<TableName>.CurrentData.<Field>... \u2014 table element, not attribute
+            if root_attr == 'Items':
+                if len(segments) < 3 or segments[2] != 'CurrentData':
+                    report_warn(f"[{tag}] '{el_name}': DataPath='{data_path}' \u2014 unknown Items.* shape, expected Items.<Table>.CurrentData.*")
+                    continue
+                table_name = segments[1]
+                table_el = None
+                for candidate in all_elements:
+                    if candidate["Tag"] == 'Table' and candidate["Name"] == table_name:
+                        table_el = candidate
+                        break
+                if table_el is None:
+                    report_error(f"[{tag}] '{el_name}': DataPath='{data_path}' \u2014 table element '{table_name}' not found")
+                    path_errors += 1
+                    continue
+                table_dp_node = table_el["Node"].find(f"{{{F_NS}}}DataPath")
+                if table_dp_node is None or not (table_dp_node.text or "").strip():
+                    continue
+                table_dp = re.sub(r'\[\d+\]', '', (table_dp_node.text or "").strip())
+                if table_dp.startswith('~'):
+                    table_dp = table_dp[1:]
+                root_attr = table_dp.split(".")[0]
+
+            if root_attr not in attr_map:
+                report_error(f"[{tag}] '{el_name}': DataPath='{data_path}' \u2014 attribute '{root_attr}' not found")
+                path_errors += 1
+
+        path_msg = ""
+        if path_checked > 0:
+            path_msg = f"{path_checked} paths checked"
+        if path_base_skipped > 0:
+            skip_note = f"{path_base_skipped} base skipped"
+            path_msg = f"{path_msg}, {skip_note}" if path_msg else skip_note
+        if path_errors == 0 and path_msg:
+            report_ok(f"DataPath references: {path_msg}")
+
+    # --- Check 6: Button command references ---
+    if not stopped:
+        cmd_errors = 0
+        cmd_checked = 0
+
+        for el in all_elements:
+            if stopped:
+                break
+            tag = el["Tag"]
+            el_name = el["Name"]
+            node = el["Node"]
+
+            if tag != "Button":
+                continue
+
+            cmd_node = node.find(f"{{{F_NS}}}CommandName")
+            if cmd_node is None:
+                continue
+
+            cmd_ref = (cmd_node.text or "").strip()
+            if not cmd_ref:
+                continue
+
+            m = re.match(r'^Form\.Command\.(.+)$', cmd_ref)
+            if m:
+                cmd_name_ref = m.group(1)
+                cmd_checked += 1
+                if cmd_name_ref not in cmd_map:
+                    report_error(f"[Button] '{el_name}': CommandName='{cmd_ref}' \u2014 command '{cmd_name_ref}' not found in Commands")
+                    cmd_errors += 1
+
+        if cmd_errors == 0 and cmd_checked > 0:
+            report_ok(f"Command references: {cmd_checked} buttons checked")
+
+    # --- Check 7: Events have handler names ---
+    if not stopped:
+        event_errors = 0
+        event_checked = 0
+
+        # Form-level events
+        form_events = root.find(f"{{{F_NS}}}Events")
+        if form_events is not None:
+            for evt in form_events.findall(f"{{{F_NS}}}Event"):
+                evt_name = evt.get("name", "")
+                handler = (evt.text or "").strip()
+                event_checked += 1
+                if not handler:
+                    report_error(f"Form event '{evt_name}': empty handler name")
+                    event_errors += 1
+
+        # Element-level events
+        for el in all_elements:
+            if stopped:
+                break
+            tag = el["Tag"]
+            el_name = el["Name"]
+            node = el["Node"]
+
+            events_node = node.find(f"{{{F_NS}}}Events")
+            if events_node is None:
+                continue
+
+            for evt in events_node.findall(f"{{{F_NS}}}Event"):
+                evt_name = evt.get("name", "")
+                handler = (evt.text or "").strip()
+                event_checked += 1
+                if not handler:
+                    report_error(f"[{tag}] '{el_name}' event '{evt_name}': empty handler name")
+                    event_errors += 1
+
+        if event_errors == 0 and event_checked > 0:
+            report_ok(f"Event handlers: {event_checked} events checked")
+
+    # --- Check 8: Command actions ---
+    if not stopped:
+        action_errors = 0
+        action_checked = 0
+
+        for cmd in cmd_nodes:
+            if stopped:
+                break
+            cmd_name = cmd.get("name", "")
+            action_node = cmd.find(f"{{{F_NS}}}Action")
+            action_checked += 1
+            if action_node is None or not (action_node.text or "").strip():
+                report_error(f"Command '{cmd_name}': missing or empty Action")
+                action_errors += 1
+
+        if action_errors == 0 and action_checked > 0:
+            report_ok(f"Command actions: {action_checked} commands checked")
+
+    # --- Check 9: MainAttribute count ---
+    if not stopped:
+        main_count = 0
+        for attr in attr_nodes:
+            main_node = attr.find(f"{{{F_NS}}}MainAttribute")
+            if main_node is not None and (main_node.text or "") == "true":
+                main_count += 1
+
+        if main_count <= 1:
+            main_info = "1 main attribute" if main_count == 1 else "no main attribute"
+            report_ok(f"MainAttribute: {main_info}")
+        else:
+            report_error(f"Multiple MainAttribute=true ({main_count} found, expected 0 or 1)")
+
+    # --- Check 10: Title must be multilingual XML ---
+    if not stopped:
+        title_node = root.find(f"{{{F_NS}}}Title")
+        if title_node is not None:
+            v8_items = title_node.findall(f"{{{V8_NS}}}item")
+            if len(v8_items) == 0 and (title_node.text or "").strip():
+                report_error(f"Form Title is plain text ('{(title_node.text or '').strip()}') \u2014 must be multilingual XML (<v8:item>). Use top-level 'title' key in form-compile DSL.")
+            else:
+                report_ok("Title: multilingual XML")
+
+    # --- Check 11: Extension-specific validations ---
+    base_form_node = root.find(f"{{{F_NS}}}BaseForm")
+    is_extension = base_form_node is not None
+
+    if not stopped and is_extension:
+        # 11a. BaseForm version
+        bf_version = base_form_node.get("version", "")
+        if bf_version:
+            report_ok(f"BaseForm: version={bf_version}")
+        else:
+            report_warn("BaseForm: version attribute missing")
+
+        # 11b. callType values validation
+        valid_call_types = {"Before", "After", "Override"}
+        ct_errors = 0
+        ct_checked = 0
+
+        form_events_node = root.find(f"{{{F_NS}}}Events")
+        if form_events_node is not None:
+            for evt in form_events_node.findall(f"{{{F_NS}}}Event"):
+                ct = evt.get("callType", "")
+                if ct:
+                    ct_checked += 1
+                    if ct not in valid_call_types:
+                        report_error(f"Form event '{evt.get('name', '')}': invalid callType='{ct}' (expected: Before, After, Override)")
+                        ct_errors += 1
+
+        for el in all_elements:
+            if stopped:
+                break
+            events_node = el["Node"].find(f"{{{F_NS}}}Events")
+            if events_node is None:
+                continue
+            for evt in events_node.findall(f"{{{F_NS}}}Event"):
+                ct = evt.get("callType", "")
+                if ct:
+                    ct_checked += 1
+                    if ct not in valid_call_types:
+                        report_error(f"[{el['Tag']}] '{el['Name']}' event '{evt.get('name', '')}': invalid callType='{ct}'")
+                        ct_errors += 1
+
+        for cmd in cmd_nodes:
+            if stopped:
+                break
+            cmd_name = cmd.get("name", "")
+            for action in cmd.findall(f"{{{F_NS}}}Action"):
+                ct = action.get("callType", "")
+                if ct:
+                    ct_checked += 1
+                    if ct not in valid_call_types:
+                        report_error(f"Command '{cmd_name}' Action: invalid callType='{ct}'")
+                        ct_errors += 1
+
+        if not stopped and ct_errors == 0 and ct_checked > 0:
+            report_ok(f"callType values: {ct_checked} checked")
+
+        # 11c. Extension ID ranges
+        base_attr_names = set()
+        base_cmd_names = set()
+
+        bf_attrs = base_form_node.find(f"{{{F_NS}}}Attributes")
+        if bf_attrs is not None:
+            for b_attr in bf_attrs.findall(f"{{{F_NS}}}Attribute"):
+                ba_name = b_attr.get("name", "")
+                if ba_name:
+                    base_attr_names.add(ba_name)
+
+        bf_cmds = base_form_node.find(f"{{{F_NS}}}Commands")
+        if bf_cmds is not None:
+            for b_cmd in bf_cmds.findall(f"{{{F_NS}}}Command"):
+                bc_name = b_cmd.get("name", "")
+                if bc_name:
+                    base_cmd_names.add(bc_name)
+
+        id_warn_count = 0
+        for attr in attr_nodes:
+            a_name = attr.get("name", "")
+            a_id = attr.get("id", "")
+            if a_name and a_name not in base_attr_names and a_id:
+                try:
+                    int_id = int(a_id)
+                    if int_id < 1000000:
+                        report_warn(f"Attribute '{a_name}' (id={a_id}): extension-added attribute has id < 1000000")
+                        id_warn_count += 1
+                except (ValueError, TypeError):
+                    pass
+
+        for cmd in cmd_nodes:
+            c_name = cmd.get("name", "")
+            c_id = cmd.get("id", "")
+            if c_name and c_name not in base_cmd_names and c_id:
+                try:
+                    int_id = int(c_id)
+                    if int_id < 1000000:
+                        report_warn(f"Command '{c_name}' (id={c_id}): extension-added command has id < 1000000")
+                        id_warn_count += 1
+                except (ValueError, TypeError):
+                    pass
+
+        if not stopped and id_warn_count == 0:
+            ext_attr_count = sum(1 for a in attr_nodes if a.get("name", "") not in base_attr_names)
+            ext_cmd_count = sum(1 for c in cmd_nodes if c.get("name", "") not in base_cmd_names)
+            if (ext_attr_count + ext_cmd_count) > 0:
+                report_ok(f"Extension ID ranges: {ext_attr_count} attr(s), {ext_cmd_count} cmd(s) \u2014 all >= 1000000")
+
+    # Check callType without BaseForm
+    if not stopped and not is_extension:
+        call_type_without_base = False
+        fe_node = root.find(f"{{{F_NS}}}Events")
+        if fe_node is not None:
+            for evt in fe_node.findall(f"{{{F_NS}}}Event"):
+                if evt.get("callType"):
+                    call_type_without_base = True
+                    break
+        if not call_type_without_base:
+            for cmd in cmd_nodes:
+                for action in cmd.findall(f"{{{F_NS}}}Action"):
+                    if action.get("callType"):
+                        call_type_without_base = True
+                        break
+                if call_type_without_base:
+                    break
+        if call_type_without_base:
+            report_warn("callType attributes found but no BaseForm \u2014 possible incorrect structure")
+
+    # --- Check 12: Type validation ---
+    if not stopped:
+        type_nodes = root.xpath('//v8:Type', namespaces={'v8': V8_NS})
+        type_error_count = 0
+        type_warn_count = 0
+        type_count = len(type_nodes)
+
+        for tn in type_nodes:
+            if stopped:
+                break
+            tv = (tn.text or "").strip()
+            if not tv:
+                continue
+
+            if tv in KNOWN_INVALID_TYPES:
+                report_error(f'12. Type "{tv}": invalid runtime/UI type (not valid in XDTO schema)')
+                type_error_count += 1
+            elif tv in VALID_CLOSED_TYPES:
+                pass  # OK
+            elif tv.startswith("cfg:"):
+                suffix = tv[4:]  # after "cfg:"
+                prefix = suffix.split(".")[0]
+                if prefix in VALID_CFG_PREFIXES or suffix == "DynamicList":
+                    # ExternalDataProcessorObject/ExternalReportObject valid only in EPF/ERF context
+                    if is_config_context and prefix in ('ExternalDataProcessorObject', 'ExternalReportObject'):
+                        report_error(f'12. Type "{tv}": External* type in configuration context (use DataProcessorObject/ReportObject instead)')
+                        type_invalid += 1
+                else:
+                    report_warn(f'12. Type "{tv}": unrecognized cfg prefix')
+                    type_warn_count += 1
+            elif ":" in tv:
+                pass  # unknown namespace, pass through
+            else:
+                report_warn(f'12. Type "{tv}": bare type without namespace prefix')
+                type_warn_count += 1
+
+        if type_error_count == 0 and type_warn_count == 0:
+            if type_count > 0:
+                report_ok(f'12. Types: {type_count} values, all valid')
+            else:
+                report_ok('12. Types: no type values to check')
+
+    # --- Finalize ---
+    checks = ok_count + errors + warnings
+    if errors == 0 and warnings == 0 and not detailed:
+        result = f"=== Validation OK: Form.{form_name} ({checks} checks) ==="
+    else:
+        output_lines.append("")
+        output_lines.append(f"=== Result: {errors} errors, {warnings} warnings ({checks} checks) ===")
+        result = "\n".join(output_lines)
+
+    print(result)
+
+    if errors > 0:
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()