@@ -26,6 +26,16 @@
 ENTRY_NAMES = {
     "main", "__init__", "__main__", "__new__", "__call__", "setup", "setUp",
     "tearDown", "run", "handler", "index", "render", "constructor",
+    # PHP magic methods
+    "__construct", "__destruct", "__invoke", "__get", "__set", "__toString",
+    # Laravel: migrations, providers, jobs, requests, factories, policies
+    "up", "down", "boot", "booted", "register", "handle", "schedule", "rules",
+    "authorize", "definition", "casts", "toArray", "via", "toMail", "broadcastOn",
+    "store", "show", "create", "edit", "update", "destroy",
+    # Filament / Livewire hooks
+    "form", "table", "configure", "panel", "mount", "getPages", "getRelations",
+    "getHeaderActions", "getStats", "getData", "getType", "getEloquentQuery",
+    "getGloballySearchableAttributes", "canAccessPanel",
 }
 
 
@@ -80,6 +90,10 @@ def _resolve_file_ref(base_file: str, target: str, file_set) -> Optional[str]:
         posixpath.normpath(target.lstrip("/")),
         target.lstrip("./"),
     ]
+    # PSR-4 namespaces: `use App\Support\MjIcon` lives in app/Support/MjIcon.php
+    head, _, rest = target.partition("/")
+    if rest and head[:1].isupper():
+        candidates.append(head.lower() + "/" + rest)
     # python dotted modules: models / app.utils -> models.py / app/utils.py
     if "/" not in target and "." not in posixpath.basename(target):
         candidates.append(target.replace(".", "/"))
@@ -233,8 +247,9 @@ def table_node(t_name: str, t: Optional[TableInfo] = None) -> str:
             if t is not None:  # enrich a placeholder with real definition
                 for n in nodes:
                     if n["id"] == nid:
-                        if t.fields:
-                            n["fields"] = t.fields
+                        if t.fields:  # merge: migrations add columns over time
+                            n["fields"] = n.get("fields", []) + [
+                                c for c in t.fields if c not in n.get("fields", [])]
                         if t.model:
                             n["model"] = t.model
                         if t.source:
@@ -252,11 +267,17 @@ def table_node(t_name: str, t: Optional[TableInfo] = None) -> str:
         })
         return nid
 
+    # real definitions first, so a model's guessed name can snap to one
+    defined = {t.name.lower() for f in files for t in f.tables if not t.aliases}
     for f in files:
-        for t in f.tables:
+        for t in sorted(f.tables, key=lambda t: bool(t.aliases)):
+            if t.aliases:
+                t.name = next((a for a in t.aliases if a.lower() in defined), t.name)
             nid = table_node(t.name, t)
             if t.model:
                 model_to_table[t.model.lower()] = nid
+                if t.aliases:  # Eloquent model file -> its table
+                    add_edge(f.path, nid, "db", f"{t.model} model → {t.name}")
 
     # ---- call edges --------------------------------------------------
     for f in files:
@@ -288,12 +309,14 @@ def table_node(t_name: str, t: Optional[TableInfo] = None) -> str:
 
     # ---- file-level connections ---------------------------------------
     file_set = {f.path for f in files}
+    called_from_page: set = set()  # own functions a page calls (onclick="f()")
     for f in files:
         fname = f.path.split("/")[-1]
         local = {fn.name: fn_nodes[(f.path, fn.name)] for fn in f.functions}
         # top-level calls: page/script code calling into functions
         for callee in f.calls:
             if callee in local:
+                called_from_page.add(local[callee])
                 continue  # a file already implicitly contains its own fns
             candidates = name_index.get(callee, [])
             if not candidates or callee in COMMON_NAMES:
@@ -332,13 +355,13 @@ def table_node(t_name: str, t: Optional[TableInfo] = None) -> str:
             target = handler_id or f.path
             route_index.append((r.method, _norm_path(r.path), target,
                                 f"{r.method} {r.path}"))
