@h2loop/autosar 0.0.0-stage → 1.0.1

package/python/ecuc_engine/rules/com.py

@@ -0,0 +1,107 @@
+"""COM I-PDU packing rules: signals inside the I-PDU, no overlapping signals."""
+from __future__ import annotations
+
+from typing import Optional
+
+from . import rule
+from ..values import parse_int
+
+TYPE_BITS = {"BOOLEAN": 1, "UINT8": 8, "SINT8": 8, "UINT16": 16, "SINT16": 16, "UINT32": 32, "SINT32": 32,
+             "UINT64": 64, "SINT64": 64, "FLOAT32": 32, "FLOAT64": 64}
+CITE_BOUNDS = "ECUC_Com_00259 ComBitPosition (position within the I-PDU), ECUC_Com_00158 ComBitSize, ECUC_EcuC_00003 PduLength"
+CITE_OVERLAP = "SWS_Com_CONSTR_00102 Signals Separated in I-PDU"
+
+
+def _size(ctx, s) -> Optional[int]:
+    bs = parse_int(ctx.text(s, "ComBitSize") or "")
+    if bs is not None:
+        return bs
+    typ = (ctx.text(s, "ComSignalType") or "").strip()
+    if typ in ("UINT8_N", "UINT8_DYN"):
+        n = parse_int(ctx.text(s, "ComSignalLength") or "")
+        return n * 8 if n is not None else None
+    return TYPE_BITS.get(typ)
+
+
+def bits(pos: int, size: int, endian: str) -> list:
+    """Occupied bit indices (byte*8 + bit). ComBitPosition is the LSB. BIG_ENDIAN (Motorola) walks
+    toward the MSB by going up within a byte, then to bit 0 of the previous byte."""
+    if endian == "BIG_ENDIAN":
+        out, b = [], pos
+        for _ in range(size):
+            out.append(b)
+            b = b + 1 if b % 8 != 7 else b - 15
+        return out
+    return list(range(pos, pos + size))  # LITTLE_ENDIAN and OPAQUE (bit0 of first byte, little-endian order)
+
+
+def _ipdus(ctx):
+    """(ipdu, length_bytes|None, [(member, kind)]) for every ComIPdu."""
+    for ipdu in ctx.containers("Com/ComConfig/ComIPdu"):
+        pdu = ctx.target(ctx.value(ipdu, "ComPduIdRef"))
+        length = parse_int(ctx.text(pdu, "PduLength") or "") if pdu is not None else None
+        members = []
+        for ref in ctx.values(ipdu, "ComIPduSignalRef"):
+            s = ctx.target(ref)
+            if s is not None:
+                members.append(s)
+        for ref in ctx.values(ipdu, "ComIPduSignalGroupRef"):
+            grp = ctx.target(ref)
+            if grp is None:
+                continue
+            members.extend(c for g in ctx.p.find(grp.path) for c in g.children
+                           if ctx.rel(c.def_ref).endswith("/ComGroupSignal"))
+            members.append(grp)  # contributes only its update bit
+        yield ipdu, length, pdu, members
+
+
+def _layout(ctx, s):
+    """[(label, bitset, line)] a signal/group occupies: its value bits and its update bit."""
+    out = []
+    pos = parse_int(ctx.text(s, "ComBitPosition") or "")
+    size = _size(ctx, s)
+    if pos is not None and size:
+        endian = (ctx.text(s, "ComSignalEndianness") or "LITTLE_ENDIAN").strip()
+        out.append((s.name, bits(pos, size, endian), ctx.value(s, "ComBitPosition").node.line, pos, size, endian))
+    ub = parse_int(ctx.text(s, "ComUpdateBitPosition") or "")
+    if ub is not None:
+        out.append((f"{s.name}.updateBit", [ub], ctx.value(s, "ComUpdateBitPosition").node.line, ub, 1, "LITTLE_ENDIAN"))
+    return out
+
+
+@rule("H2L-COM-001", "error", CITE_BOUNDS, "signal bits lie inside its I-PDU (PduLength * 8)")
+def signal_in_pdu(ctx):
+    for ipdu, length, pdu, members in _ipdus(ctx):
+        if length is None:
+            continue
+        limit = length * 8
+        for s in members:
+            for label, bs, line, pos, size, endian in _layout(ctx, s):
+                lo, hi = min(bs), max(bs)
+                if lo < 0 or hi >= limit:
+                    yield s, line, (f"{label}: ComBitPosition={pos} ComBitSize={size} ({endian}) occupies bits {lo}..{hi}, "
+                                    f"outside I-PDU {ipdu.name} ({pdu.path} PduLength={length} bytes = bits 0..{limit - 1})"), \
+                        (ctx.value(s, "ComBitPosition") or ctx.value(s, "ComUpdateBitPosition")).def_ref
+
+
+@rule("H2L-COM-002", "error", CITE_OVERLAP, "signals of one I-PDU do not overlap")
+def no_overlap(ctx):
+    for ipdu, length, pdu, members in _ipdus(ctx):
+        owner: dict = {}
+        reported = set()
+        for s in members:
+            for label, bs, line, pos, size, endian in _layout(ctx, s):
+                for b in bs:
+                    prev = owner.get(b)
+                    if prev is None:
+                        owner[b] = (label, s)
+                        continue
+                    if prev[0] == label:
+                        continue
+                    key = tuple(sorted((prev[0], label)))
+                    if key in reported:
+                        continue
+                    reported.add(key)
+                    yield s, line, (f"{label} overlaps {prev[0]} at bit {b} in I-PDU {ipdu.name} "
+                                    f"({label}: pos {pos} size {size} {endian})"), \
+                        (ctx.value(s, "ComBitPosition") or ctx.value(s, "ComUpdateBitPosition")).def_ref

