Four features: search, stock comparison, real fonts, and a report

grep searches file *contents* across anything openable -- a partition, a
firmware image, a persistence image, a disc, a folder -- because listing and
reading both assume you already know which file you want, and most questions
are the other way round. Text patterns are tried as UTF-8 and UTF-16LE, since
firmware carries plenty of the latter, and hex patterns are there for hunting
structures rather than words. It reuses diffimg's Side abstraction: searching
and comparing both need paths plus a reader, so they share one.

stock answers "what on this unit is not factory" in one step instead of three.
The baseline lives in a .efs at ADR3000000 inside whichever release matches
the car, which is tribal knowledge standing between someone and the answer.
It now finds it -- and, because a disc carries fourteen of them, scores every
candidate against the unit and uses the best fit rather than the first. On a
test comparison the first-match answer was ARB300 and the right one was
RDW400: 31 files identical versus 54, silently wrong in a way nobody would
have questioned.

Screen labels now draw at their real size. The chain is element -> mFontResID
-> CFont -> mFontFormatResID -> CFontFormat.mHeight, and it resolved for zero
elements until the cause turned up: a field's CUID is hashed with its class
CUID as the seed, so the same field name hashes differently per class, and the
two name tables that looked like they contradicted each other were describing
different halves of the model. Merged, 2,583 elements resolve, the sizes form
a real typographic scale, and the typefaces name themselves -- UCR____.TTF and
VERAMONO.TTF, both sitting in IFS2.

report writes one self-contained HTML page: what the image is, whether each
partition read cleanly, what is not stock, and the bootscreens inlined as data
URIs. Something to attach to a forum post instead of twelve screenshots. It
carries the privacy warning, because a head-unit drive holds the VIN, saved
destinations and call history, and a report is easier to share than a disk
image.

Two test fixtures were wrong again and are fixed rather than accommodated: a
search context padded with NULs is correctly reported as hex, so it was
testing the wrong branch.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: dspl1236

pcmexplorer/cli.py

@@ -1,5 +1,6 @@
 """Command-line interface -- everything the GUI does, scriptable."""
 import os
+import re
 import sys
 
 from . import version_string
@@ -47,6 +48,21 @@
   pcm-explorer <x.mmi> verify               container self-check
   pcm-explorer <x.mmi> screens [root]       drawables resolved to x/y/w/h
 
+Search contents across any of the above:
+
+  pcm-explorer grep <target> <pattern> [part]   which files contain this?
+  pcm-explorer grep disk.img Burmester P2
+  pcm-explorer grep PCM3_IFS1.ifs --hex 89504e47
+
+One shareable HTML page about an image:
+
+  pcm-explorer report disk.img
+  pcm-explorer report disk.img unit.html "D:/PCM/ISO Extract"
+
+What is non-stock on a unit -- the baseline is found inside the disc for you:
+
+  pcm-explorer stock ./car_hbpersistence "D:/PCM/ISO Extract"
+
 Compare any two of the above:
 
   pcm-explorer diff <a> <b>                 what changed between them
@@ -453,6 +469,129 @@ def _hbm5_cmd(m, cmd, a):
     return 1
 
 