-            if handler_id:
-                # mark handler node with its route
-                for n in nodes:
-                    if n["id"] == handler_id:
-                        n.setdefault("routes", []).append(
-                            {"method": r.method, "path": r.path})
-                        break
+            # mark the handler with its route; closure routes (Laravel
+            # `Route::get('/', function () {...})`) land on the file itself
+            for n in nodes:
+                if n["id"] == target:
+                    n.setdefault("routes", []).append(
+                        {"method": r.method, "path": r.path})
+                    break
 
     # ---- api edges (frontend call -> backend route) -------------------
     def match_route(method: str, url: str) -> Optional[Tuple[str, str]]:
@@ -374,6 +397,8 @@ def match_route(method: str, url: str) -> Optional[Tuple[str, str]]:
                 tid = model_to_table.get(ref.table.lower()) \
                     or table_ids.get(ref.table.lower())
                 if tid is None:
+                    if ref.via == "orm-guess":
+                        continue  # `Foo::where()` where Foo isn't a known model
                     # unknown table: create it only for confident refs
                     if ref.via == "sql" or ref.table.lower() in table_ids:
                         tid = table_node(ref.table)
@@ -389,6 +414,12 @@ def match_route(method: str, url: str) -> Optional[Tuple[str, str]]:
 
     # ---- orphans + circular dependencies --------------------------------
     cycles = _mark_orphans_and_cycles(nodes, edges)
+    # Eloquent model methods (relations, accessors) are reached through magic
+    # properties like $booking->user, which static analysis can't see
+    model_files = {f.path for f in files for t in f.tables if t.model and t.aliases}
+    for n in nodes:
+        if n.get("orphan") and (n.get("file") in model_files or n["id"] in called_from_page):
+            del n["orphan"]
 
     # ---- stats ---------------------------------------------------------
     n_fns = sum(1 for n in nodes if n["kind"] in ("function", "method"))
 
@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import os
+import re
 from collections import Counter, defaultdict
 from typing import Dict, Iterable
 
@@ -24,6 +25,20 @@ def _short(items: Iterable[str], cap: int = LIST_CAP) -> str:
     return ", ".join(items[:cap]) + more
 
 
+def _human(name: str) -> str:
+    return " ".join(re.sub(r"(?<=[a-z0-9])(?=[A-Z])|_+", " ", name).split()).lower()
+
+
+def _desc(fn: Dict) -> str:
+    """Drop auto-descriptions that only repeat the name ("Get Header Actions."),
+    keep what they add after it ("handles POST /users; queries users")."""
+    d = (fn.get("description") or "").strip()
+    head, _, tail = d.partition(" — ")
+    if head.rstrip(".").lower() == _human(fn["label"]):
+        return tail.rstrip(".")
+    return d
+
+
 def to_markdown(graph: Dict) -> str:
     nodes = {n["id"]: n for n in graph.get("nodes", [])}
     edges = [e for e in graph.get("edges", [])
@@ -76,11 +91,16 @@ def layer_rank(k: str) -> int:
           ""]
 
     # ---- entry points
-    routes = sorted(((r["method"], r["path"], fn) for fl in fns.values() for fn in fl
-                     for r in fn.get("routes") or []), key=lambda x: (x[1], x[0]))
+    routes = set()
+    for n in nodes.values():
+        for r in n.get("routes") or []:
+            if n["kind"] == "file":  # inline handler, e.g. a Laravel route closure
+                routes.add((r["method"], r["path"], f"`{n['file']}` (inline)"))
+            elif n["kind"] in ("function", "method"):
+                routes.add((r["method"], r["path"], f"`{n['file']}:{n['label']}()`"))
     if routes:
         L += ["## HTTP routes", "", "| Method | Path | Handler |", "|---|---|---|"]
-        L += [f"| {m} | `{p}` | `{fn['file']}:{fn['label']}()` |" for m, p, fn in routes]
+        L += [f"| {m} | `{p}` | {h} |" for m, p, h in sorted(routes, key=lambda x: (x[1], x[0], x[2]))]
         L.append("")
 
     # ---- data model