package/python/ecuc_engine/rules/handles.py

@@ -0,0 +1,42 @@
+"""Handle-ID uniqueness (TPS_ECUConfiguration 3.4.1.1 "Handle ID concept")."""
+from __future__ import annotations
+
+import re
+
+from . import rule
+from ..values import parse_int
+
+# Handle-ID params by name when no defs say so; with defs, any SYMBOLIC-NAME-VALUE integer counts.
+NAME = re.compile(r"(HandleId|^CanIfTxPduId|^CanIfRxPduId)$")
+
+
+@rule("H2L-HID-001", "error",
+      "TPS_ECUConfiguration 3.4.1.1 Handle ID concept; ECUC_Com_00165/00175, ECUC_PduR_00322, ECUC_CanIf_00591/00597",
+      "handle IDs are unique per module and handle-ID parameter")
+def unique_handle_ids(ctx):
+    seen: dict = {}  # (module path, rel def) -> {value: [(elem, pv)]}
+    for path, group in ctx.p.by_path.items():
+        e = group[0]
+        if e.kind != "container":
+            continue
+        mod = ctx.module_of(e)
+        for g in group:
+            for pv in g.params:
+                if pv.is_ref or pv.value is None:
+                    continue
+                d = ctx.defs.get(pv.def_ref)
+                is_handle = (d.kind == "INTEGER" and d.symbolic_name) if d is not None else False
+                if not is_handle and not NAME.search(pv.name):
+                    continue
+                v = parse_int(pv.value)
+                if v is None:
+                    continue
+                key = (mod.path, ctx.rel(pv.def_ref))
+                seen.setdefault(key, {}).setdefault(v, []).append((g, pv))
+    for (mod, rel), by_val in seen.items():
+        for v, hits in by_val.items():
+            if len(hits) < 2:
+                continue
+            names = ", ".join(sorted({h[0].name for h in hits}))
+            for g, pv in hits:
+                yield g, pv.node.line, f"{pv.name}={v} is used by {len(hits)} containers in {mod} ({names}); handle IDs must be unique", pv.def_ref

package/python/ecuc_engine/validate.py

