crosspad-mcp-server 9.1.1 → 9.2.0

package/tracer/swd_tracer.py

@@ -695,6 +695,328 @@ def _expand_spec(spec, table):
     specs = [_spec_name(base, p) for p in parts_lists]
     return specs, len(specs)
 
+# Raw absolute-address spec (PROTOCOL §1.2): read MCU memory straight by address
+# with no DWARF symbol — for peripheral registers / arbitrary RAM. Because there
+# is no type to infer size/encoding from, the type tag is explicit (default u32).
+#   @0x40021000          -> u32 at 0x40021000
+#   @0x40021000:u16      -> u8|u16|u32 / i8|i16|i32 / f32
+#   @0x20000000:u8[16]   -> 16 consecutive elements (expands like an array)
+_RAW_RE = re.compile(
+    r"^@(0[xX][0-9A-Fa-f]+|\d+)"        # 1: address (hex 0x… or decimal)
+    r"(?::([uif](?:8|16|32)))?"          # 2: optional type tag
+    r"(?:\[(\d+)\])?$")                  # 3: optional element count
+_RAW_TYPE = {
+    "u8": ("uint", 1), "u16": ("uint", 2), "u32": ("uint", 4),
+    "i8": ("int", 1),  "i16": ("int", 2),  "i32": ("int", 4),
+    "f32": ("float", 4),
+}
+
+def _resolve_raw(spec):
+    """Resolve a raw @address spec.
+
+    Returns None when `spec` is not a raw spec at all (no leading '@'), so the
+    caller falls through to DWARF symbol resolution.  Otherwise returns
+    {"n": count, "elems": [{name,address,size,encoding}, ...]} — a malformed raw
+    spec yields n=0/elems=[] (reported unresolved by the caller).
+    """
+    if not spec.startswith("@"):
+        return None
+    m = _RAW_RE.match(spec)
+    if not m:
+        return {"n": 0, "elems": []}  # looks raw but malformed
+    addr = int(m.group(1), 0)
+    tname = m.group(2) or "u32"
+    enc, size = _RAW_TYPE[tname]
+    count = int(m.group(3)) if m.group(3) else 1
+    elems = []
+    for i in range(count):
+        a = addr + i * size
+        # Single element keeps the user's spec verbatim as its name; an expanded
+        # block re-renders each element's concrete address so names stay unique.
+        nm = spec if count == 1 else "@0x%X:%s" % (a, tname)
+        elems.append({"name": nm, "address": a, "size": size, "encoding": enc})
+    return {"n": count, "elems": elems}
+
+def _split_transform(spec):
+    """Peel a trailing bit/mask transform suffix (#... or &...) off a spec.
+
+    Base specs never contain '#' or '&', so the earliest occurrence of either
+    starts the suffix. Returns (base, suffix) with the sigil kept on the suffix,
+    or (spec, None) when there is no transform.
+    """
+    idxs = [i for i in (spec.find("#"), spec.find("&")) if i >= 0]
+    if not idxs:
+        return spec, None
+    i = min(idxs)
+    return spec[:i], spec[i:]
+
+def _parse_transform(suffix, size):
+    """Validate a transform suffix against the base byte size; return a transform
+    dict or None. bits = size*8. '#N' bit, '#hi:lo' range (inclusive, hi>=lo),
+    '&0xMASK' mask (normalized to the lowest set bit)."""
+    bits = size * 8
+    if suffix.startswith("#"):
+        body = suffix[1:]
+        if ":" in body:
+            parts = body.split(":")
+            if len(parts) != 2:
+                return None
+            try:
+                hi, lo = int(parts[0]), int(parts[1])
+            except ValueError:
+                return None
+            if lo < 0 or hi < lo or hi >= bits:
+                return None
+            return {"kind": "range", "hi": hi, "lo": lo}
+        try:
+            n = int(body)
+        except ValueError:
+            return None
+        if n < 0 or n >= bits:
+            return None
+        return {"kind": "bit", "n": n}
+    if suffix.startswith("&"):
+        try:
+            mask = int(suffix[1:], 0)
+        except ValueError:
+            return None
+        if mask <= 0 or mask >= (1 << bits):
+            return None
+        shift = (mask & -mask).bit_length() - 1  # ffs: index of lowest set bit
+        return {"kind": "mask", "mask": mask, "shift": shift}
+    return None
+
+def _parse_value(text, encoding, size):
+    """Parse the RHS literal per the target encoding. int: hex 0x.. or decimal
+    (range-checked to the byte size, two's-complement for signed); float: f32."""
+    text = text.strip()
+    if encoding == "float":
+        return float(text)
+    v = int(text, 0)  # 0x.. hex or decimal
+    bits = size * 8
+    if encoding in ("int", "char"):
+        lo, hi = -(1 << (bits - 1)), (1 << (bits - 1)) - 1
+        if not (lo <= v <= hi):
+            raise ValueError("value out of range for i%d" % bits)
+        if v < 0:
+            v &= (1 << bits) - 1  # store two's-complement
+    else:
+        if not (0 <= v < (1 << bits)):
+            raise ValueError("value out of range for u%d" % bits)
+    return v
+
+def _parse_write_spec(spec, table):
+    """'target=value' -> resolved write descriptor (see Interfaces)."""
+    if "=" not in spec:
+        return {"ok": False, "spec": spec, "error": "missing '=' (use target=value)"}
+    left, right = spec.split("=", 1)
+    left, right = left.strip(), right.strip()
+    # Transforms (#bit / &mask) are read-only, not supported on write targets.
+    base, suffix = _split_transform(left)
+    if suffix is not None:
+        return {"ok": False, "spec": spec,
+                "error": "transforms (#bit / &mask) are read-only, not supported on write targets"}
+    # Resolve the LHS address/size/encoding using the read resolvers.
+    raw = _resolve_raw(left)
+    if raw is not None:
+        if raw["n"] != 1:
+            return {"ok": False, "spec": spec,
+                    "error": "block write unsupported; write one element"}
+        d = raw["elems"][0]
+    else:
+        d = _resolve_spec(left, table)
+        if not d:
+            return {"ok": False, "spec": spec, "error": "unknown target: %s" % left}
+    try:
+        val = _parse_value(right, d["encoding"], d["size"])
+    except ValueError as e:
+        return {"ok": False, "spec": spec, "error": str(e)}
+    return {"ok": True, "name": left, "address": d["address"],
+            "size": d["size"], "encoding": d["encoding"], "value": val}
+
+# Cortex-M architectural memory map (ARMv6/7/8-M) — identical across STM32 series.
+_SRAM = (0x20000000, 0x3FFFFFFF)
+_ARCH_REGIONS = [
+    _SRAM,                       # SRAM
+    (0x40000000, 0x5FFFFFFF),    # Peripheral + IOPORT
+    (0xE0000000, 0xE00FFFFF),    # PPB / SCS (NVIC, SCB, DWT...)
+]
+
+def _check_allowed(addr, size, ram_regions=None):
+    """Return None if [addr, addr+size) is a permitted write target, else an
+    error string. Code region 0x0..0x1FFFFFFF (flash/system/option) is blocked."""
+    if size not in (1, 2, 4):
+        return "bad access size %r" % size
+    if addr % size != 0:
+        return "0x%08X not %d-byte aligned" % (addr, size)
+    end = addr + size - 1
+    for lo, hi in _ARCH_REGIONS:
+        if lo <= addr and end <= hi:
+            # SRAM refinement: if pack RAM regions are known, require containment.
+            if (lo, hi) == _SRAM and ram_regions:
+                if not any(rl <= addr and end <= rh for rl, rh in ram_regions):
+                    return "0x%08X outside mapped SRAM" % addr
+            return None
+    return "0x%08X outside write allowlist (Code region / unmapped is blocked)" % addr
+
+def _ram_regions_from(session):
+    """Best-effort (lo,hi) inclusive RAM ranges from the pyOCD memory map; None if
+    the (generic) target exposes none."""
+    try:
+        mm = session.target.get_memory_map()
+        rams = [(r.start, r.end) for r in mm if r.type.name.lower() == "ram"]
+        return rams or None
+    except Exception:
+        return None
+
+_WSIZE = {1: "write8", 2: "write16", 4: "write32"}
+_RSIZE = {1: "read8", 2: "read16", 4: "read32"}
+
+def do_write(target, descriptors, ram_regions):
+    """Apply each resolved write non-halting; read-back old/new for confirmation."""
+    out = []
+    for d in descriptors:
+        if not d.get("ok"):
+            out.append({"name": d.get("name", d.get("spec")), "ok": False,
+                        "error": d["error"]})
+            continue
+        addr, size = d["address"], d["size"]
+        guard = _check_allowed(addr, size, ram_regions)
+        if guard:
+            out.append({"name": d["name"], "address": addr, "size": size,
+                        "ok": False, "error": "write blocked: " + guard})
+            continue
+        try:
+            old = getattr(target, _RSIZE[size])(addr)
+            getattr(target, _WSIZE[size])(addr, d["value"] & ((1 << (size * 8)) - 1))
+            new = getattr(target, _RSIZE[size])(addr)
+            out.append({"name": d["name"], "address": addr, "size": size,
+                        "ok": True, "old": old, "new": new})
+        except Exception as e:
+            out.append({"name": d["name"], "address": addr, "size": size,
+                        "ok": False, "error": str(e)})
+    return out
+
+def cmd_write(args):
+    specs = [s for s in args.writes.split(";") if s.strip()]
+    try:
+        table = build_symbol_table(args.elf)
+    except Exception as e:
+        print(json.dumps({"type": "error", "error": "ELF/DWARF error: %s" % e}), flush=True)
+        return
+    descriptors = [_parse_write_spec(s, table) for s in specs]
+    session, cerr, _ = _try_open_session(args.probe, args.target, args.connect_timeout)
+    if session is None:
+        print(json.dumps({"type": "write_result", "ok": False, "error": cerr,
+                          "results": []}), flush=True)
+        return
+    try:
+        results = do_write(session.target, descriptors, _ram_regions_from(session))
+    finally:
+        try: session.close()
+        except Exception: pass
+    print(json.dumps({"type": "write_result",
+                      "ok": all(r["ok"] for r in results) if results else False,
+                      "results": results}), flush=True)
+
+def _resolve_func(elf_path, name):
+    """Entry address of a function symbol from the ELF .symtab (STT_FUNC)."""
+    from elftools.elf.elffile import ELFFile
+    with open(elf_path, "rb") as f:
+        elf = ELFFile(f)
+        symtab = elf.get_section_by_name(".symtab")
+        if symtab is None:
+            return None
+        for sym in symtab.iter_symbols():
+            if sym.name == name and sym["st_info"]["type"] == "STT_FUNC":
+                return sym["st_value"] & ~1  # clear Thumb bit
+    return None
+
+_CALL_CTX = ["r0","r1","r2","r3","r4","r5","r6","r7","r8","r9","r10","r11","r12",
+             "sp","lr","pc","xpsr","primask"]
+
+def do_call(target, entry, args, ret_type, timeout_s):
+    """AAPCS function-call thunk. Halts the core, runs func(args), restores full
+    context, resumes. Returns {ok,r0,decoded?} or {ok:False,error}."""
+    from pyocd.core.target import Target
+    if len(args) > 4:
+        return {"ok": False, "error": "max 4 args (r0-r3); got %d" % len(args)}
+    saved = {}
+    trap = None
+    try:
+        target.halt()
+        for r in _CALL_CTX:
+            saved[r] = target.read_core_register(r)
+        # Return trap = reset-handler entry from the ACTIVE vector table (VTOR),
+        # so the call thunk is MCU-agnostic (not tied to the STM32 flash alias at
+        # 0x08000000). VTOR low bits are reserved/zero; mask for safe alignment.
+        # VTOR=0 after reset aliases the table at 0x00000000.
+        vtor = target.read32(0xE000ED08) & 0xFFFFFF00
+        trap = target.read32(vtor + 4) & ~1
+        target.set_breakpoint(trap, Target.BreakpointType.HW)
+        for i, a in enumerate(args):
+            target.write_core_register("r%d" % i, a & 0xFFFFFFFF)
+        target.write_core_register("primask", 1)          # mask ISRs during thunk
+        target.write_core_register("lr", trap | 1)        # Thumb return
+        target.write_core_register("pc", entry)
+        xpsr = saved["xpsr"] | (1 << 24)                  # ensure Thumb (T) bit
+        target.write_core_register("xpsr", xpsr)
+        target.resume()
+        deadline = time.monotonic() + timeout_s
+        while time.monotonic() < deadline:
+            if target.get_state() == Target.State.HALTED:
+                break
+            time.sleep(0.002)
+        else:
+            target.halt()
+            return {"ok": False, "error":
+                    "call timed out after %gms (function did not return)" % (timeout_s * 1000)}
+        r0 = target.read_core_register("r0")
+        res = {"ok": True, "r0": r0}
+        if ret_type and ret_type != "u32":
+            res["decoded"] = _decode(r0.to_bytes(4, "little"), 0, *_RAW_TYPE[ret_type])
+        return res
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+    finally:
+        try:
+            if trap is not None:
+                target.remove_breakpoint(trap)
+        except Exception:
+            pass
+        for r, v in saved.items():
+            try:
+                target.write_core_register(r, v)          # full context restore
+            except Exception:
+                pass
+        try:
+            target.resume()                               # firmware continues pre-call
+        except Exception:
+            pass
+
+def cmd_call(args):
+    if not args.confirm:
+        print(json.dumps({"type": "call_result", "ok": False,
+                          "error": "call requires --confirm"}), flush=True)
+        return
+    entry = _resolve_func(args.elf, args.func_name)
+    if entry is None:
+        print(json.dumps({"type": "call_result", "ok": False,
+                          "error": "unknown function: %s" % args.func_name}), flush=True)
+        return
+    argv = [int(a, 0) for a in args.args.split(",") if a.strip()] if args.args else []
+    session, cerr, _ = _try_open_session(args.probe, args.target, args.connect_timeout)
+    if session is None:
+        print(json.dumps({"type": "call_result", "ok": False, "error": cerr}), flush=True)
+        return
+    try:
+        res = do_call(session.target, entry, argv, args.ret_type, args.timeout)
+    finally:
+        try: session.close()
+        except Exception: pass
+    res["type"] = "call_result"
+    print(json.dumps(res), flush=True)
+
 def _resolve_specs(specs, table):
     """Resolve a list of specs, applying §1.1 array/vector/matrix expansion.
 
@@ -708,22 +1030,55 @@ def _resolve_specs(specs, table):
     """
     resolved, unresolved = [], []
     for spec in specs:
-        elems, n = _expand_spec(spec, table)
+        base, suffix = _split_transform(spec)
+        # §1.2: raw @address specs bypass DWARF entirely.
+        raw = _resolve_raw(base)
+        if raw is not None:
+            if raw["n"] > EXPAND_CAP:
+                unresolved.append("%s (expands to %d > %d)" % (spec, raw["n"], EXPAND_CAP))
+            elif not raw["elems"]:
+                unresolved.append(spec)
+            elif suffix is not None:
+                if raw["n"] != 1:
+                    unresolved.append("%s (transform on expanding spec unsupported)" % spec)
+                else:
+                    t = _parse_transform(suffix, raw["elems"][0]["size"])
+                    if t is None:
+                        unresolved.append(spec)
+                    else:
+                        e = dict(raw["elems"][0]); e["transform"] = t; e["name"] = spec
+                        resolved.append(e)
+            else:
+                resolved.extend(raw["elems"])
+            continue
+        elems, n = _expand_spec(base, table)
         if n > EXPAND_CAP:
             unresolved.append("%s (expands to %d > %d)" % (spec, n, EXPAND_CAP))
             continue
         if elems:
-            # Expanded (possibly to a single concrete element). Resolve each;
-            # any element that fails to resolve is silently dropped (the spec as
-            # a whole produced concrete names, so it isn't "unresolved").
+            if suffix is not None and n != 1:
+                unresolved.append("%s (transform on expanding spec unsupported)" % spec)
+                continue
             for e in elems:
                 r = _resolve_spec(e, table)
