@topy-ai/maggie 0.7.52 → 0.7.54

package/bundled-tools/clis/maggie_design_bulk.py

@@ -0,0 +1,290 @@
+"""Bulk author mode: many similar pages from one brief, facts file and validator.
+
+One job tracks every target page through write -> validate -> picture -> seed.
+The rules come from a run of 255 industry pages:
+
+* a page gets its picture only after it validated and its file has not
+  changed since (a picture worker that rewrites a file while a writer still
+  edits it loses work);
+* a writer receives the file's current hash and must re-read the page if it
+  changed before writing (``record --stage written --expect-hash``);
+* changing the brief, facts or validator mid-run sends every page that passed
+  under the old rules back to ``revalidate``;
+* pages are seeded only when every page in the job passed all checks.
+
+The validator is the project's own command (JSON argv; the page path is
+appended). Two built-in checks need no command: internal links must point at a
+route of the job or ``--known-routes``, and every price must appear in the
+facts file.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+STAGES = ("planned", "written", "validated", "pictured", "seeded")
+LINK = re.compile(r"""(?:href=["']|\]\(|"(?:href|url|link)"\s*:\s*")(/[^"')\s#?]*)""")
+PRICE = re.compile(r"(?:[£$€¥]\s?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?|(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?\s?(?:GBP|USD|EUR)\b)")
+
+
+def now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def digest(path: Path) -> str | None:
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:16] if path.is_file() else None
+
+
+def rules_digest(job: dict, project: Path) -> str:
+    parts = [json.dumps(job["validator"]), json.dumps(job["checks"]), json.dumps(job["knownRoutes"])]
+    for key in ("brief", "facts"):
+        parts.append(digest(project / job[key]) or "missing" if job.get(key) else "")
+    return hashlib.sha256("\n".join(parts).encode()).hexdigest()[:16]
+
+
+def job_path(project: Path, job_id: str) -> Path:
+    return project / ".maggie" / "design" / f"{job_id}.json"
+
+
+def load(project: Path, job_id: str) -> dict:
+    return json.loads(job_path(project, job_id).read_text(encoding="utf-8"))
+
+
+def save(project: Path, job: dict) -> None:
+    path = job_path(project, job["id"])
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(job, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def refresh_rules(job: dict, project: Path) -> list[str]:
+    """When the rules changed, earlier passes no longer count."""
+    current = rules_digest(job, project)
+    if current == job.get("rulesDigest"):
+        return []
+    moved = []
+    for target in job["targets"]:
+        if STAGES.index(target["stage"]) >= STAGES.index("validated") and target["stage"] != "seeded":
+            target["stage"] = "written"
+            target["revalidate"] = True
+            moved.append(target["id"])
+    job["rulesDigest"] = current
+    job["history"].append({"at": now(), "event": "rules-changed", "revalidate": len(moved)})
+    return moved
+
+
+def builtin_checks(job: dict, project: Path, text: str) -> list[str]:
+    errors = []
+    if "links" in job["checks"]:
+        routes = {target["route"].rstrip("/") or "/" for target in job["targets"]} | {route.rstrip("/") or "/" for route in job["knownRoutes"]}
+        for link in sorted(set(LINK.findall(text))):
+            if (link.rstrip("/") or "/") not in routes and not link.startswith(("/_", "/api/", "/images/", "/media/", "/fonts/")) and "." not in link.rsplit("/", 1)[-1]:
+                errors.append(f"link to {link}, which is not a page of this job or a known route")
+    if "prices" in job["checks"] and job.get("facts"):
+        facts = (project / job["facts"]).read_text(encoding="utf-8") if (project / job["facts"]).is_file() else ""
+        allowed = {re.sub(r"\s", "", value) for value in PRICE.findall(facts)}
+        for price in sorted({re.sub(r"\s", "", value) for value in PRICE.findall(text)}):
+            if price not in allowed:
+                errors.append(f"price {price} is not in the facts file")
+    return errors
+
+
+def page_text(path: Path) -> str:
+    """The page's text; for a JSON page, its string values (escapes decoded)."""
+    raw = path.read_text(encoding="utf-8", errors="replace")
+    if path.suffix != ".json":
+        return raw
+    strings: list[str] = []
+
+    def walk(value: object) -> None:
+        if isinstance(value, str):
+            strings.append(value)
+        elif isinstance(value, dict):
+            for key, item in value.items():
+                # Keep "href": "/x" shapes visible to the link check.
+                if isinstance(item, str) and key in {"href", "url", "link"}:
+                    strings.append(f'"{key}": "{item}"')
+                else:
+                    walk(item)
+        elif isinstance(value, list):
+            for item in value:
+                walk(item)
+
+    try:
+        walk(json.loads(raw))
+    except json.JSONDecodeError:
+        return raw
+    return "\n".join(strings)
+
+
+def validate_target(job: dict, project: Path, target: dict, timeout: int) -> dict:
+    path = project / target["file"]
+    if not path.is_file():
+        return {"passed": False, "errors": ["page file does not exist yet"]}
+    errors = builtin_checks(job, project, page_text(path))
+    if job["validator"]:
+        try:
+            completed = subprocess.run([*job["validator"], str(path)], cwd=project, capture_output=True, text=True, timeout=timeout, check=False)
+        except (OSError, subprocess.TimeoutExpired) as error:
+            return {"passed": False, "errors": errors + [f"validator could not run: {type(error).__name__}"]}
+        if completed.returncode:
+            detail = (completed.stdout.strip() or completed.stderr.strip()).splitlines()[-5:]
+            errors.extend(["validator: " + line[:300] for line in detail] or ["validator failed"])
+    return {"passed": not errors, "errors": errors}
+
+
+def eligible(job: dict, project: Path, stage: str) -> list[dict]:
+    batch = []
+    for target in job["targets"]:
+        current = digest(project / target["file"])
+        if stage == "write" and target["stage"] in {"planned", "written"} and (target["stage"] == "planned" or target.get("revalidate") or target.get("lastErrors")):
+            batch.append({"id": target["id"], "route": target["route"], "file": target["file"], "currentHash": target.get("knownHash") or "none", "errors": target.get("lastErrors", [])})
+        elif stage == "picture" and target["stage"] == "validated" and current == target.get("validatedHash"):
+            # Stable since validation: nobody is editing it.
+            batch.append({"id": target["id"], "route": target["route"], "file": target["file"], "validatedHash": current})
+        if len(batch) >= job["batchSize"]:
+            break
+    return batch
+
+
+def command(args: argparse.Namespace) -> int:
+    project = args.project.resolve()
+    if args.bulk_command == "plan":
+        if not args.confirm:
+            print("CONFIRMATION_REQUIRED: rerun with --confirm", file=sys.stderr)
+            return 2
+        raw = json.loads(args.targets.read_text(encoding="utf-8"))
+        items = raw.get("targets", raw) if isinstance(raw, dict) else raw
+        targets, seen = [], set()
+        for item in items:
+            route = str(item.get("route") or "")
+            if not route.startswith("/") or route == "/":
+                raise ValueError(f"target route must be a non-homepage path: {route!r}")
+            target_id = str(item.get("id") or route.strip("/").replace("/", "-"))
+            if target_id in seen:
+                raise ValueError(f"duplicate target id {target_id}")
+            seen.add(target_id)
+            targets.append({"id": target_id, "route": route, "file": str(item.get("file") or f"src/content/pages/{target_id}.json"), "stage": "planned"})
+        job_id = "bulk-" + hashlib.sha256((str(project) + "\n" + "\n".join(t["route"] for t in targets)).encode()).hexdigest()[:12]
+        relative = lambda path: str(path.resolve().relative_to(project)) if path else None  # noqa: E731
+        job = {"schemaVersion": "maggie-design-bulk.v1", "id": job_id, "mode": "bulk-author", "brief": relative(args.brief), "facts": relative(args.facts),
+               "validator": json.loads(args.validator) if args.validator else [], "checks": sorted(set(args.check)), "knownRoutes": args.known_routes,
+               "batchSize": args.batch_size, "targets": targets, "history": [{"at": now(), "event": "planned", "targets": len(targets)}]}
+        if job["validator"] and not (isinstance(job["validator"], list) and all(isinstance(part, str) for part in job["validator"])):
+            raise ValueError("--validator must be a JSON argv array")
+        job["rulesDigest"] = rules_digest(job, project)
+        save(project, job)
+        print(json.dumps({"job": job_id, "targets": len(targets), "batchSize": job["batchSize"], "plan": str(job_path(project, job_id))}, indent=2))
+        return 0
+    job = load(project, args.job)
+    revalidate = refresh_rules(job, project)
+    if args.bulk_command == "next":
+        batch = eligible(job, project, args.stage)
+        save(project, job)
+        print(json.dumps({"job": job["id"], "stage": args.stage, "revalidate": revalidate, "batch": batch, "rule": "re-read each file and compare currentHash before writing" if args.stage == "write" else "draw only these pages; skip any whose hash changed"}, indent=2, ensure_ascii=False))
+        return 0
+    if args.bulk_command == "record":
+        target = next((item for item in job["targets"] if item["id"] == args.target), None)
+        if not target:
+            raise ValueError(f"unknown target {args.target}")
+        current = digest(project / target["file"])
+        if args.stage == "written":
+            # knownHash is the file as the job last saw it (written, validated or
+            # pictured). A writer who read another version must re-read first.
+            if args.expect_hash is None:
+                raise ValueError("--expect-hash is required: pass the currentHash from `next --stage write` ('none' for a new page)")
+            if args.expect_hash != (target.get("knownHash") or "none"):
+                raise ValueError(f"{target['id']} changed since you read it (now {target.get('knownHash')}); re-read the page, apply your edit again and record with the new hash")
+            target.update({"stage": "written", "knownHash": current, "revalidate": False})
+        elif args.stage == "pictured":
+            if target["stage"] != "validated":
+                raise ValueError(f"{target['id']} is not validated; validate it before drawing")
+            target.update({"stage": "pictured", "pictureHash": current, "knownHash": current})
+        target["updatedAt"] = now()
+        save(project, job)
+        print(json.dumps({"target": target["id"], "stage": target["stage"], "hash": current}, indent=2))
+        return 0
+    if args.bulk_command == "validate":
+        results = []
+        for target in job["targets"]:
+            if args.only and target["id"] not in args.only:
+                continue
+            if target["stage"] == "planned" or (target["stage"] in {"validated", "pictured", "seeded"} and digest(project / target["file"]) == target.get("validatedHash") and not target.get("revalidate")):
+                continue
+            outcome = validate_target(job, project, target, args.timeout)
+            current = digest(project / target["file"])
+            if outcome["passed"]:
+                # A page that changed after its picture needs the picture again.
+                target.update({"stage": "validated" if target.get("pictureHash") != current else "pictured", "validatedHash": current, "knownHash": current, "revalidate": False, "lastErrors": []})
+            else:
+                target.update({"stage": "written", "lastErrors": outcome["errors"][:20]})
+            results.append({"id": target["id"], **outcome})
+        save(project, job)
+        failed = [item for item in results if not item["passed"]]
+        print(json.dumps({"job": job["id"], "validated": len(results) - len(failed), "failed": failed[:50], "revalidate": revalidate}, indent=2, ensure_ascii=False))
+        return 0 if not failed else 1
+    # status / seed
+    counts = {stage: sum(1 for target in job["targets"] if target["stage"] == stage) for stage in STAGES}
+    stale = [target["id"] for target in job["targets"] if target["stage"] in {"validated", "pictured"} and digest(project / target["file"]) != target.get("validatedHash")]
+    ready = counts["pictured"] + counts["seeded"] == len(job["targets"]) and not stale
+    if args.bulk_command == "seed":
+        if not ready:
+            print(json.dumps({"job": job["id"], "seed": "blocked", "counts": counts, "changedAfterValidation": stale, "reason": "every page must be validated, pictured and unchanged since validation before any page is seeded"}, indent=2))
+            return 1
+        if not args.confirm:
+            print("CONFIRMATION_REQUIRED: rerun with --confirm", file=sys.stderr)
+            return 2
+        for target in job["targets"]:
+            target["stage"] = "seeded"
+        job["history"].append({"at": now(), "event": "seeded", "targets": len(job["targets"])})
+        save(project, job)
+        print(json.dumps({"job": job["id"], "seed": "ready", "targets": [{"route": t["route"], "file": t["file"]} for t in job["targets"]]}, indent=2))
+        return 0
+    save(project, job)
+    print(json.dumps({"job": job["id"], "counts": counts, "changedAfterValidation": stale, "revalidate": revalidate, "seedReady": ready}, indent=2))
+    return 0
+
+
+def add_parser(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(prog="maggie design bulk", description=__doc__.splitlines()[0])
+    sub = parser.add_subparsers(dest="bulk_command", required=True)
+    plan = sub.add_parser("plan", help="create a bulk author job from a target list")
+    plan.add_argument("--targets", type=Path, required=True, help='JSON [{"id"?, "route", "file"?}] or {"targets": [...]}')
+    plan.add_argument("--brief", type=Path)
+    plan.add_argument("--facts", type=Path)
+    plan.add_argument("--validator", help="JSON argv; the page file path is appended")
+    plan.add_argument("--check", action="append", choices=["links", "prices"], default=[])
+    plan.add_argument("--known-routes", nargs="*", default=[])
+    plan.add_argument("--batch-size", type=int, default=8)
+    plan.add_argument("--confirm", action="store_true")
+    for name in ("next", "record", "validate", "status", "seed"):
+        command_parser = sub.add_parser(name)
+        command_parser.add_argument("job")
+        if name == "next":
+            command_parser.add_argument("--stage", choices=["write", "picture"], required=True)
+        if name == "record":
+            command_parser.add_argument("--target", required=True)
+            command_parser.add_argument("--stage", choices=["written", "pictured"], required=True)
+            command_parser.add_argument("--expect-hash", help="the currentHash you read before writing ('none' for a new page)")
+        if name == "validate":
+            command_parser.add_argument("--only", nargs="*")
+            command_parser.add_argument("--timeout", type=int, default=120)
+        if name == "seed":
+            command_parser.add_argument("--confirm", action="store_true")
+    for action in sub.choices.values():
+        action.add_argument("--project", type=Path, default=Path.cwd())
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str]) -> int:
+    args = add_parser(argv)
+    try:
+        return command(args)
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        print(f"BLOCKED: maggie design bulk: {error}", file=sys.stderr)
+        return 1

package/bundled-tools/clis/maggie_design_lint.py

@@ -7,7 +7,10 @@ pressable in JSX/TSX. React Native Web renders ``Pressable`` and the
 remove control becomes ``<button>`` inside ``<button>``: invalid DOM, and taps
 land on the wrong control.
 
-``layer-check`` flags unlayered CSS that competes with Tailwind v4 utilities.
+``layer-check`` flags unlayered CSS that competes with Tailwind v4 utilities,
+and warns about ``width: max-content`` (or ``w-max``) strips that can push a
+390 px page sideways. ``textinput-check`` flags React Native Web multiline
+inputs without a height and grow-only auto-grow.
 Tailwind v4 emits utilities inside ``@layer utilities``; any unlayered rule
 wins over every layer regardless of specificity, so an unlayered
 ``h1 { font-family }`` beats ``font-*`` and ``.ph { display: inline-block }``
@@ -19,6 +22,13 @@ Expo Router modal route (``presentation: "transparentModal"``, ``"modal"``,
 surfaces can measure a 0 top inset, so the header and Close button sit under
 the notch or Dynamic Island; web screenshots cannot show it. Read insets with
 ``useSafeAreaInsets()`` from the root ``SafeAreaProvider`` instead.
+
+``sheet-check`` flags closing a modal sheet and, in the same tick, showing a
+toast, refreshing or writing query data, navigating, or opening another sheet.
+On iOS the closing sheet's transparent window can stay on top of the app and
+swallow every touch until the app is killed. Close first, then do the rest
+once the sheet has slid away (``afterSheetCloses(fn)``: ``setTimeout`` of the
+slide duration on iOS/Android, immediate on web).
 """
 
 from __future__ import annotations
@@ -239,12 +249,41 @@ def _rule_findings(source: str, start: int, end: int, layered: bool, display: st
         index = close + 1
 
 
+MAX_CONTENT_RULE = re.compile(r"([^{}]+)\{([^{}]*\b(?:min-)?width\s*:\s*max-content[^{}]*)\}", re.I)
+MAX_CONTENT_CLASS = re.compile(r"class(?:Name)?\s*=\s*[\"'`{]([^\"'`}]*\bw-max\b[^\"'`}]*)", re.I)
+OVERFLOW_GUARD = re.compile(r"\b(?:max-width|overflow(?:-x)?)\s*:", re.I)
+
+
+def overflow_findings(project: Path, css_sources: dict[Path, str], markup: list[Path]) -> list[dict[str, object]]:
+    """width: max-content on a tab strip or toolbar makes a phone page scroll sideways unless it can shrink or scroll."""
+    findings: list[dict[str, object]] = []
+    for path, source in css_sources.items():
+        for match in MAX_CONTENT_RULE.finditer(source):
+            body = match.group(2)
+            if OVERFLOW_GUARD.search(body):
+                continue
+            selector = " ".join(match.group(1).split())[-80:]
+            findings.append({"file": _display(path, project), "line": source.count("\n", 0, match.start(2)) + 1, "selector": selector, "kind": "max-content", "severity": "warning",
+                             "message": "width: max-content without max-width/overflow can push a 390 px page sideways; give the strip overflow-x: auto inside a min-width: 0 parent, or max-width: 100%"})
+    for path in markup:
+        source = path.read_text(encoding="utf-8", errors="replace")
+        for match in MAX_CONTENT_CLASS.finditer(source):
+            classes = match.group(1)
+            if re.search(r"\b(?:overflow-x-auto|overflow-auto|overflow-x-scroll|max-w-[\w\[\]%-]+)\b", classes):
+                continue
+            findings.append({"file": _display(path, project), "line": source.count("\n", 0, match.start()) + 1, "selector": classes.strip()[:80], "kind": "max-content", "severity": "warning",
+                             "message": "w-max without overflow-x-auto or a max-w-* can make the page scroll sideways at 390 px"})
+    return findings
+
+
 def layer_check(project: Path, paths: list[Path], force_v4: bool) -> dict[str, object]:
     files = iter_files(paths or [project], (".css", ".pcss", ".postcss"))
     sources = {path.resolve(): _strip_css_comments(path.read_text(encoding="utf-8", errors="replace")) for path in files}
+    markup = iter_files(paths or [project], (".tsx", ".jsx", ".astro", ".vue", ".svelte", ".html"))
+    overflow = overflow_findings(project, sources, markup)
     tailwind_v4 = force_v4 or any(TAILWIND_V4_IMPORT.search(source) for source in sources.values())
     if not tailwind_v4:
-        return {"schemaVersion": "maggie-design-layer-check.v1", "passed": True, "status": "skipped", "reason": "no Tailwind v4 entry (@import \"tailwindcss\") found", "checkedFiles": len(files), "findings": []}
+        return {"schemaVersion": "maggie-design-layer-check.v1", "passed": True, "status": "skipped", "reason": "no Tailwind v4 entry (@import \"tailwindcss\") found", "checkedFiles": len(files), "findings": overflow, "warnings": len(overflow)}
     layered_files: set[Path] = set()
     for path, source in sources.items():
         for target in LAYERED_IMPORT.findall(source):
@@ -252,6 +291,7 @@ def layer_check(project: Path, paths: list[Path], force_v4: bool) -> dict[str, o
     findings: list[dict[str, object]] = []
     for path, source in sources.items():
         _rule_findings(source, 0, len(source), path in layered_files, _display(path, project), findings)
+    findings += overflow
     errors = [item for item in findings if item["severity"] == "error"]
     return {"schemaVersion": "maggie-design-layer-check.v1", "passed": not errors, "status": "checked", "checkedFiles": len(files), "errors": len(errors), "warnings": len(findings) - len(errors), "findings": findings}
 
@@ -311,6 +351,158 @@ def safe_area_check(project: Path, paths: list[Path]) -> dict[str, object]:
             "recommendation": "Wrap the app once in SafeAreaProvider; in modals read const insets = useSafeAreaInsets() and pad the header/footer. Verify on a notched iPhone (or simulator) — web screenshots cannot show the inset."}
 
 
+TEXTINPUT_TAG = re.compile(r"<TextInput\b(?:[^<>]|=>|\{[^{}]*(?:\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}[^{}]*)*\})*?/?>", re.S)
+TEXTINPUT_ALLOW = "maggie-allow-textinput"
+
+
+def textinput_check(project: Path, paths: list[Path]) -> dict[str, object]:
+    """React Native Web renders a multiline TextInput as a 2-row textarea; flag inputs without a height and grow-only auto-grow."""
+    project = project.resolve()
+    files = iter_files(paths or [project], (".tsx", ".jsx"))
+    findings: list[dict[str, object]] = []
+    for path in files:
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        if "TextInput" not in raw or TEXTINPUT_ALLOW in raw:
+            continue
+        source = _strip_jsx_comments(raw)
+        display = _display(path, project)
+        for tag in TEXTINPUT_TAG.finditer(source):
+            text = tag.group(0)
+            if not re.search(r"\bmultiline\b(?!\s*=\s*\{\s*false\s*\})", text):
+                continue
+            line = _line(source, tag.start())
+            sized = re.search(r"\bnumberOfLines\s*=|\brows\s*=|\b(?:height|minHeight)\s*:", text)
+            style_ref = re.search(r"\bstyle\s*=\s*\{\s*(?:\[)?\s*(?:styles|s)\.(\w+)", text)
+            if not sized and style_ref and re.search(rf"\b{style_ref.group(1)}\s*:\s*\{{[^{{}}]*\b(?:height|minHeight)\s*:", source):
+                sized = True
+            if not sized:
+                findings.append({"file": display, "line": line, "kind": "multiline-without-height", "severity": "error",
+                                 "message": "multiline TextInput without numberOfLines or an explicit height renders a 2-row textarea on web (placeholder high, buttons misaligned); set one line of height and grow by measuring"})
+            if "onContentSizeChange" in text and "scrollHeight" not in source:
+                findings.append({"file": display, "line": line, "kind": "grow-only-autogrow", "severity": "warning",
+                                 "message": "onContentSizeChange never reports a smaller size on web, so this composer grows but never shrinks; on web collapse to the minimum, read scrollHeight, then set the height"})
+    errors = [item for item in findings if item["severity"] == "error"]
+    return {"schemaVersion": "maggie-design-textinput-check.v1", "passed": not errors, "checkedFiles": len(files), "findings": findings}
+
+
+SHEET_ALLOW = "maggie-allow-sheet-close"
+SHEET_CLOSE = re.compile(r"\bset(?:\w*(?:Sheet|Modal|Drawer|Picker|Dialog))\s*\(\s*(?:null|undefined|false)\s*\)|\bset\w*(?:Open|Visible|Shown|Show)\s*\(\s*false\s*\)|\b(?:onClose|closeSheet|closeModal|dismiss|onDismiss)\s*\(\s*\)")
+SHEET_DEFER_NAMES = ("afterSheetCloses", "setTimeout", "requestAnimationFrame", "queueMicrotask", "InteractionManager.runAfterInteractions", "runAfterInteractions")
+SHEET_DEFER = re.compile(r"\b(?:" + "|".join(map(re.escape, SHEET_DEFER_NAMES)) + r")\s*\(")
+SHEET_TRIGGERS = (
+    ("toast", re.compile(r"\b(?:toast|showToast|Toast\.show)\s*\(")),
+    ("query-refresh", re.compile(r"\b(?:refetch|invalidateQueries|refetchQueries|resetQueries|mutate|revalidate|reload|refresh)\s*\(")),
+    ("set-query-data", re.compile(r"\bsetQueryData\s*\(")),
+    ("navigation", re.compile(r"\b(?:router|navigation|navigator)\.(?:push|replace|navigate|back|dismiss\w*)\s*\(|\bLinking\.openURL\s*\(")),
+    ("another-sheet", re.compile(r"\bset\w*(?:Sheet|Modal|Drawer|Picker|Dialog)\s*\(\s*(?!null|undefined|false)[^)\s]")),
+    ("another-sheet", re.compile(r"\bset\w*(?:Open|Visible|Shown|Show)\s*\(\s*true\s*\)")),
+    ("navigation", re.compile(r"\b\w+\.open\s*\(|\bopenSheet\s*\(")),
+)
+# A parent's callback often toasts or refreshes; worth a look, not an error.
+SHEET_CALLBACK = re.compile(r"(?<![.\w])on[A-Z]\w*\s*\(")
+SHEET_PROP = re.compile(r"<(?:\w+\.)?\w*(?:Sheet|Modal|Drawer|Dialog)\b[^>]*?\b(?:open|visible|isOpen|isVisible)\s*=\s*\{([^{}]*)\}", re.S)
+
+
+SHEET_PAUSE = re.compile(r"\bawait\s+(?:new\s+Promise\s*\([^;]*?\bsetTimeout\b|(?:sleep|delay|wait|pause)\s*\()")
+
+
+def _defer_pattern(source: str) -> re.Pattern[str]:
+    """Built-in deferrals plus local helpers whose body defers (e.g. `const later = (fn) => { ... setTimeout ... }`)."""
+    names = []
+    for match in re.finditer(r"(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\([^\n]*?\)\s*(?::[^={\n]+)?=>\s*\{|function\s+(\w+)\s*\([^\n]*?\)[^{\n]*\{", source):
+        body = source[match.end():match.end() + 600]
+        if re.search(r"\b(?:setTimeout|afterSheetCloses|requestAnimationFrame|runAfterInteractions)\b", body.split("\n}", 1)[0]):
+            names.append(match.group(1) or match.group(2))
+    if not names:
+        return SHEET_DEFER
+    return re.compile(r"\b(?:" + "|".join(map(re.escape, (*SHEET_DEFER_NAMES, *names))) + r")\s*\(")
+
+
+def _call_end(source: str, open_paren: int) -> int:
+    level, cursor = 0, open_paren
+    while cursor < len(source):
+        if source[cursor] == "(":
+            level += 1
+        elif source[cursor] == ")":
+            level -= 1
+            if level == 0:
+                return cursor
+        cursor += 1
+    return len(source)
+
+
+def _same_tick(source: str, start: int, defer: re.Pattern[str]) -> str:
+    """Text that runs synchronously after `start` in the same block, with deferred callbacks blanked out."""
+    out: list[str] = []
+    depth = 0
+    index = start
+    while index < len(source):
+        deferred = defer.match(source, index)
+        if deferred:
+            index = _call_end(source, deferred.end() - 1) + 1
+            continue
+        if SHEET_PAUSE.match(source, index):
+            break  # awaiting a timer longer than nothing: the rest runs later
+        char = source[index]
+        if char in "({[":
+            depth += 1
+        elif char in ")}]":
+            depth -= 1
+            if depth < 0:
+                break
+        out.append(char)
+        index += 1
+    return "".join(out)
+
+
+def sheet_check(project: Path, paths: list[Path]) -> dict[str, object]:
+    project = project.resolve()
+    files = iter_files(paths or [project], (".tsx", ".jsx", ".ts", ".js"))
+    findings: list[dict[str, object]] = []
+    for path in files:
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        if SHEET_ALLOW in raw or not re.search(r"\bSheet\b|<Modal\b|BottomSheet|presentation", raw):
+            continue
+        source = _strip_jsx_comments(raw)
+        display = _display(path, project)
+        # The state behind each sheet's open/visible prop: its setter closes the sheet.
+        names = {name for expression in SHEET_PROP.findall(source) for name in re.findall(r"(?<![.\w])([a-z]\w*)\b", re.sub(r"(['\"`])(?:\\.|(?!\1).)*\1", "", expression)) if name not in {"true", "false", "null", "undefined"}}
+        setters = [f"set{name[0].upper()}{name[1:]}" for name in names]
+        close_pattern = SHEET_CLOSE if not setters else re.compile(SHEET_CLOSE.pattern + "|\\b(?:" + "|".join(map(re.escape, setters)) + ")\\s*\\(\\s*(?:null|undefined|false|\"\"|'')\\s*\\)")
+        defer = _defer_pattern(source)
+        deferred_spans = [(match.end(), _call_end(source, match.end() - 1)) for match in defer.finditer(source)]
+        for close in close_pattern.finditer(source):
+            # A close inside a deferred callback already runs after the slide.
+            if any(begin <= close.start() <= end for begin, end in deferred_spans):
+                continue
+            # `const close = () => setOpen(false)`: the function only closes.
+            if re.search(r"=>\s*$", source[max(0, close.start() - 40):close.start()]):
+                continue
+            after = _same_tick(source, close.end(), defer)
+            seen: set[str] = set()
+            for kind, pattern in SHEET_TRIGGERS:
+                match = pattern.search(after)
+                if match and kind not in seen:
+                    seen.add(kind)
+                    findings.append({"file": display, "line": _line(source, close.start()), "kind": kind, "severity": "error", "close": close.group(0), "then": match.group(0).strip(),
+                                     "message": f"`{close.group(0)}` is followed in the same tick by {kind.replace('-', ' ')} (`{match.group(0).strip()}`); on iOS the closing sheet can stay on screen and take every touch. Close first, then run the rest in afterSheetCloses(() => ...)."})
+            callback = SHEET_CALLBACK.search(after)
+            if callback and not seen:
+                findings.append({"file": display, "line": _line(source, close.start()), "kind": "parent-callback", "severity": "warning", "close": close.group(0), "then": callback.group(0).strip(),
+                                 "message": f"`{close.group(0)}` is followed by `{callback.group(0).strip()}`; if that callback toasts, refreshes, navigates or closes another sheet, defer it with afterSheetCloses."})
+        # Content tied to the open state: closing (x = null) also empties the sheet while it slides away.
+        for tag in re.finditer(r"<(?:\w+\.)?\w*(?:Sheet|Modal|Drawer|Dialog)\b[^>]*?\b(?:open|visible|isOpen|isVisible)\s*=\s*\{\s*(?:Boolean\(\s*(\w+)\s*\)|!!\s*(\w+)|(\w+)\s*!==?\s*(?:null|undefined))\s*\}", source, re.S):
+            name = next(group for group in tag.groups() if group)
+            rest = source[tag.end():tag.end() + 1500]
+            body = rest[:rest.find("</")] if "</" in rest else rest
+            if re.search(rf"(?<![\w.]){re.escape(name)}\s*(?:\?\.|\.|\[)", source[tag.start():tag.end()] + body):
+                findings.append({"file": display, "line": _line(source, tag.start()), "kind": "content-tied-to-open", "severity": "warning", "close": f"set{name[0].upper()}{name[1:]}(null)", "then": f"{name}.… in the sheet",
+                                 "message": f"the sheet opens on `{name}` and shows `{name}`'s fields, so closing it (clearing `{name}`) changes its content while it slides away; keep a separate open flag and clear `{name}` in afterSheetCloses (or leave it until the next open)."})
+    errors = [item for item in findings if item["severity"] == "error"]
+    return {"schemaVersion": "maggie-design-sheet-check.v1", "passed": not errors, "checkedFiles": len(files), "findings": findings,
+            "fix": "export function afterSheetCloses(fn: () => void) { if (Platform.OS === \"web\") fn(); else setTimeout(fn, SHEET_CLOSE_MS); }  // SHEET_CLOSE_MS ~ the slide-out duration (about 450 ms)"}
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="maggie design", description="Static design checks that run before browser QA.")
     sub = parser.add_subparsers(dest="command", required=True)
@@ -325,9 +517,19 @@ def main(argv: list[str] | None = None) -> int:
     safe = sub.add_parser("safe-area-check", help="flag SafeAreaView inside Expo Router modal routes and React Native Modal (.tsx/.jsx)")
     safe.add_argument("--project", type=Path, default=Path.cwd())
     safe.add_argument("--path", type=Path, action="append", default=[], help="file or directory to scan; defaults to the project")
+    textinput = sub.add_parser("textinput-check", help="flag multiline TextInput without a height and grow-only auto-grow on React Native Web (.tsx/.jsx)")
+    textinput.add_argument("--project", type=Path, default=Path.cwd())
+    textinput.add_argument("--path", type=Path, action="append", default=[], help="file or directory to scan; defaults to the project")
+    sheet = sub.add_parser("sheet-check", help="flag closing a modal sheet and, in the same tick, a toast, refresh, query write, navigation or another sheet (iOS freeze)")
+    sheet.add_argument("--project", type=Path, default=Path.cwd())
+    sheet.add_argument("--path", type=Path, action="append", default=[], help="file or directory to scan; defaults to the project")
     args = parser.parse_args(argv)
     try:
-        if args.command == "safe-area-check":
+        if args.command == "sheet-check":
+            report = sheet_check(args.project, args.path)
+        elif args.command == "textinput-check":
+            report = textinput_check(args.project, args.path)
+        elif args.command == "safe-area-check":
             report = safe_area_check(args.project, args.path)
         elif args.command == "pressable-check":
             report = pressable_check(args.project, args.path, args.pressable)