@@ -106,13 +126,17 @@ def layer_rank(k: str) -> int:
         by_layer[f.get("layer") or "unknown"].append(f)
     for layer in sorted(by_layer, key=layer_rank):
         L += [f"### {LAYER_NAME.get(layer, layer)}", ""]
+        quiet = []  # files with nothing to say beyond their name
         for f in by_layer[layer]:
             path = f["file"]
             members = [f["id"]] + [fn["id"] for fn in fns.get(path, [])]
             talks = [ref(owner(e["target"])) for m in members for e in out_e[m]
                      if owner(e["target"]) != f["id"]]
             heard = [ref(owner(e["source"])) for m in members for e in in_e[m]
                      if owner(e["source"]) != f["id"]]
+            if not (talks or heard or fns.get(path) or f.get("warnings")):
+                quiet.append(f"`{path}`")
+                continue
             L.append(f"#### `{path}` ({f.get('language', '?')}, {f.get('loc', 0)} lines)")
             if talks:
                 L.append("Uses: " + _short(talks))
@@ -125,28 +149,30 @@ def layer_rank(k: str) -> int:
                 params = ", ".join(fn.get("params") or [])
                 cls = f"{fn['parentClass']}." if fn.get("parentClass") else ""
                 line = f"- `{cls}{fn['label']}({params})` L{fn.get('line', '?')}"
-                if fn.get("description"):
-                    line += f": {fn['description']}"
+                if _desc(fn):
+                    line += f": {_desc(fn)}"
                 calls = [ref(e["target"], path) for e in out_e[fn["id"]] if e["kind"] != "db"]
                 tbls = [nodes[e["target"]]["label"] for e in out_e[fn["id"]] if e["kind"] == "db"]
                 callers = [ref(e["source"], path) for e in in_e[fn["id"]]]
                 extra = []
                 if calls:
                     extra.append("calls " + _short(calls))
-                if tbls and not fn.get("description"):  # descriptions already name their tables
+                if tbls and not all(t in _desc(fn) for t in tbls):  # skip if the description names them
                     extra.append("tables " + _short(tbls))
                 if callers:
                     extra.append("called by " + _short(callers))
                 if fn.get("cycle"):
                     extra.append("in a call cycle")
-                elif fn.get("orphan"):
-                    extra.append("no callers found")
+                # no "no callers found": framework hooks (up(), boot(), form())
+                # are called by the framework, so it would mislead more than help
                 if extra:
                     line += " | " + "; ".join(extra)
                 L.append(line)
             if len(fl) > FNS_PER_FILE:
                 L.append(f"- … {len(fl) - FNS_PER_FILE} more functions")
             L.append("")
+        if quiet:
+            L += ["Other files: " + _short(quiet, 40), ""]
 
     # ---- things to be careful about
     notes = []
 
@@ -58,6 +58,9 @@ class TableInfo:
     fields: List[str] = field(default_factory=list)
     line: int = 0
     source: str = ""     # file that defines it
+    # candidate names when `name` is only a guess (e.g. Laravel's pluralised
+    # Eloquent table names); resolved against real tables in build_graph
+    aliases: List[str] = field(default_factory=list)
 
 
 @dataclass
 
@@ -15,6 +15,7 @@
     "try", "throw", "case", "using", "lock", "foreach", "select", "func",
     "defer", "go", "range", "elsif", "unless", "until", "when", "match",
     "sizeof", "typeof", "yield", "puts", "print", "println", "printf",
+    "function", "fn", "use",  # PHP closures: `function () use ($x)`, `fn () =>`
 }
 
 SQL_RE = re.compile(
@@ -23,6 +24,100 @@
     re.IGNORECASE)
 CALL_RE = re.compile(r"(?<![\w$.:])([A-Za-z_][\w]*)\s*\(")
 