@@ -0,0 +1,263 @@
+"""Mechanical ECUC checks, derived from the param defs only (no hand-written module rules).
+
+Diagnostics are LSP-like: {file, line, path, rule, severity, message, defRef}.
+Rules:
+  ECUC-NO-DEF            module's definition is not among the loaded param defs (module skipped)
+  ECUC-UNKNOWN-DEF       container / parameter / reference whose DEFINITION-REF is not in the module def
+  ECUC-WRONG-PARENT      container's def is not a child of its parent's def
+  ECUC-DEST-MISMATCH     DEFINITION-REF DEST attribute differs from the def element type
+  ECUC-VALUE-TYPE        NUMERICAL vs TEXTUAL value element does not match the def kind
+  ECUC-MULT-CONTAINER    sub-container count outside the def multiplicity (incl. missing mandatory)
+  ECUC-CHOICE            choice container does not hold exactly one choice
+  ECUC-MULT-PARAM        parameter / reference count outside the def multiplicity
+  ECUC-MISSING-PARAM     mandatory parameter / reference absent
+  ECUC-TYPE / ECUC-RANGE / ECUC-ENUM / ECUC-STRING / ECUC-EMPTY-VALUE   value checks
+  ECUC-REF-DANGLING      reference target does not exist
+  ECUC-REF-DEST          reference target is of the wrong definition / metaclass
+  ECUC-REF-UNRESOLVED    foreign reference target not in any loaded file (warning)
+  ECUC-DUP-NAME          two containers with the same AUTOSAR path
+  ECUC-OBSOLETE          value for an obsolete def (warning)
+  H2L-FILTER-NOMATCH     a files/module filter matched nothing that was loaded (error, never a silent "clean")
+  H2L-DISCOVERY          discovery notes: hidden dir included, symlink cycle skipped, walk cap (info)
+Hand-written semantic rules (ecuc_engine/rules, ids H2L-*) run afterwards, with or without defs.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from . import defs as D
+from . import paths
+from .model import Project
+from .values import check_value, expected_value_tag
+
+GENERIC_CONTAINER_DESTS = {"ECUC-CONTAINER-DEF"}
+SEV_ORDER = {"error": 0, "warning": 1, "info": 2, "hint": 3}
+
+
+class Diags:
+    def __init__(self, project: Project):
+        self.p = project
+        self.items: list = []
+
+    def add(self, file, line, path, rule, severity, message, def_ref=None):
+        self.items.append({"file": self.p.rel(file), "line": line, "path": path, "rule": rule,
+                           "severity": severity, "message": message, "defRef": def_ref})
+
+
+def _same_def(defs: D.DefIndex, a: Optional[str], b: Optional[str]) -> bool:
+    if not a or not b:
+        return False
+    return a == b or defs.rel(a) == defs.rel(b)
+
+
+def _resolve_def(defs: D.DefIndex, ref: Optional[str]) -> Optional[D.DefNode]:
+    if not ref:
+        return None
+    d = defs.get(ref)
+    if d is not None:
+        return d
+    # vendor-relocated path (/Vendor/Com/... vs /AUTOSAR/EcucDefs/Com/...): match by module-relative path
+    rel = defs.rel(ref)
+    for m in defs.modules.values():
+        if rel.split("/", 1)[0] == m.name:
+            return defs.get(m.path + rel[len(m.name):])
+    return None
+
+
+def validate(project: Project, files: Optional[list] = None, module: Optional[str] = None) -> dict:
+    defs = project.defs
+    dg = Diags(project)
+    warned_modules = set()
+    visited = set()
+
+    def fmult(lo, up):
+        return f"{lo}..{'*' if up is None else up}"
+
+    def check_elem_group(path: str):
+        if path in visited:
+            return
+        visited.add(path)
+        group = project.find(path)
+        e0 = group[0]
+        if e0.kind == "container" and len(group) > 1:
+            for e in group[1:]:
+                dg.add(e.file, e.line, path, "ECUC-DUP-NAME", "error",
+                       f"duplicate container path {path} (also at {project.rel(e0.file)}:{e0.line})", e.def_ref)
+        d = _resolve_def(defs, e0.def_ref)
+        if d is None:
+            if e0.kind == "module":
+                key = e0.def_ref or path
+                if key not in warned_modules:
+                    warned_modules.add(key)
+                    dg.add(e0.file, e0.line, path, "ECUC-NO-DEF", "warning",
+                           f"no param def loaded for {e0.def_ref}; module not validated", e0.def_ref)
+            else:
+                dg.add(e0.file, e0.line, path, "ECUC-UNKNOWN-DEF", "error",
+                       f"container definition {e0.def_ref} does not exist in the loaded param defs", e0.def_ref)
+            return
+        if e0.def_dest and e0.def_dest != d.tag and not (e0.def_dest in GENERIC_CONTAINER_DESTS and d.is_container):
+            dg.add(e0.file, e0.line, path, "ECUC-DEST-MISMATCH", "warning",
+                   f"DEFINITION-REF DEST={e0.def_dest} but the def is {d.tag}", d.path)
+        if e0.kind == "container" and e0.parent is not None:
+            pd = _resolve_def(defs, e0.parent.def_ref)
+            if pd is not None and d.parent != pd.path:
+                dg.add(e0.file, e0.line, path, "ECUC-WRONG-PARENT", "error",
+                       f"{d.name} is not a sub-container of {pd.name} (allowed: "
+                       f"{', '.join(defs.by_path[c].name for c in pd.containers) or 'none'})", d.path)
+        if d.obsolete:
+            dg.add(e0.file, e0.line, path, "ECUC-OBSOLETE", "warning", f"{d.name} is obsolete", d.path)
+
+        # children (merged across split fragments)
+        children = [c for e in group for c in e.children]
+        params = [(e, pv) for e in group for pv in e.params]
+        counts: dict = {}
+        seen_child_paths = set()
+        for c in children:
+            if c.path in seen_child_paths:
+                continue
+            seen_child_paths.add(c.path)
+            cd = _resolve_def(defs, c.def_ref)
+            if cd is not None:
+                counts[cd.path] = counts.get(cd.path, 0) + 1
+        if d.tag == D.CHOICE_TAG:
+            n = sum(counts.get(c, 0) for c in d.containers)
+            if n != 1:
+                dg.add(e0.file, e0.line, path, "ECUC-CHOICE", "error",
+                       f"choice container {d.name} holds {n} choices, needs exactly 1 of "
+                       f"{', '.join(defs.by_path[c].name for c in d.containers)}", d.path)
+        else:
+            for cpath in d.containers:
+                cd = defs.by_path[cpath]
+                n = counts.get(cpath, 0)
+                if n < cd.lower or (cd.upper is not None and n > cd.upper):
+                    dg.add(e0.file, e0.line, path, "ECUC-MULT-CONTAINER", "error",
+                           f"{d.name} '{e0.name}': {cd.name} has {n} instance(s), def requires {fmult(cd.lower, cd.upper)}",
+                           cd.path)
+        pcounts: dict = {}
+        for e, pv in params:
+            pd = _resolve_def(defs, pv.def_ref)
+            line = pv.node.line
+            if pd is None or pd.parent != d.path:
+                dg.add(e.file, line, path, "ECUC-UNKNOWN-DEF", "error",
+                       f"parameter/reference {pv.def_ref} is not defined for {d.name}", pv.def_ref)
+                continue
+            pcounts[pd.path] = pcounts.get(pd.path, 0) + 1
+            if pd.obsolete:
+                dg.add(e.file, line, path, "ECUC-OBSOLETE", "warning", f"{pd.name} is obsolete", pd.path)
+            if pv.def_dest and pv.def_dest != pd.tag:
+                dg.add(e.file, line, path, "ECUC-DEST-MISMATCH", "warning",
+                       f"{pd.name}: DEFINITION-REF DEST={pv.def_dest} but the def is {pd.tag}", pd.path)
+            exp = expected_value_tag(pd)
+            if exp and pv.tag != exp:
+                dg.add(e.file, line, path, "ECUC-VALUE-TYPE", "warning",
+                       f"{pd.name} is a {pd.kind} def; value element should be {exp}, found {pv.tag}", pd.path)
+            if D.is_ref_kind(pd.kind or ""):
+                check_ref(e, pv, pd, path, line)
+            elif pd.kind != "ADD-INFO" and not pv.is_auto:
+                for rule, msg in check_value(pd, pv.value):
+                    sev = "warning" if rule == "ECUC-EMPTY-VALUE" else "error"
+                    dg.add(e.file, (pv.value_node or pv.node).line, path, rule, sev, f"{d.name} '{e0.name}': {msg}", pd.path)
+        for ppath in d.params + d.refs:
+            pd = defs.by_path[ppath]
+            n = pcounts.get(ppath, 0)
+            if n == 0 and pd.lower > 0:
+                dg.add(e0.file, e0.line, path, "ECUC-MISSING-PARAM", "error",
+                       f"{d.name} '{e0.name}': mandatory {pd.name} ({pd.kind}, {pd.mult}) is missing", pd.path)
+            elif n < pd.lower or (pd.upper is not None and n > pd.upper):
+                dg.add(e0.file, e0.line, path, "ECUC-MULT-PARAM", "error",
+                       f"{d.name} '{e0.name}': {pd.name} has {n} value(s), def requires {pd.mult}", pd.path)
+        for c in children:
+            check_elem_group(c.path)
+
+    def check_ref(e, pv, pd, path, line):
+        tgt = (pv.value or "").strip()
+        if pd.kind in ("INSTANCE-REFERENCE", "URI-REFERENCE"):
+            return
+        if not tgt:
+            dg.add(e.file, line, path, "ECUC-EMPTY-VALUE", "error", f"{pd.name}: empty reference", pd.path)
+            return
+        if pd.kind == "FOREIGN-REFERENCE":
+            hit = project.identifiables.get(tgt)
+            if hit is None:
+                if project.input_loaded:
+                    dg.add(e.file, line, path, "ECUC-REF-DANGLING", "error",
+                           f"{pd.name} -> {tgt}: target not found in any loaded ARXML", pd.path)
+                else:
+                    dg.add(e.file, line, path, "ECUC-REF-UNRESOLVED", "warning",
+                           f"{pd.name} -> {tgt}: target not in loaded files (add the System/SWC ARXML to "
+                           f"'input' in .hydron/autosar.json)", pd.path)
+                return
+            # DESTINATION-TYPE is often an abstract metaclass (RTE-EVENT for TIMING-EVENT), which needs the
+            # metamodel to check; the VALUE-REF DEST attribute must name the target's concrete type exactly.
+            if pv.dest and pv.dest != hit[0]:
+                dg.add(e.file, line, path, "ECUC-REF-DEST", "error",
+                       f"{pd.name} -> {tgt}: VALUE-REF DEST={pv.dest} but the target is a {hit[0]}", pd.path)
+            return
+        targets = project.find(tgt)
+        if not targets:
+            dg.add(e.file, line, path, "ECUC-REF-DANGLING", "error",
+                   f"{pd.name} -> {tgt}: no ECUC container with that path", pd.path)
+            return
+        t = targets[0]
+        if pd.dest_refs and not any(_same_def(defs, t.def_ref, dr) for dr in pd.dest_refs):
+            dg.add(e.file, line, path, "ECUC-REF-DEST", "error",
+                   f"{pd.name} -> {tgt} is a {t.def_ref.rsplit('/', 1)[-1] if t.def_ref else '?'}, def requires "
+                   f"{' or '.join(r.rsplit('/', 1)[-1] for r in pd.dest_refs)}", pd.path)
+
+    for m in project.modules:
+        if module and m.name != module and (m.def_ref or "").rsplit("/", 1)[-1] != module:
+            continue
+        check_elem_group(m.path)
+
+    from .rules import run_rules
+    dg.items.extend(run_rules(project))
+
+    items = dg.items
+    loaded = sorted(project.files)
+    by_file: dict = {}
+    for m in project.modules:
+        by_file.setdefault(project.rel(m.file), set()).add(m.name)
+    sample = ", ".join(project.rel(f) for f in loaded[:8]) + (f", … (+{len(loaded) - 8})" if len(loaded) > 8 else "")
+    scope: dict = {"root": project.root, "configFiles": len(loaded), "paramDefFiles": len(project.sources.defs),
+                   "inputFiles": len(project.sources.input)}
+    nomatch = []
+    if files:
+        matched, empty = paths.select(project.root, files, loaded)
+        for raw in empty:
+            nomatch.append(_nomatch(project, f"files filter {raw!r} matched none of the {len(loaded)} loaded config "
+                                             f"file(s) [{sample or 'none'}]; NOTHING was validated for it. Pass a file, "
+                                             f"directory or glob relative to {project.root}, or omit 'files'."))
+        want = {project.rel(f) for f in matched}
+        items = [i for i in items if i["file"] in want]
+        scope["filter"] = {"files": list(files), "matched": sorted(want)[:200], "matchedCount": len(want)}
+    if module:
+        names = {m.name for m in project.modules} | {(m.def_ref or "").rsplit("/", 1)[-1] for m in project.modules}
+        if module not in names:
+            nomatch.append(_nomatch(project, f"module filter {module!r} matches no loaded module "
+                                             f"({', '.join(sorted(names - {''})) or 'none loaded'}); NOTHING was validated."))
+        scope["module"] = module
+    info = [{"file": "", "line": 0, "path": "", "rule": "H2L-DISCOVERY", "severity": "info", "message": n, "defRef": None}
+            for n in project.sources.notes]
+    items = nomatch + items + info
+    shown = sorted(by_file.items())
+    scope["files"] = [{"file": f, "modules": sorted(ms)} for f, ms in shown[:100]]
+    if len(shown) > 100:
+        scope["filesTruncated"] = len(shown) - 100
+    items.sort(key=lambda i: (i["file"], i["line"], SEV_ORDER.get(i["severity"], 9), i["rule"]))
+    summary: dict = {}
+    for i in items:
+        summary[i["severity"]] = summary.get(i["severity"], 0) + 1
+    return {
+        "validated": bool(defs),
+        "rules": "semantic rule packs ran (H2L-*)",
+        "defsLoaded": len(defs.modules),
+        "modules": sorted({m.name for m in project.modules}),
+        "summary": summary,
+        "scope": scope,
+        "diagnostics": items,
+    }
+
+
+def _nomatch(project: Project, msg: str) -> dict:
+    return {"file": "", "line": 0, "path": project.root, "rule": "H2L-FILTER-NOMATCH", "severity": "error",
+            "message": msg, "defRef": None}

package/python/ecuc_engine/values.py

@@ -0,0 +1,146 @@
+"""Typed value checks and ECUC-JSON value rendering, driven by the param def."""
+from __future__ import annotations
+
+import math
+import re
+from typing import Optional
+
+from .defs import DefNode
+
+C_IDENT = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+BOOL_TRUE = {"true", "1"}
+BOOL_FALSE = {"false", "0"}
+JS_SAFE = 2 ** 53 - 1
+
+
+def parse_int(s: str) -> Optional[int]:
+    s = s.strip()
+    try:
+        return int(s, 0)
+    except ValueError:
+        try:
+            return int(s)  # leading zeros, e.g. "007"
+        except ValueError:
+            return None
+
+
+def parse_float(s: str) -> Optional[float]:
+    t = s.strip()
+    if t.upper() in ("INF", "+INF"):
+        return math.inf
+    if t.upper() == "-INF":
+        return -math.inf
+    try:
+        return float(t)
+    except ValueError:
+        iv = parse_int(t)
+        return float(iv) if iv is not None else None
+
+
+def _bound(s: Optional[str], f):
+    if s is None or s == "":
+        return None
+    return f(s)
+
+
+def check_value(d: DefNode, raw: Optional[str]) -> list:
+    """Return [(rule, message)] problems with ``raw`` against ``d``. Empty list = OK."""
+    if raw is None or raw == "":
+        return [("ECUC-EMPTY-VALUE", f"{d.name}: empty value")]
+    k = d.kind
+    out = []
+    if k == "INTEGER":
+        v = parse_int(raw)
+        if v is None:
+            return [("ECUC-TYPE", f"{d.name}: '{raw}' is not an integer")]
+        lo, hi = _bound(d.min, parse_int), _bound(d.max, parse_int)
+        if (lo is not None and v < lo) or (hi is not None and v > hi):
+            out.append(("ECUC-RANGE", f"{d.name}={raw} outside [{d.min}..{d.max}]"))
+    elif k == "FLOAT":
+        v = parse_float(raw)
+        if v is None or math.isnan(v):
+            return [("ECUC-TYPE", f"{d.name}: '{raw}' is not a float")]
+        lo, hi = _bound(d.min, parse_float), _bound(d.max, parse_float)
+        bad = (lo is not None and (v < lo or (d.min_open and v == lo))) or \
+              (hi is not None and (v > hi or (d.max_open and v == hi)))
+        if bad:
+            out.append(("ECUC-RANGE", f"{d.name}={raw} outside {'(' if d.min_open else '['}{d.min}..{d.max}{')' if d.max_open else ']'}"))
+    elif k == "BOOLEAN":
+        if raw.strip().lower() not in BOOL_TRUE | BOOL_FALSE:
+            out.append(("ECUC-TYPE", f"{d.name}: '{raw}' is not a boolean (true/false/1/0)"))
+    elif k == "ENUMERATION":
+        if d.literals and raw.strip() not in d.literals:
+            lits = ", ".join(d.literals[:20]) + (" …" if len(d.literals) > 20 else "")
+            out.append(("ECUC-ENUM", f"{d.name}: '{raw}' is not a literal of the def ({lits})"))
+    elif k in ("STRING", "FUNCTION-NAME", "LINKER-SYMBOL", "MULTILINE-STRING"):
+        if d.min_len is not None and len(raw) < d.min_len:
+            out.append(("ECUC-STRING", f"{d.name}: length {len(raw)} < min {d.min_len}"))
+        if d.max_len is not None and len(raw) > d.max_len:
+            out.append(("ECUC-STRING", f"{d.name}: length {len(raw)} > max {d.max_len}"))
+        if k in ("FUNCTION-NAME", "LINKER-SYMBOL") and not C_IDENT.match(raw.strip()):
+            out.append(("ECUC-STRING", f"{d.name}: '{raw}' is not a valid C identifier"))
+        if d.regex:
+            try:
+                if not re.fullmatch(d.regex, raw):
+                    out.append(("ECUC-STRING", f"{d.name}: '{raw}' does not match /{d.regex}/"))
+            except re.error:
+                pass
+    return out
+
+
+def expected_value_tag(d: DefNode) -> Optional[str]:
+    k = d.kind or ""
+    if k in ("INTEGER", "FLOAT", "BOOLEAN"):
+        return "ECUC-NUMERICAL-PARAM-VALUE"
+    if k in ("ENUMERATION", "STRING", "FUNCTION-NAME", "LINKER-SYMBOL", "MULTILINE-STRING"):
+        return "ECUC-TEXTUAL-PARAM-VALUE"
+    if k == "ADD-INFO":
+        return "ECUC-ADD-INFO-PARAM-VALUE"
+    if k == "INSTANCE-REFERENCE":
+        return "ECUC-INSTANCE-REFERENCE-VALUE"
+    if k.endswith("REFERENCE"):
+        return "ECUC-REFERENCE-VALUE"
+    return None
+
+
+def to_json(d: Optional[DefNode], raw: Optional[str], is_ref: bool, numerical: bool):
+    """Raw ARXML text -> compact JSON value (int/float/bool/str, refs as '->/path')."""
+    if raw is None:
+        return None
+    if is_ref:
+        return "->" + raw if raw.startswith("/") else raw
+    k = d.kind if d is not None else ("NUMBER" if numerical else None)
+    t = raw.strip()
+    if k == "BOOLEAN" or (k == "NUMBER" and t.lower() in ("true", "false")):
+        lo = t.lower()
+        return True if lo in BOOL_TRUE else False if lo in BOOL_FALSE else raw
+    if k in ("INTEGER", "NUMBER"):
+        v = parse_int(t)
+        if v is not None:
+            return v if abs(v) <= JS_SAFE and t == str(v) else t  # keep hex / huge as text
+        if k == "INTEGER":
+            return raw
+    if k in ("FLOAT", "NUMBER"):
+        v = parse_float(t)
+        if v is not None and math.isfinite(v):
+            return v
+        return raw
+    return raw
+
+
+def from_json(d: Optional[DefNode], v) -> str:
+    """JSON value from an edit op -> ARXML text."""
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, (int, float)):
+        if isinstance(v, float) and v.is_integer() and d is not None and d.kind == "FLOAT":
+            return repr(v)
+        return str(v)
+    if v is None:
+        raise ValueError("null is not a value; use op 'remove' to delete a parameter")
+    s = str(v)
+    if s.startswith("->"):
+        s = s[2:]
+    if d is not None and d.kind == "BOOLEAN" and s.lower() in ("true", "false"):
+        s = s.lower()
+    return s