+def cmd_grep(argv):
+    """Search file contents across any openable artifact."""
+    from .diffimg import open_side
+    from .search import as_patterns, format_hits, search_side
+    if len(argv) < 2:
+        print("usage: grep <image|firmware|efs|disc|folder> <pattern> [part]")
+        print("       --hex     pattern is hex bytes, e.g. 89504e47")
+        print("       -i        case-insensitive")
+        print("       --in STR  only files whose path contains STR")
+        return 1
+    target, pattern = argv[0], argv[1]
+    rest = argv[2:]
+    mode = "hex" if "--hex" in rest else "both"
+    ignore_case = "-i" in rest
+    path_filter = None
+    if "--in" in rest:
+        i = rest.index("--in")
+        if i + 1 < len(rest):
+            path_filter = rest[i + 1]
+    part = next((a for a in rest if re.match(r"^[PL]\d+$", a)), None)
+
+    try:
+        side = open_side(target, part)
+        patterns = as_patterns(pattern, mode, ignore_case)
+    except Exception as e:
+        print("could not search: %s" % e)
+        return 1
+
+    print("searching %s (%s, %d files) for %r\n"
+          % (side.label, side.kind, len(side.index), pattern))
+    nf = nh = 0
+    for path, hits in search_side(side, patterns, ignore_case, path_filter):
+        print(format_hits(path, hits))
+        nf += 1
+        nh += len(hits)
+    print("\n%d hit%s in %d file%s"
+          % (nh, "" if nh == 1 else "s", nf, "" if nf == 1 else "s"))
+    return 0 if nf else 1
+
+
+def cmd_report(argv):
+    """One shareable HTML page describing an image."""
+    from .report import build
+    if not argv:
+        print("usage: report <image> [out.html] [update disc or .efs]")
+        print("  A self-contained page: what the image is, whether it read")
+        print("  cleanly, and -- with a baseline -- what on it is not stock.")
+        return 1
+    src = argv[0]
+    out = argv[1] if len(argv) > 1 else os.path.splitext(
+        os.path.basename(src))[0] + "-report.html"
+    baseline = argv[2] if len(argv) > 2 else None
+    try:
+        path = build(src, out, baseline)
+    except Exception as e:
+        print("could not build the report: %s" % e)
+        return 1
+    print("wrote %s (%s)" % (path, human(os.path.getsize(path))))
+    return 0
+
+
+def cmd_stock(argv):
+    """What on this unit differs from factory?"""
+    from .diffimg import compare, find_baseline, open_side
+    if len(argv) < 2:
+        print("usage: stock <exported /HBpersistence folder> <update disc or .efs>")
+        print("  Compares a unit against the factory baseline and reports what")
+        print("  has been added, removed or changed. The baseline is found for")
+        print("  you inside the disc.")
+        return 1
+    target, ref = argv[0], argv[1]
+    try:
+        mine = open_side(target)
+    except Exception as e:
+        print("could not open %s: %s" % (target, e))
+        return 1
+
+    label, base = None, None
+    if os.path.isdir(ref) or ref.lower().endswith(".iso"):
+        try:
+            label, base = find_baseline(ref, against=mine)
+        except Exception as e:
+            print("could not read the disc: %s" % e)
+            return 1
+        if base is None:
+            print("no factory persistence image found in %s" % ref)
+            return 1
+        print("baseline: %s" % label)
+    else:
+        try:
+            base = open_side(ref)
+        except Exception as e:
+            print("could not open %s: %s" % (ref, e))
+            return 1
+
+    added, removed, changed, same, by_name = compare(base, mine)
+    print("\n%s vs factory\n" % mine.label)
+    print("  %-28s %d" % ("identical to factory", same))
+    print("  %-28s %d" % ("modified", len(changed)))
+    print("  %-28s %d" % ("added (not in factory)", len(added)))
+    print("  %-28s %d" % ("missing (factory has it)", len(removed)))
+    if by_name:
+        print("\n  matched on file name -- the flash image carries no directory")
+        print("  structure, so same-named files in different folders merge.")
+
+    def block(title, rows, fmt):
+        if not rows:
+            return
+        print("\n%s" % title)
+        for r in rows[:30]:
+            print("   " + fmt(r))
+        if len(rows) > 30:
+            print("   ... and %d more" % (len(rows) - 30))
+
+    block("MODIFIED", changed,
+          lambda r: "%-44s %8d -> %d" % (r[0][:44], r[1], r[3]))
+    block("ADDED", added, lambda r: "%-44s %8d" % (r[0][:44], r[1]))
+    block("MISSING", removed, lambda r: "%-44s %8d" % (r[0][:44], r[1]))
+    if not (changed or added or removed):
+        print("\nNothing differs from factory.")
+    return 0
+
+
 def cmd_diff(argv):
     """Compare two readable things and report what differs."""
     from .diffimg import compare, format_report, open_side