+# ---- PHP / Laravel ------------------------------------------------------
+# CALL_RE skips `X::f(` and would read `$obj->label(` as a call to any
+# function named label. In PHP only these member calls are trustworthy:
+PHP_MEMBER_CALL_RE = re.compile(
+    r"(?:\$this->|\b(?:self|static|parent)::|\b[A-Z]\w*::)(\w+)\s*\(")
+PHP_USE_RE = re.compile(r"^\s*use\s+([A-Za-z_][\w\\]*\\\w+)\s*(?:as\s+\w+\s*)?;",
+                        re.MULTILINE)
+PHP_VIEW_RE = re.compile(r"\bview\s*\(\s*['\"]([\w.\-/]+)['\"]")
+# Eloquent: Booking::where(...), Booking::create(...), DB::table('bookings')
+PHP_ORM_RE = re.compile(
+    r"\b([A-Z]\w*)::(query|where\w*|find\w*|first\w*|create|insert\w*|"
+    r"update\w*|upsert|destroy|all|with|latest|oldest|orderBy|count|sum|"
+    r"pluck|paginate|select)\s*\(")
+PHP_DB_TABLE_RE = re.compile(r"\bDB::table\(\s*['\"](\w+)['\"]")
+ORM_OP = {"create": "insert", "insert": "insert", "upsert": "insert",
+          "update": "update", "destroy": "delete"}
+NOT_MODELS = {"DB", "Route", "Schema", "Carbon", "Str", "Arr", "Auth", "Cache",
+              "Log", "Http", "Storage", "Validator", "Hash", "Session", "Config",
+              "Gate", "Mail", "Event", "Queue", "App", "Request", "Response"}
+SCHEMA_RE = re.compile(r"Schema::(create|table)\s*\(\s*['\"](\w+)['\"]")
+BLUEPRINT_COL_RE = re.compile(r"\$\w+->(\w+)\s*\(\s*(?:['\"](\w+)['\"])?")
+BLUEPRINT_IMPLIED = {"id": ["id"], "timestamps": ["created_at", "updated_at"],
+                     "timestampsTz": ["created_at", "updated_at"],
+                     "softDeletes": ["deleted_at"], "rememberToken": ["remember_token"]}
+BLUEPRINT_SKIP = {"index", "unique", "primary", "foreign", "dropColumn",
+                  "dropForeign", "dropIndex", "renameColumn", "fullText",
+                  "spatialIndex", "comment", "engine", "charset", "collation"}
+ELOQUENT_RE = re.compile(
+    r"^\s*(?:final\s+)?class\s+(\w+)\s+extends\s+(?:Model|Authenticatable|Pivot)\b",
+    re.MULTILINE)
+PHP_TABLE_PROP_RE = re.compile(r"\$table\s*=\s*['\"](\w+)['\"]")
+
+
+def _snake(name: str) -> str:
+    return re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name).lower()
+
+
+def _plural_candidates(snake: str) -> List[str]:
+    """Laravel's table guess for a model, best first (Booking -> bookings)."""
+    if snake.endswith("y") and snake[-2:-1] not in "aeiou":
+        first = snake[:-1] + "ies"
+    elif snake.endswith(("s", "x", "z", "ch", "sh")):
+        first = snake + "es"
+    else:
+        first = snake + "s"
+    return [first, snake]  # bare name covers uncountables like `equipment`
+
+
+def _php_member_calls(body: str) -> List[str]:
+    return [m.group(1) for m in PHP_MEMBER_CALL_RE.finditer(body)]
+
+
+def _php_db_refs(body: str, line: int) -> List[DbRef]:
+    refs = [DbRef(table=m.group(1), op="query", via="sql", line=line)
+            for m in PHP_DB_TABLE_RE.finditer(body)]
+    for m in PHP_ORM_RE.finditer(body):
+        if m.group(1) in NOT_MODELS:
+            continue
+        op = next((v for k, v in ORM_OP.items() if m.group(2).startswith(k)), "select")
+        refs.append(DbRef(table=m.group(1), op=op, via="orm-guess", line=line))
+    return refs
+
+
+def parse_laravel(info: FileInfo, text: str) -> None:
+    """File-level Laravel facts: `use` imports, view() links, migrations,
+    Eloquent models. Cheap regex passes; nothing matches in non-Laravel PHP."""
+    info.imports.extend(m.group(1).replace("\\", "/") for m in PHP_USE_RE.finditer(text))
+    for m in PHP_VIEW_RE.finditer(text):
+        info.links.append("resources/views/" + m.group(1).replace(".", "/") + ".blade.php")
+
+    for m in SCHEMA_RE.finditer(text):
+        end = _brace_end_line(text, m.end())
+        block = "\n".join(text.split("\n")[_line_of(text, m.start()) - 1:end or None])
+        cols: List[str] = []
+        for c in BLUEPRINT_COL_RE.finditer(block):
+            method, col = c.group(1), c.group(2)
+            if method in BLUEPRINT_SKIP:
+                continue
+            for name in BLUEPRINT_IMPLIED.get(method, [col] if col else []):
+                if name not in cols:
+                    cols.append(name)
+        # Schema::table() only alters: it adds columns but doesn't define the table
+        info.tables.append(TableInfo(name=m.group(2), fields=cols[:40],
+                                     line=_line_of(text, m.start()),
+                                     source=info.path if m.group(1) == "create" else ""))
+
+    for m in ELOQUENT_RE.finditer(text):
+        cls = m.group(1)
+        explicit = PHP_TABLE_PROP_RE.search(text)
+        cands = [explicit.group(1)] if explicit else _plural_candidates(_snake(cls))
+        # no source: the migration defines the table; the model links to it by edge
+        info.tables.append(TableInfo(name=cands[0], model=cls, aliases=cands,
+                                     line=_line_of(text, m.start())))
+
 LANG_PATTERNS: Dict[str, Dict[str, Pattern]] = {
     "go": {
         "function": re.compile(
@@ -173,8 +268,16 @@ def parse_generic(info: FileInfo, text: str, language: str) -> None:
             cname = cm.group(1)
             if cname in KEYWORDS or cname == name or cname in seen:
                 continue
+            if language == "php" and body[max(0, cm.start() - 2):cm.start()] == "->":
+                continue  # $obj->method(): unknown receiver, see PHP_MEMBER_CALL_RE
             seen.add(cname)
             fn.calls.append(cname)
+        if language == "php":
+            for cname in _php_member_calls(body):
+                if cname not in seen and cname != name and cname not in KEYWORDS:
+                    seen.add(cname)
+                    fn.calls.append(cname)
+            fn.db_refs.extend(_php_db_refs(body, start_line))
         fn.calls = fn.calls[:40]
         fn.description = describe(fn, body[:400])
         info.functions.append(fn)
@@ -196,6 +299,10 @@ def parse_generic(info: FileInfo, text: str, language: str) -> None:
 
     if language in ("php", "ruby"):
         extract_toplevel(info, text)
+    if language == "php":
+        parse_laravel(info, text)
+        info.imports = sorted(set(info.imports))[:60]
+        info.links = list(dict.fromkeys(info.links))[:30]
 
 
 PAGE_LINK_RE = re.compile(
@@ -218,14 +325,23 @@ def extract_toplevel(info: FileInfo, text: str) -> None:
     def outside(line: int) -> bool:
         return not any(s <= line <= e for s, e in fn_ranges)
 
+    is_php = info.language == "php"
     seen = set()
     for m in CALL_RE.finditer(text):
         name = m.group(1)
         if name in TOPLEVEL_NOISE or name in seen:
             continue
+        if is_php and text[max(0, m.start() - 2):m.start()] == "->":
+            continue
         if outside(_line_of(text, m.start())):
             seen.add(name)
             info.calls.append(name)
+    if is_php:  # routes/web.php closures call App\X::y() at top level
+        for m in PHP_MEMBER_CALL_RE.finditer(text):
+            name = m.group(1)
+            if name not in seen and name not in TOPLEVEL_NOISE and outside(_line_of(text, m.start())):
+                seen.add(name)
+                info.calls.append(name)
     info.calls = info.calls[:40]
 
     seen_l = set()