mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/packs/pins.py

@@ -0,0 +1,47 @@
+"""Pack pins: a team can pin each app pack to the app version it was checked on (``Verified.version``, the version
+``GET /api/packs`` shows), or turn one off. A Mac with a pin uses a pack only when this build's pack matches it; any
+other pack steps aside, and the general agent does the step, as it does for a pack that is stale. A pin never makes a
+pack do more: packs only move around and read, so a pin is about every Mac in a team doing the same thing, not about
+safety. The team track (teams/control_plane.py) sets the pins it read; with none set, every pack works as shipped.
+"""
+
+OFF = "off"
+_pins = {}  # pack key -> OFF, or the app version the team pinned the pack to
+
+
+def set_pins(pins):
+    """Replace the pins with ``pins`` ({pack key: OFF or a version}); {} clears them."""
+    _pins.clear()
+    _pins.update(
+        {key: value for key, value in dict(pins or {}).items() if isinstance(key, str) and isinstance(value, str)}
+    )
+
+
+def current():
+    return dict(_pins)
+
+
+def aside(pack):
+    """Why this Mac's ``pack`` steps aside under the team's pin, in a sentence, or None when it may be used."""
+    pin = _pins.get(pack.key)
+    if pin is None:
+        return None
+    if pin == OFF:
+        return f"Your team turned off the {pack.name} pack."
+    built = pack.verified.version if pack.verified else None
+    if built == pin:
+        return None
+    on = f"the pack checked on {pack.name} {built}" if built else "a pack with no checked version"
+    return (
+        f"Your team pinned the {pack.name} pack to {pack.name} {pin}, and this Mobster has {on}. Update Mobster, "
+        "or ask an Admin to change the pin."
+    )
+
+
+def state(pack):
+    """What this Mac reports about ``pack`` to its team: the version it has and whether it is stepping aside."""
+    return {
+        "key": pack.key,
+        "version": pack.verified.version if pack.verified else None,
+        "aside": aside(pack) is not None,
+    }

mobile_agent/packs/reddit.py