@@ -487,6 +626,12 @@ def main(argv):
     # diff takes two operands rather than an image plus a verb
     if argv[0] == "diff":
         return cmd_diff(argv[1:])
+    if argv[0] == "grep":
+        return cmd_grep(argv[1:])
+    if argv[0] == "stock":
+        return cmd_stock(argv[1:])
+    if argv[0] == "report":
+        return cmd_report(argv[1:])
 
     path = argv[0]
     # a directory is only meaningful as an extracted update-disc tree

pcmexplorer/diffimg.py

@@ -129,6 +129,65 @@ def open_side(path, part=None):
                          "partition")
 
 
+def find_baseline(disc_path, want="persistence", against=None):
+    """Locate the factory baseline for a comparison inside an update disc.
+
+    "What is non-stock on this unit" is the question people actually have, and
+    answering it by hand means knowing that the factory ``/HBpersistence`` lives
+    in a ``.efs`` at ``ADR3000000`` inside whichever release matches the car.
+    That is three steps of tribal knowledge before the comparison even starts,
+    so this does the finding.
+
+    Returns (label, side) or (None, None).
+    """
+    disc = UpdateDisc(disc_path)
+    files = disc.files()
+    if want == "persistence":
+        # A disc carries one baseline per release -- ARB, CHN, RDW, several
+        # versions. Taking the first is a coin toss dressed as an answer, so
+        # score each against the unit and use the best fit.
+        import tempfile
+        cands = [p for p in files
+                 if p.lower().endswith(".efs") and "hbpersistence" in p.lower()]
+        best, best_side, best_score = None, None, -1
+        for i, p in enumerate(cands):
+            data = disc.read(p)
+            if not data:
+                continue
+            tmp = os.path.join(tempfile.gettempdir(), "pcmx_baseline_%d.efs" % i)
+            with open(tmp, "wb") as f:
+                f.write(data)
+            try:
+                side = _from_entries(p.rsplit("/", 1)[-1], EfsImage(tmp),
+                                     "EFS", flat=True)
+            except Exception:
+                continue
+            if against is None:
+                return p, side                     # nothing to score against
+            _a, _r, _c, same, _bn = compare(side, against)
+            if same > best_score:
+                best, best_side, best_score = p, side, same
+        if best_side is not None:
+            label = best
+            if len(cands) > 1:
+                label = "%s  (best of %d, %d files identical)" % (
+                    best, len(cands), best_score)
+            return label, best_side
+        # fall back to the update's own overlay, which is a subset
+        overlay = [p for p in files if "/FIL/HBpersistence/" in p]
+        if overlay:
+            index, store = {}, {}
+            for p in overlay:
+                data = disc.read(p) or b""
+                key = "/" + p.split("/FIL/HBpersistence/", 1)[1]
+                index[key] = (len(data), _sha(data))
+                store[key] = p
+            return ("FIL/HBpersistence overlay",
+                    Side("update overlay", index,
+                         lambda k: disc.read(store[k]) or b"", kind="disc overlay"))
+    return None, None
+
+
 def compare(a, b):
     """Return (added, removed, changed, same, by_name).
 

pcmexplorer/gui.py

@@ -108,15 +108,22 @@ def show_screen(self, root=None):
         cv.create_rectangle(0, 0, DISPLAY_W, DISPLAY_H, outline=ACCENT)
         # biggest first, so small elements land on top of their containers
         drawn = 0
-        for _rid, b, lab in sorted(boxes, key=lambda r: -(r[1][2] * r[1][3])):
+        for rid, b, lab in sorted(boxes, key=lambda r: -(r[1][2] * r[1][3])):
             x, y, w, h, src = b
             if w <= 0 or h <= 0 or x > DISPLAY_W or y > DISPLAY_H:
                 continue
             colour = ACCENT if "P" in src else DIM
             cv.create_rectangle(x, y, x + w, y + h, outline=colour)
-            if lab and w > 26 and h > 12:
-                cv.create_text(x + 3, y + 2, anchor="nw", text=lab[:24],
-                               fill=TEXT, font=("Consolas", 7))
+            if lab and w > 20 and h > 10:
+                # draw the label at the element's own font size, centred like the
+                # unit would -- the metrics are in the file, so use them rather
+                # than one fixed size that makes every screen look the same
+                px = sc.font_px(rid) or 11
+                px = max(6, min(px, h - 2))
+                cv.create_text(x + w // 2, y + h // 2, anchor="center",
+                               text=lab[:40], fill=TEXT,
+                               font=("Segoe UI", -px),
+                               width=max(10, w - 4))
             drawn += 1
         ttk.Label(win, style="Dim.TLabel",
                   text="%d of %d elements drawn   %dx%d   gold = position "

pcmexplorer/hbm5geom.py

@@ -67,27 +67,61 @@
 # Kinds seen on a position descriptor: a left/right anchor pair.
 ANCHOR_KINDS = (21, 22)
 
+# A field's CUID is hashed with its *class* CUID as the seed, so the same field
+# name has a different hash in every class that declares it. These two groups
+# therefore coexist rather than conflict: the drawable hierarchy below, and the
+# resource classes it points at.
 CLASS_NAMES = {
+    # drawables
     0x8E2F8293: "CDrawObject",          0x90AA9E70: "CGUIElement",
     0xA806B8EE: "CAligningObject",      0xA3C213B8: "CBitmapObject",
     0x71B5DB06: "CTextBase",            0x3EBA6425: "CTextObject",
     0xBA066794: "CFormattedTextObject", 0x77F80FB9: "CTextArea",
+    0x2267FE33: "<CPoint>",             0x0AA3495D: "<CSize>",
+    # resources
     0xDA63396B: "CDisplay",             0x92AE6BAD: "CColor",
     0x57E931C3: "CAlignment",           0xC6D7DD90: "CBitmap",
     0xE0D04503: "CFontFormat",          0x0B60D4CA: "CFontFile",
-    0x5C8F9492: "CResourceTable",       0x25B3AC9A: "<string>",
-    0x2267FE33: "<CPoint>",             0x0AA3495D: "<CSize>",
+    0x5C8F9492: "CResourceTable",       0x25B3AC9A: "CHBString",
+    0x60436E39: "CFont",                0x8AC3362F: "CFontReferences",
+    0x2F71594A: "CFontTextCombination", 0xE161265A: "CPlacementFontCombination",
+    0x3DC09477: "CPlacementCombination", 0xB9106E94: "CBitmapColorCombination",
+    0xD7CE702B: "CColors",              0xD8492763: "CColorMasks",
+    0x1F53E9FF: "CColorReferences",     0x833EFC17: "PositionResource",
+    0x8425447B: "AlignmentResource",
 }
 
 FIELD_NAMES = {
+    # on the drawable classes
     0x0A2B4963: "mParentID",       0x7F9A5557: "mDrawOrder",
     0x7A1CC624: "mPositionResID",  0xF790B5F2: "mSizeResID",
     0xEBD70139: "mPosition",       0x45CF85C4: "mSize",
     0x5FFAEE1E: "m_childrenIDs",   0x1A2BEA44: "m_resourceTableID",
     0x5A894D17: "mAlignmentResID", 0x79CC0437: "mAlignment",
     0x94EA844C: "mBmpResID",       0xF9F3B843: "mColorsResID",
     0xD7C9A631: "mTextResID",      0xB397877F: "mFontResID",
-    0x9960974E: "point",           0x26693065: "size",
+    0x621C612D: "mFontResID",      0x9960974E: "point",
+    0x26693065: "size",
+    # on CFont / CFontFormat / CFontFile -- the chain a label's size comes from
+    0xAFB73BC7: "mFontFormatResID", 0x650043A0: "mColorsResID",
+    0x84477324: "mFontFileResID",   0xA2E58771: "mHeight",
+    0xD080B74E: "mWidth",           0xEE757E54: "mEngine",
+    0x92DD65C3: "mHorizontalDPI",   0x2E858ACE: "mVerticalDPI",
+    0x70160B06: "mFileName",        0xFFF5F83A: "mOutlineWidth",
+    0x1EB8A8EF: "mFontResID",       0x5F028ED0: "mFontResID",
+    0x5F90203A: "mFonts",           0x5C8C1726: "mString",
+    # on CBitmap
+    0xEC9570D7: "mMode",            0x93DF2ACC: "mBitsPerPixel",
+    0x78BDA50A: "mWidth",           0xE70B5DA7: "mHeight",
+    0x0800845E: "mPaletteCount",    0x9A979BD7: "mPixelData",
+    # on the resource-side placement classes
+    0x8F1AC150: "mPoint",           0xC0654178: "mSize",
+    0x10432267: "mPosition",        0x2B5B2DE3: "mSize",
+    0xE4E168FB: "mPositionResID",   0xD967BDC7: "mSizeResID",
+    0xE46C3005: "mBmpResID",        0x98165484: "mTextResID",
+    0xA433A1BF: "mColorsResID",     0xF1BF6A3D: "mParentID",
+    0xA3EFFD51: "m_childrenIDs",    0xD0B3623F: "m_resourceTableID",
+    0x516D5D62: "mDrawOrder",
 }
 
 
@@ -398,6 +432,58 @@ def screens(self, min_elements=4, limit=400):
                 break
         return uniq
 
+    def font_px(self, rid):
+        """Pixel height of the font an element draws in, or None.
+
+        The chain is element -> mFontResID -> CFont -> mFontFormatResID ->
+        CFontFormat.mHeight, and CFontFormat also names the .ttf via CFontFile,
+        so the real typeface is knowable too -- the files are in IFS2.  Using the
+        recorded size rather than one fixed size is what stops every screen
+        looking alike: a heading and a list row differ by more than their text.
+        """
+        r = self.record(rid)
+        if not r:
+            return None
+        fid = r.get("mFontResID") or 0
+        if not fid:
+            return None
+        f = self.record(fid)
+        if f is None:                       # a descriptor: follow its variants
+            for _kind, pid in self.desc.get(fid, ()):
+                f = self.record(pid)
+                if f is not None:
+                    break
+        if not f:
+            return None
+        ffid = f.get("mFontFormatResID") or 0
+        fmt = self.record(ffid) if ffid else None
+        if fmt is None and ffid:
+            for _kind, pid in self.desc.get(ffid, ()):
+                fmt = self.record(pid)
+                if fmt is not None:
+                    break
+        h = (fmt or {}).get("mHeight")
+        if isinstance(h, int) and 4 <= h <= 96:
+            return h
+        return None
+
+    def font_file(self, rid):
+        """The .ttf an element's font resolves to, if the chain is complete."""
+        r = self.record(rid)
+        fid = (r or {}).get("mFontResID") or 0
+        f = self.record(fid) if fid else None
+        ffid = (f or {}).get("mFontFormatResID") or 0
+        fmt = self.record(ffid) if ffid else None
+        fileid = (fmt or {}).get("mFontFileResID") or 0
+        ff = self.record(fileid) if fileid else None
+        name = (ff or {}).get("mFileName")
+        if isinstance(name, bytes):
+            try:
+                return name.decode("utf-8", "replace").strip("\x00")
+            except Exception:
+                return None
+        return name if isinstance(name, str) else None
+
     def name_of(self, rid, scan=600):
         """A human name for a screen: the first text found inside it.