-                if r:
-                    resolved.append(r)
+                if not r:
+                    continue
+                if suffix is not None:
+                    t = _parse_transform(suffix, r["size"])
+                    if t is None:
+                        unresolved.append(spec); continue
+                    r = dict(r); r["transform"] = t; r["name"] = spec
+                resolved.append(r)
             continue
         # Not expandable — try as a plain concrete scalar spec.
-        r = _resolve_spec(spec, table)
+        r = _resolve_spec(base, table)
         if r:
+            if suffix is not None:
+                t = _parse_transform(suffix, r["size"])
+                if t is None:
+                    unresolved.append(spec)
+                    continue
+                r = dict(r); r["transform"] = t; r["name"] = spec
             resolved.append(r)
         else:
             unresolved.append(spec)
@@ -750,7 +1105,8 @@ def _resolve_type_from(die, cu):
     return "uint", (bs.value if bs else 4)
 
 def _coalesce(sigs):
-    """sigs: list of {name,address,size,encoding}. Returns [(start,length,[(name,off,size,enc)])]."""
+    """sigs: list of {name,address,size,encoding,transform?}.
+    Returns [(start,length,[(name,off,size,enc,transform)])]."""
     items = sorted(sigs, key=lambda s: s["address"])
     ranges = []
     for s in items:
@@ -758,9 +1114,10 @@ def _coalesce(sigs):
         if ranges and a <= ranges[-1][0] + ranges[-1][1] + 4:  # merge if within 4 bytes of prev end
             start, length, members = ranges[-1]
             new_end = max(start + length, a + ln)
-            ranges[-1] = (start, new_end - start, members + [(s["name"], a - start, ln, s["encoding"])])
+            ranges[-1] = (start, new_end - start,
+                          members + [(s["name"], a - start, ln, s["encoding"], s.get("transform"))])
         else:
-            ranges.append((a, ln, [(s["name"], 0, ln, s["encoding"])]))
+            ranges.append((a, ln, [(s["name"], 0, ln, s["encoding"], s.get("transform"))]))
     return ranges
 
 def _decode(buf, off, size, enc):
@@ -772,6 +1129,20 @@ def _decode(buf, off, size, enc):
     signed = enc in ("int", "char")
     return int.from_bytes(raw, "little", signed=signed)
 
+def _apply_transform(value, size, transform):
+    """Apply a bit/range/mask transform to a decoded value. The value is
+    reinterpreted UNSIGNED (masked to size*8 bits) so a signed encoding does not
+    corrupt bit extraction."""
+    u = value & ((1 << (size * 8)) - 1)
+    kind = transform["kind"]
+    if kind == "bit":
+        return (u >> transform["n"]) & 1
+    if kind == "range":
+        lo, hi = transform["lo"], transform["hi"]
+        return (u >> lo) & ((1 << (hi - lo + 1)) - 1)
+    # mask
+    return (u & transform["mask"]) >> transform["shift"]
+
 def cmd_trace(args):
     names = [n for n in args.signals.split(",") if n]
     # §11.3 ELF / DWARF guard: a bad/missing ELF must surface as an error frame,