@@ -0,0 +1,110 @@
+"""The Reddit pack: your home feed, a post and its comments, communities, chat, your inbox and search."""
+
+import re
+
+from . import core, rows, social
+from .core import PickRow, Reader, Route, ScreenSpec, Tap, TypeIn, Verified, sig
+
+BUNDLE = "com.reddit.Reddit"
+TAB = (.86, 1.0)
+TOP = (0.0, .2)
+TAB_LABEL = r"^(Home|Communities|Answers|Create|Chat|Inbox)\b"
+COLUMNS = (("place", "Community", "text"), ("handle", "Author", "text"), ("text", "Post", "text"),
+           ("when", "When", "text"), ("score", "Score", "number"), ("comments", "Comments", "number"),
+           ("ad", "Ad", "text"))
+COMMENT_COLUMNS = (("handle", "Author", "text"), ("text", "Comment", "text"), ("when", "When", "text"),
+                   ("score", "Score", "number"))
+
+
+tab = rows.tab_tap(TAB)
+
+
+class Reddit(core.Pack):
+    name, key, prefix, bundle = "Reddit", "reddit", "RD", BUNDLE
+    verified = Verified("2025.44.0", "2026-10-14", "inferred from Reddit's usual labels; no recorded tree yet")
+    tabs = sig(TAB_LABEL, "Button", region=TAB)
+    never = re.compile(r"^(upvote|downvote|join|leave|award|give award|share|crosspost|save|hide|report|block|"
+                       r"reply|post|send|follow)\b", re.I)
+    mentions = re.compile(r"\b(reddit|subreddits?|r/[A-Za-z0-9_]+|upvotes?)\b", re.I)
+    sites = ("www.reddit.com", "reddit.com", "old.reddit.com", "redd.it")
+
+    screens = (
+        ScreenSpec("home", "your Reddit home feed", (
+            sig(r"^Home$", "Button", region=TAB, selected=True, must=True, weight=2),
+            sig(r"\br/[A-Za-z0-9_]{2,}", "Cell", weight=2), sig(r"\b\d[\d,.]*[KM]? (upvotes?|comments?|votes?)\b")),
+            ocr=(sig(r"\br/[A-Za-z0-9_]{2,}", weight=2),
+                 sig(r"\b\d[\d,.]*[KM]?\s*(upvotes?|comments?|votes?)\b|^\d[\d.,]*[KM]?$"),
+                 sig(r"^(Home|Popular|Latest)$", region=TOP), sig(r"^(Join|Joined)$", never=True))),
+        ScreenSpec("community", "a community", (
+            sig(r"^r/[A-Za-z0-9_]{2,}$", region=TOP, must=True, weight=2), sig(r"^(Join|Joined)$", "Button"),
+            sig(r"\b(members|online)\b")),
+            ocr=(sig(r"^r/[A-Za-z0-9_]{2,}$", region=TOP, must=True, weight=2), sig(r"^(Join|Joined)$"),
+                 sig(r"\b(members|online)\b"))),
+        ScreenSpec("post", "a post and its comments", (
+            sig(r"^(Add a comment|Join the conversation)", must=True, weight=2), sig(r"^Back$", "Button", region=TOP),
+            sig(r"^Sort by|^(Best|Top|New) comments")),
+            ocr=(sig(r"^(Add a comment|Join the conversation)", must=True, weight=2),
+                 sig(r"^Back$", "Button", region=TOP), sig(r"^Sort by|^(Best|Top|New) comments"))),
+        ScreenSpec("chat", "your chats", (
+            sig(r"^Chat$", "Button", region=TAB, selected=True, must=True, weight=2),
+            sig(r"^(Threads|Requests|Start chat)\b")),
+            ocr=(sig(r"^Chat$", region=TOP, must=True, weight=2), sig(r"^(Threads|Requests|Start chat)\b"))),
+        ScreenSpec("inbox", "your inbox", (
+            sig(r"^Inbox$", "Button", region=TAB, selected=True, must=True, weight=2),
+            sig(r"^(Notifications|Messages)$", region=TOP)),
+            ocr=(sig(r"^Inbox$", region=TOP, must=True, weight=2),
+                 sig(r"^(Notifications|Messages)$", region=(0, .25)))),
+        ScreenSpec("search", "search results", (
+            sig(r"^Search", "SearchField", must=True),
+            sig(r"^(Posts|Communities|Comments|Media|People)$", region=(0, .3), weight=2)),
+            ocr=(sig(r"^Search", "SearchField", must=True),
+                 sig(r"^(Posts|Communities|Comments|Media|People)$", region=(0, .3), weight=2))),
+    )
+    routes = {
+        "home": Route("home", "your Reddit home feed", ("home",), (tab(r"^Home$", "the Home tab"),)),
+        "chat": Route("chat", "your chats", ("chat",), (tab(r"^Chat$", "the Chat tab"),)),
+        "inbox": Route("inbox", "your inbox", ("inbox",), (tab(r"^Inbox$", "the Inbox tab"),)),
+        "thread": Route("thread", "a chat", ("chat",), (tab(r"^Chat$", "the Chat tab"),
+                                                        PickRow("chat", roles=("Cell", "Button"))), arg="name"),
+        "community": Route("community", "a community", ("community",), (),
+                           link="https://www.reddit.com/r/{arg}", arg="name", from_tabs=False),
+        "user": Route("user", "a profile", ("community", "home"), (), link="https://www.reddit.com/user/{arg}",
+                      arg="user", from_tabs=False),
+        "search": Route("search", "search results", ("search",),
+                        (tab(r"^Home$", "the Home tab"), Tap(r"^Search", "Search", region=TOP),
+                         TypeIn(r"^Search", "the search field", submit=True)), arg="query"),
+        "post": Route("post", "the post", ("post",), (), link="{arg}", arg="url", from_tabs=False),
+        "comments": Route("comments", "the comments", ("post",), (), from_tabs=False),
+    }
+    hidden_routes = ("user", "comments")
+    open_aliases = {"feed": "home", "subreddit": "community", "r": "community", "dms": "chat", "messages": "inbox",
+                    "link": "post", "chats": "chat"}
+    read_aliases = {"feed": "home", "posts": "home", "subreddit": "community", "comment": "comments",
+                    "dms": "chat", "chats": "chat"}
+    read_default = {"home": 10, "community": 10, "comments": 20, "search": 10, "chat": 15}
+    read_titles = {"home": "posts", "community": "posts", "comments": "comments", "search": "results",
+                   "chat": "chats"}
+    nouns = {"home": "post", "community": "post", "comments": "comment", "search": "result", "chat": "chat"}
+    prompts = {
+        "OPEN": ("- RD_OPEN where: go to a Reddit screen by code, no taps from you: home | community <name> | chat "
+                 "| inbox | thread <name> | search <words> | post <link>. If it can't, go on the usual way. It never "
+                 "votes, joins, comments or posts: those are your taps, and the person approves them."),
+        "READ": ("- RD_READ what [n]: read Reddit by code from the screen's tree: home n | community n (the one "
+                 "open) | comments n (on the post open) | search n | chat n. Gives community, author, title, time, "
+                 "score and comments. Opens the screen it needs."),
+    }
+    mcp_open_hint = "your home feed, a community, chats, your inbox, search, a post's link"
+    mcp_read_hint = "your home feed, a community, a post's comments, search results or your chats"
+
+    @property
+    def readers(self):
+        not_a_chat = re.compile(r"^(threads|requests|start chat|new chat|search)\b", re.I)
+        return {"home": Reader(social.feed_reader("home", "posts", COLUMNS), ("home",), "home"),
+                "community": Reader(social.feed_reader("community", "posts", COLUMNS), ("community",), None),
+                "comments": Reader(social.feed_reader("comments", "comments", COMMENT_COLUMNS, roles=("Cell", "Other")),
+                             ("post",), None),
+                "search": Reader(social.feed_reader("search", "results", COLUMNS), ("search",), None),
+                "chat": Reader(social.dm_reader(not_a_chat), ("chat",), "chat")}
+
+
+PACK = Reddit()

mobile_agent/packs/register.py

@@ -0,0 +1,276 @@
+"""Track ``packs``'s registrations (tracks.load calls ``register(api)`` once per process, staged)."""
+
+import functools
+import time as _time
+
+from . import pins
+
+TOOL_ORDER = 4
+CONTEXT_ORDER = 40
+SLEEP = _time.sleep                  # the health run's pause after a tap (tests set it to nothing)
+# The packs Mobster ships, by module: each module has PACK, an instance of core.Pack.
+MODULES = ("instagram", "tiktok", "messages", "settings", "calendar", "notes", "maps", "photos", "safari",
+           "x", "youtube", "threads", "linkedin", "reddit")
+_extra = []
+
+
+def all_packs():
+    """Every pack this build has, in MODULES order, then any a test added (``add_for_tests``)."""
+    import importlib
+    out = []
+    for name in MODULES:
+        try:
+            module = importlib.import_module(f"{__package__}.{name}")
+        except ModuleNotFoundError as error:
+            if error.name != f"{__package__}.{name}":
+                raise
+            continue
+        out.append(module.PACK)
+    return out + list(_extra)
+
+
+def add_for_tests(pack):
+    _extra.append(pack)
+    return lambda: _extra.remove(pack)
+
+
+def status_route(request):
+    """GET /api/packs: {packs: [health.status ...]}."""
+    from pathlib import Path
+
+    from ..api_routes import Response
+    from . import core, health
+    runtime = request.runtime
+    state_db = getattr(getattr(runtime, "config", None), "state_db", None)
+    entries = health.recent(Path(state_db).parent if state_db else None)
+    return Response.json({"packs": [health.status(pack, core.app_version(runtime, pack.bundle), entries)
+                                    for pack in all_packs()]})
+
+
+class Confirmer:
+    def on_finished(self, run, summary, private):
+        if (summary or {}).get("status") == "completed":
+            from . import heal
+            heal.confirm_run(getattr(run, "id", None))
+
+
+def register(api):
+    """``api`` is mobile_agent.harness_api."""
+    from .. import api_routes
+    from ..mcp_server import registry as mcp_registry
+    from . import context, mcp, tools
+    packs = all_packs()
+    if packs:
+        # What a pack read stays in front of the model on later turns (context.py).
+        api.register_context_provider(context.factory(packs), order=CONTEXT_ORDER)
+    for pack in packs:
+        api.register_tool(tools.factory(pack, "OPEN"), order=TOOL_ORDER)
+        api.register_tool(tools.factory(pack, "READ"), order=TOOL_ORDER)
+    if packs:
+        mcp_registry.register_provider(mcp.PacksProvider(packs))
+        # A run that finished completed confirms the variants proposed from screens a pack missed in it (heal.py).
+        api.register_run_listener(Confirmer())
+    api_routes.register(api_routes.Route("packs", "GET", "/api/packs", status_route, body="none"))
+    if packs:
+        # The watch: a read-only health run per app, as a task with packCheck (a schedule can run it).
+        api.register_run_field("packCheck", functools.partial(validate_pack_key, "packCheck"))
+        api.register_pre_run(pack_check, order=3)
+        # The numbers: a read-only run per app that stores today's profile and Insights numbers (accounts/stats.py).
+        api.register_run_field("packStats", functools.partial(validate_pack_key, "packStats"))
+        api.register_pre_run(pack_stats, order=3)
+        # A workflow's "Read an app" step (graph app.read): one reader's rows, by code, no model.
+        api.register_run_field("packRead", validate_pack_read)
+        api.register_pre_run(pack_read, order=3)
+        # The front door: a request that is exactly a pack reader's question or a Settings page is answered by code,
+        # before any model call (front_door.py).
+        from . import front_door
+        api.register_pre_run(front_door.hook, order=front_door.ORDER)
+
+
+def validate_pack_key(field, value, runtime):
+    """A pack run field (``packCheck``, ``packStats``): a pack's key; the run is that pack's read-only run."""
+    if not isinstance(value, str) or value not in {pack.key for pack in all_packs()}:
+        raise ValueError(f"{field} is the key of an app pack (GET /api/packs)")
+    return value
+
+
+def validate_pack_read(value, runtime):
+    """``packRead``: {"pack", "reader", "n", "arg"}, one of a pack's readers; the run is that read, with no model."""
+    if not isinstance(value, dict) or set(value) - {"pack", "reader", "n", "arg"}:
+        raise ValueError("packRead is {pack, reader, n, arg}")
+    pack = next((p for p in all_packs() if p.key == value.get("pack")), None)
+    if pack is None or value.get("reader") not in pack.readers:
+        raise ValueError("packRead names an app pack and one of its readers (GET /api/packs)")
+    n = value.get("n", 10)
+    if type(n) is not int or not 1 <= n <= 50:
+        raise ValueError("packRead reads 1 to 50 rows")
+    arg = value.get("arg")
+    if arg is not None and (not isinstance(arg, str) or not 1 <= len(arg.strip()) <= 200):
+        raise ValueError("packRead's arg is 1 to 200 characters")
+    return {"pack": pack.key, "reader": value["reader"], "n": n, "arg": arg.strip() if arg else None}
+
+
+def stepping_aside(hook):
+    """A pack pre-run hook for a run that names its pack (packRead, packCheck, packStats): when the team's pin has the
+    pack step aside, the run ends saying so, and never goes on to a model that nobody asked for."""
+    @functools.wraps(hook)
+    def wrapped(ctx, driver, approve):
+        from .. import harness_api
+        from . import core
+        try:
+            return hook(ctx, driver, approve)
+        except core.PinnedAside as aside:
+            return harness_api.PreRun(result={
+                "event": "result", "status": "completion_not_confirmed", "engine": "smart", "outcome": "check",
+                "answer": None, "reason": str(aside), "actions": 0, "decisions": 0, "costUsd": 0.0, "model": None,
+                "elapsed_ms": 0, "independently_verified": False, "proof": []})
+    return wrapped
+
+
+@stepping_aside
+def pack_read(ctx, driver, approve):
+    """Pre-run hook: a run with ``packRead`` reads that reader's rows on the phone by code and ends with them as its
+    data and a table."""
+    spec = (ctx.extras or {}).get("packRead")
+    if not spec or driver is None:
+        return None
+    import time
+
+    from .. import harness_api
+    from .. import result_blocks as rb
+    from . import core
+    pack = next(p for p in all_packs() if p.key == spec["pack"])
+    io = _io(ctx, driver, pack)       # a pack the team's pin has step aside ends the run here, before anything acts
+    # An acting event, journaled before the first tap: a crash mid-run is never read as a run that didn't act.
+    ctx.emit({"event": "skill_started", "op": f"{pack.prefix}_READ"})
+    started = time.monotonic()
+
+    def ended(status, outcome, answer, reason=None, data=None, blocks=()):
+        return harness_api.PreRun(result={
+            "event": "result", "status": status, "engine": "smart", "outcome": outcome, "answer": answer,
+            "reason": reason, "data": data, "actions": 1, "decisions": 0, "costUsd": 0.0, "model": None,
+            "elapsed_ms": round((time.monotonic() - started) * 1000), "blocks": rb.envelope(list(blocks)),
+            "independently_verified": outcome == "done", "proof": []})
+    try:
+        result = pack.read(io, spec["reader"], spec["n"], spec.get("arg"))
+    except core.Lost as lost:
+        said = str(lost).rstrip(".")
+        return ended("completion_not_confirmed", "check", None,
+                     f"Mobster couldn't read {pack.name}: {said}. Check the phone shows {pack.name}, "
+                     "then run it again.")
+    scalars = (str, int, float, bool, type(None))
+    rows = [{k: v for k, v in row.items() if isinstance(v, scalars)} for row in result.rows]
+    columns = [{"key": k, "label": label, "type": kind} for k, label, kind in result.columns]
+    data = {"rows": rows, "columns": columns, "title": result.title, "stopped": result.stopped or None}
+    table = rb.table(columns, rows, title=result.title, id=f"{pack.key}-{spec['reader']}") if rows else None
+    return ended("completed", "done", f"{result.title}: {len(rows)} {'row' if len(rows) == 1 else 'rows'}.",
+                 data=data, blocks=[table] if table else ())
+
+
+def _io(ctx, driver, pack):
+    from . import core
+    pinned = pins.aside(pack)
+    if pinned:
+        raise core.PinnedAside(pinned)
+    return core.PackIO(driver, pack, cancelled=ctx.cancelled, sleep=SLEEP,
+                       allows_app=lambda bundle: ctx.runtime is None or getattr(ctx.runtime, "allows_app",
+                                                                                lambda *a: True)(ctx.run_id, bundle))
+
+
+def pack_run(ctx, driver, field, op):
+    """What both pack pre-run hooks start from: ``(pack, io, started)`` for the run's ``field``, or None when the run
+    doesn't carry it or has no phone."""
+    key = (ctx.extras or {}).get(field)
+    if not key or driver is None:
+        return None
+    import time
+    pack = next(p for p in all_packs() if p.key == key)
+    io = _io(ctx, driver, pack)       # a pack the team's pin has step aside ends the run here, before anything acts
+    # An acting event, journaled before the first tap: a crash mid-run is never read as a run that didn't act.
+    ctx.emit({"event": "skill_started", "op": f"{pack.prefix}_{op}"})
+    return pack, io, time.monotonic()
+
+
+@stepping_aside
+def pack_check(ctx, driver, approve):
+    """Pre-run hook: a run with ``packCheck`` visits the pack's tab screens on the phone, records each in the health
+    log,
+    and ends with a checklist."""
+    run = pack_run(ctx, driver, "packCheck", "CHECK")
+    if run is None:
+        return None
+    import time
+
+    from . import core, health
+    pack, io, started = run
+    rows = health.check(pack, io)
+    version = core.app_version(ctx.runtime, pack.bundle)
+    for row in rows:
+        health.record(ctx.data_dir, {"pack": pack.key, "op": "CHECK", "step": row["route"], "ok": row["landed"],
+                                     "screen": row["screen"], "confidence": row["confidence"], "version": version,
+                                     **({"unsure_screen": pack.routes[row["route"]].lands[0]}
+                                        if not row["landed"] and not row["screen"] else {})})
+    ctx.emit({"event": "app_pack_check", "pack": pack.key, "routes": len(rows),
+              "landed": sum(1 for row in rows if row["landed"]), "version": version})
+    from .. import harness_api
+    return harness_api.PreRun(result=health.check_result(pack, rows, version, time.monotonic() - started))
+
+
+@stepping_aside
+def pack_stats(ctx, driver, approve):
+    """Pre-run hook: a run with ``packStats`` reads the signed-in profile's numbers and its Insights overview and stores
+    them as today's row (accounts/stats.py), no model."""
+    run = pack_run(ctx, driver, "packStats", "STATS")
+    if run is None:
+        return None
+    import time
+
+    from .. import harness_api
+    from .. import result_blocks as rb
+    from ..accounts import stats
+    from . import core
+    pack, io, started = run
+    account = (ctx.extras or {}).get("account")
+    wanted = account.get("handle") if isinstance(account, dict) else None
+
+    def done(answer, rows=(), ok=True):
+        blocks = [rb.table([{"label": label, "key": k, "type": kind} for k, label, kind in pack_columns],
+                           list(rows), title=f"{pack.name} numbers", id=f"{pack.key}-stats")] if rows else []
+        return harness_api.PreRun(result={
+            "event": "result", "status": "completed", "engine": "smart", "outcome": "done" if ok else "check",
+            "answer": answer, "actions": 1, "decisions": 0, "elapsed_ms": round((time.monotonic() - started) * 1000),
+            "costUsd": 0.0, "model": None, "blocks": rb.envelope(blocks)})
+
+    pack_columns = (("handle", "Profile", "text"), ("followers", "Followers", "number"),
+                    ("following", "Following", "number"), ("posts", "Posts", "number"), ("likes", "Likes", "number"),
+                    ("period", "Period", "text"), ("views", "Views", "number"), ("reach", "Reached", "number"),
+                    ("profile_visits", "Profile visits", "number"), ("follower_change", "Follower change", "number"))
+    try:
+        profile = pack.read(io, "profile", 1, None)
+        mine = profile.rows[0] if profile.rows else {}
+        handle = mine.get("handle")
+        if mine.get("state") != "yours" or not handle:
+            return done(f"Mobster didn't store {pack.name} numbers: the Profile tab doesn't show your own profile. "
+                        "Open your profile in the app, then run this again.", ok=False)
+        if wanted and wanted.lstrip("@").casefold() != handle.lstrip("@").casefold():
+            return done(f"Mobster didn't store {pack.name} numbers: the app shows @{handle}, "
+                        f"not @{wanted.lstrip('@')}. "
+                        "Switch to that account, then run this again.", ok=False)
+        values = {k: mine.get(k) for k in ("followers", "following", "posts", "likes")}
+        try:
+            overview = pack.read(io, "insights", 1, None).rows[0]
+            values.update({k: overview.get(k) for k in ("period", "views", "reach", "profile_visits",
+                                                        "follower_change")})
+            note = ""
+        except core.Lost as lost:
+            note = f" Insights weren't read: {str(lost).rstrip('.')}."
+        folder = ctx.data_dir
+        if ctx.runtime is not None:
+            from ..accounts.store import store_for
+            folder = store_for(ctx.runtime).data_dir
+        stats.record(folder, pack.key, handle, values)
+    except core.Lost as lost:
+        return done(f"Mobster couldn't read {pack.name}: {str(lost).rstrip('.')}. Check the phone shows "
+                    f"{pack.name}, then run this again.", ok=False)
+    ctx.emit({"event": "app_pack_stats", "pack": pack.key})
+    return done(f"Stored @{handle}'s {pack.name} numbers for today.{note}", [{"handle": handle, **values}])