@@ -798,6 +1169,8 @@ def cmd_trace(args):
     sigset = {s["name"]: s for s in resolved}
     state = {"dirty": True, "ranges": _coalesce(list(sigset.values())),
              "unresolved": initial_unresolved, "signals": list(sigset.values())}
+    pending_cmds = []          # list of dict msgs from stdin (write/call), drained in loop
+    cmd_lock = threading.Lock()
 
     def _signals_frame():
         """Build the {"type":"signals",...} frame from the current poll set."""
@@ -874,6 +1247,12 @@ def cmd_trace(args):
                 sigs = msg.get("signals")
                 if isinstance(sigs, list):
                     _apply_remove([s for s in sigs if isinstance(s, str)])
+            elif cmd == "write" and isinstance(msg.get("writes"), list):
+                with cmd_lock:
+                    pending_cmds.append(msg)
+            elif cmd == "call":
+                with cmd_lock:
+                    pending_cmds.append(msg)
     threading.Thread(target=stdin_reader, daemon=True).start()
 
     log(f"connecting probe (serial={args.probe or 'auto'}, target={args.target}, "
@@ -895,6 +1274,7 @@ def cmd_trace(args):
         os._exit(3 if "no debug probe" in cerr else 1)
 
     target = session.target
+    ram_regions = _ram_regions_from(session)
     log("connected; polling (non-halting)")
     # §11.2 persistent-fault tracking: a single read fault = stop_suspected, but
     # faults lasting longer than --lost-timeout mean the probe/target is gone.
@@ -919,6 +1299,39 @@ def cmd_trace(args):
                     state["ranges"] = _coalesce(list(state["signals"]))
                     state["dirty"] = False
                 print(json.dumps(_signals_frame()), flush=True)
+            drained = []
+            with cmd_lock:
+                if pending_cmds:
+                    drained = pending_cmds[:]; pending_cmds.clear()
+            for msg in drained:
+                rid = msg.get("id")
+                kind = "write_result" if msg.get("cmd") == "write" else "call_result"
+                try:
+                    if msg.get("cmd") == "write":
+                        descs = [_parse_write_spec(s, table)
+                                 for s in msg["writes"] if isinstance(s, str)]
+                        results = do_write(target, descs, ram_regions)
+                        print(json.dumps({"type": "write_result", "id": rid,
+                            "ok": all(r["ok"] for r in results) if results else False,
+                            "results": results}), flush=True)
+                    else:  # call
+                        if not msg.get("confirm"):
+                            print(json.dumps({"type": "call_result", "id": rid,
+                                "ok": False, "error": "call requires confirm:true"}), flush=True)
+                            continue
+                        entry = _resolve_func(args.elf, msg.get("func", ""))
+                        if entry is None:
+                            print(json.dumps({"type": "call_result", "id": rid, "ok": False,
+                                "error": "unknown function: %s" % msg.get("func")}), flush=True)
+                            continue
+                        res = do_call(target, entry,
+                                      [int(a) for a in msg.get("args", [])],
+                                      msg.get("ret_type", "u32"), float(msg.get("timeout", 2.0)))
+                        res.update({"type": "call_result", "id": rid})
+                        print(json.dumps(res), flush=True)
+                except Exception as e:
+                    print(json.dumps({"type": kind, "id": rid, "ok": False,
+                                      "error": "command failed: %s" % e}), flush=True)
             ranges = state["ranges"]
             values, in_stop = {}, False
             for (start, length, members) in ranges:
@@ -927,8 +1340,11 @@ def cmd_trace(args):
                 except Exception:
                     in_stop = True
                     break
-                for (name, off, size, enc) in members:
-                    values[name] = _decode(data, off, size, enc)
+                for (name, off, size, enc, transform) in members:
+                    v = _decode(data, off, size, enc)
+                    if transform is not None:
+                        v = _apply_transform(v, size, transform)
+                    values[name] = v
             t = time.monotonic() - t0
             if in_stop:
                 now = time.monotonic()
@@ -1084,6 +1500,27 @@ def main():
                          "read. Reports inaccessible on timeout/no-probe. Default 6.")
     dp.set_defaults(func=cmd_device_state)
 
+    wp = sub.add_parser("write")
+    wp.add_argument("--elf", required=True)
+    wp.add_argument("--writes", required=True, help="';'-separated target=value specs")
+    wp.add_argument("--probe", default=None)
+    wp.add_argument("--target", default="cortex_m")
+    wp.add_argument("--connect-timeout", type=float, default=6.0)
+    wp.set_defaults(func=cmd_write)
+
+    cp = sub.add_parser("call")
+    cp.add_argument("--elf", required=True)
+    cp.add_argument("--func", required=True, dest="func_name")
+    cp.add_argument("--args", default=None, help="comma-separated ints (hex 0x.. or dec)")
+    cp.add_argument("--confirm", action="store_true")
+    cp.add_argument("--ret-type", dest="ret_type", default="u32",
+                    choices=list(_RAW_TYPE.keys()))
+    cp.add_argument("--timeout", type=float, default=2.0)
+    cp.add_argument("--probe", default=None)
+    cp.add_argument("--target", default="cortex_m")
+    cp.add_argument("--connect-timeout", type=float, default=6.0)
+    cp.set_defaults(func=cmd_call)
+
     args = ap.parse_args()
     args.func(args)
 

package/tracer/ui/config.js

@@ -0,0 +1,40 @@
+/* Config panel wiring (client-side only). Mirrors the side-panel controls into
+   the shared cfg object. toggleFull is exported for the keyboard shortcut. */
+
+import { sigs, cfg } from "./state.js";
+
+let cfgWindow, cfgFull, cfgMax, cfgYMode;
+
+function applyFull(){
+  cfg.full=cfgFull.checked;
+  cfgWindow.disabled=cfg.full;   // trailing window is meaningless in full-history
+}
+
+export function toggleFull(){
+  if(!cfgFull)return;
+  cfgFull.checked=!cfgFull.checked;
+  applyFull();
+}
+
+/* Reflect a new visible window width (e.g. from wheel-zoom) into cfg + the input
+   so the "Trailing window" field never goes stale while zooming. */
+export function setWindow(sec){
+  if(!(sec>0))return;
+  cfg.windowSec=sec;
+  if(cfgWindow) cfgWindow.value = sec<10 ? sec.toFixed(1) : String(Math.round(sec));
+}
+
+export function initConfig(){
+  cfgWindow=document.getElementById("cfgWindow");
+  cfgFull=document.getElementById("cfgFull");
+  cfgMax=document.getElementById("cfgMax");
+  cfgYMode=document.getElementById("cfgYMode");
+
+  cfgWindow.onchange=()=>{ const v=parseFloat(cfgWindow.value); if(v>0) cfg.windowSec=v; };
+  cfgFull.onchange=applyFull;
+  cfgMax.onchange=()=>{
+    const v=parseInt(cfgMax.value,10);
+    if(v>=100){ cfg.maxSamples=v; for(const[,s]of sigs) while(s.data.length>v) s.data.shift(); }
+  };
+  cfgYMode.onchange=()=>{ cfg.yMode=cfgYMode.value; };
+}