mobile_agent/packs/rows.py

@@ -0,0 +1,108 @@
+"""Rows read from list screens, the same way on an accessibility tree and on a picture (image-only connections)."""
+
+import re
+
+from . import core
+
+# A time or a date as list rows show them: "9:55 PM", "Yesterday", "Monday", "10/1/26", "Oct 3", "2h", "3 days ago".
+WHEN = re.compile(r"^(\d{1,2}:\d{2}\s?([AaPp]\.?[Mm]\.?)?|yesterday|today|now|just now|"
+                  r"(mon|tues|wednes|thurs|fri|satur|sun)day|\d{1,2}/\d{1,2}(/\d{2,4})?|"
+                  r"(jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.? \d{1,2}(, \d{4})?|"
+                  r"\d{1,2} (jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*|"
+                  r"\d+\s?(s|m|min|h|hr|d|w|mo|y)|\d+ (seconds?|minutes?|hours?|days?|weeks?|months?|years?) ago)$",
+                  re.I)
+FLAGS = ("unread", "pinned", "muted", "time sensitive", "draft", "starred", "important", "verified", "new")
+
+
+def labelled(snapshot, roles=("Cell",), region=(.1, .92), minimum=2):
+    """The elements in ``region`` with ``roles`` and a label of at least ``minimum`` characters, each label once
+    (largest
+    element first when two share a label at the same place)."""
+    out, seen = [], set()
+    for element in sorted(core.find_all(snapshot, r".", roles=roles, region=region),
+                          key=lambda e: (round(core.centre_y(e), 2), -e.rect[2] * e.rect[3])):
+        label = core.plain(element.label)
+        key = (label, round(core.centre_y(element), 2))
+        if len(label) < minimum or key in seen:
+            continue
+        seen.add(key)
+        out.append(element)
+    return out
+
+
+def parts(label):
+    """(parts, flags): a row label's comma parts with iOS's flags ("Unread", "Pinned"...) taken out, lowercased."""
+    tokens = [t.strip() for t in core.plain(label).split(",")]
+    flags = {t.casefold() for t in tokens if t.casefold() in FLAGS}
+    return [t for t in tokens if t and t.casefold() not in FLAGS], flags
+
+
+def lines(snapshot, region=(0.0, 1.0)):
+    """A picture's text lines in ``region``, top to bottom then left to right."""
+    return sorted((e for e in getattr(snapshot, "elements", ()) or ()
+                   if e.label and region[0] <= core.centre_y(e) <= region[1]),
+                  key=lambda e: (round(core.centre_y(e), 3), e.rect[0]))
+
+
+def anchored(snapshot, anchor=WHEN, region=(.1, .92), right=.55, same_line=.012):
+    """On a picture: rows found by ``anchor`` (a regex on a whole line) at the right of their first line."""
+    texts = lines(snapshot, region)
+    marks = [e for e in texts if e.rect[0] >= right and anchor.match(core.plain(e.label))]
+    rows = []
+    for index, mark in enumerate(marks):
+        top = core.centre_y(mark)
+        bottom = core.centre_y(marks[index + 1]) - same_line if index + 1 < len(marks) else region[1]
+        head = [e for e in texts if e is not mark and abs(core.centre_y(e) - top) <= same_line
+                and e.rect[0] < mark.rect[0]]
+        body = [e for e in texts if e is not mark and e not in head and top + same_line < core.centre_y(e) < bottom]
+        rows.append({"anchor": core.plain(mark.label), "head": [core.plain(e.label) for e in head],
+                     "body": [core.plain(e.label) for e in body], "top": round(top, 3)})
+    return rows
+
+
+def pairs(snapshot, region=(.1, .95), roles=("Cell", "Button", "StaticText", "Other")):
+    """{label: value} of a settings-style list: "iOS Version, 26.0.1" on a tree; on a picture, a line on the left and a
+    line on the right at the same height."""
+    out = {}
+    if core.image_only(snapshot):
+        texts = lines(snapshot, region)
+        for left in (e for e in texts if e.rect[0] < .45):
+            right = [e for e in texts if e.rect[0] >= .45 and abs(core.centre_y(e) - core.centre_y(left)) < .012]
+            value = re.sub(r"\s*[>›]$", "", core.plain(right[-1].label)) if right else ""
+            if value and not re.fullmatch(r"[>›<‹]", value):
+                out.setdefault(re.sub(r"\s*[>›]$", "", core.plain(left.label)), value)
+        return out
+    for element in labelled(snapshot, roles, region):
+        label, value = core.plain(element.label), core.plain(element.value)
+        if value and value not in ("0", "1") and label:
+            out.setdefault(label, value)
+        elif ", " in label:
+            key, _, rest = label.partition(", ")
+            if key and rest:
+                out.setdefault(key, re.sub(r"(\d), (\d{3})\b", r"\1,\2", rest))
+    return out
+
+
+def tabbar(names, region=(.86, 1.0)):
+    """A tab bar's signal: any of ``names`` (whole labels) at the bottom, a button on a tree, a line on a picture."""
+    return core.sig(rf"^({'|'.join(names)})$", region=region)
+
+
+def top_left_back(snapshot, top=(.04, .14), never=core.NEVER):
+    """A navigation bar's Back button: a button at the top left whose label names the screen before ("Settings",
+    "General", "Search", "Oct 15"), never one whose words name an act."""
+    if core.image_only(snapshot):
+        return None
+    for element in sorted(core.find_all(snapshot, r"\S", role="Button", region=top), key=lambda e: e.rect[0]):
+        if element.rect[0] < .2 and element.rect[2] < .4 and not never.search(element.label or "") \
+                and not core.ACT_LABEL.match(core.plain(element.label)):
+            return element
+    return None
+
+
+def back_unless_act(pack, snapshot):
+    return top_left_back(snapshot, never=pack.never)
+
+
+def tab_tap(region):
+    return lambda label, what: core.Tap(label, what, role="Button", region=region)