uriloop 0.3.1__py3-none-any.whl

uriloop/ai/vision.py

@@ -0,0 +1,181 @@
+"""Warstwa L5 — detekcja YOLO na zrzutach (pulpit noVNC i strona CDP).
+
+Backendy (router, rola `vision`):
+  ultralytics   — `YOLO(model)(img)`; wagi .pt (np. yolo11n.pt; do GUI: detektor ikon/elementów UI)
+  onnxruntime   — model wyeksportowany do ONNX (wyjście [1, 4+nc, N]: cx, cy, w, h, wyniki klas); bez torch
+
+Każda detekcja dostaje URN (stabilny dla klasy i przybliżonej pozycji) i gotowe Action URI kliknięcia
+w środek ramki — tym samym kanałem co elementy DOM, więc decyzja d1 i generator widzą je jednakowo.
+"""
+from __future__ import annotations
+
+import ast
+import functools
+import os
+from pathlib import Path
+
+from PIL import Image
+
+from ..uri import stable_urn
+from . import router
+
+COCO = ("person bicycle car motorcycle airplane bus train truck boat traffic_light fire_hydrant stop_sign "
+        "parking_meter bench bird cat dog horse sheep cow elephant bear zebra giraffe backpack umbrella handbag "
+        "tie suitcase frisbee skis snowboard sports_ball kite baseball_bat baseball_glove skateboard surfboard "
+        "tennis_racket bottle wine_glass cup fork knife spoon bowl banana apple sandwich orange broccoli carrot "
+        "hot_dog pizza donut cake chair couch potted_plant bed dining_table toilet tv laptop mouse remote keyboard "
+        "cell_phone microwave oven toaster sink refrigerator book clock vase scissors teddy_bear hair_drier "
+        "toothbrush").split()
+
+
+class VisionUnavailable(RuntimeError):
+    pass
+
+
+def _profiles() -> list[dict]:
+    out = []
+    override = os.environ.get("URILOOP_YOLO_MODEL")
+    want = os.environ.get("URILOOP_YOLO_BACKEND")
+    for p in router.select("vision", router.Telemetry(), require_installed=False):
+        if want and p["backend"] != want:
+            continue
+        if override:
+            if (p["backend"] == "onnxruntime") != override.endswith(".onnx"):
+                continue
+            p = {**p, "model": override}
+        out.append(p)
+    if not out:
+        raise VisionUnavailable("brak profilu vision dla URILOOP_YOLO_BACKEND/URILOOP_YOLO_MODEL")
+    return out
+
+
+@functools.lru_cache(maxsize=2)
+def _ultralytics(model: str):
+    try:
+        from ultralytics import YOLO
+    except ImportError as exc:
+        raise VisionUnavailable("pip install ultralytics (lub URILOOP_YOLO_BACKEND=onnxruntime)") from exc
+    return YOLO(model)
+
+
+@functools.lru_cache(maxsize=2)
+def _onnx(model: str):
+    try:
+        import onnxruntime as ort
+    except ImportError as exc:
+        raise VisionUnavailable("pip install onnxruntime") from exc
+    if not Path(model).exists():
+        raise VisionUnavailable(f"brak pliku modelu ONNX: {model}")
+    sess = ort.InferenceSession(model, providers=[p for p in ("CUDAExecutionProvider", "CPUExecutionProvider")
+                                                  if p in ort.get_available_providers()])
+    meta = sess.get_modelmeta().custom_metadata_map or {}
+    names = COCO
+    if meta.get("names"):
+        try:
+            d = ast.literal_eval(meta["names"])
+            names = tuple(d[i] for i in sorted(d)) if isinstance(d, dict) else tuple(d)
+        except (ValueError, SyntaxError):
+            pass
+    return sess, names
+
+
+def _letterbox(img: Image.Image, size: int):
+    import numpy as np
+    w, h = img.size
+    r = min(size / w, size / h)
+    nw, nh = round(w * r), round(h * r)
+    canvas = Image.new("RGB", (size, size), (114, 114, 114))
+    px, py = (size - nw) // 2, (size - nh) // 2
+    canvas.paste(img.convert("RGB").resize((nw, nh), Image.BILINEAR), (px, py))
+    arr = np.asarray(canvas, dtype=np.float32).transpose(2, 0, 1)[None] / 255.0
+    return arr, r, px, py
+
+
+def _nms(boxes, scores, iou: float):
+    import numpy as np
+    order = scores.argsort()[::-1]
+    keep = []
+    while order.size:
+        i = order[0]
+        keep.append(i)
+        xx1 = np.maximum(boxes[i, 0], boxes[order[1:], 0])
+        yy1 = np.maximum(boxes[i, 1], boxes[order[1:], 1])
+        xx2 = np.minimum(boxes[i, 2], boxes[order[1:], 2])
+        yy2 = np.minimum(boxes[i, 3], boxes[order[1:], 3])
+        inter = np.clip(xx2 - xx1, 0, None) * np.clip(yy2 - yy1, 0, None)
+        area = lambda b: (b[..., 2] - b[..., 0]) * (b[..., 3] - b[..., 1])  # noqa: E731
+        o = inter / (area(boxes[i]) + area(boxes[order[1:]]) - inter + 1e-9)
+        order = order[1:][o < iou]
+    return keep
+
+
+def decode_yolo(out, conf: float, iou: float, r: float, px: int, py: int, names, size_wh):
+    """Dekodowanie wyjścia YOLOv8/11 [1, 4+nc, N] → lista (x1, y1, x2, y2, score, cls) w pikselach obrazu."""
+    import numpy as np
+    pred = out[0]
+    nc4 = 4 + len(names)
+    if pred.shape[0] != nc4 and pred.shape[1] == nc4:   # wariant [N, 4+nc]
+        pred = pred.T
+    boxes, cls_scores = pred[:4].T, pred[4:].T
+    cls = cls_scores.argmax(1)
+    score = cls_scores.max(1)
+    m = score >= conf
+    boxes, cls, score = boxes[m], cls[m], score[m]
+    if not len(score):
+        return []
+    xyxy = np.stack([boxes[:, 0] - boxes[:, 2] / 2, boxes[:, 1] - boxes[:, 3] / 2,
+                     boxes[:, 0] + boxes[:, 2] / 2, boxes[:, 1] + boxes[:, 3] / 2], 1)
+    xyxy[:, [0, 2]] = (xyxy[:, [0, 2]] - px) / r
+    xyxy[:, [1, 3]] = (xyxy[:, [1, 3]] - py) / r
+    W, H = size_wh
+    xyxy[:, [0, 2]] = xyxy[:, [0, 2]].clip(0, W)
+    xyxy[:, [1, 3]] = xyxy[:, [1, 3]].clip(0, H)
+    out = []
+    for c in np.unique(cls):
+        idx = np.where(cls == c)[0]
+        for k in _nms(xyxy[idx], score[idx], iou):
+            j = idx[k]
+            out.append((*map(float, xyxy[j]), float(score[j]), int(c)))
+    return sorted(out, key=lambda d: -d[4])
+
+
+def detect(img: Image.Image, *, scope: str = "desktop", dpr: float = 1.0, conf: float | None = None,
+           iou: float = 0.45, max_det: int = 100) -> dict:
+    errors = []
+    for p in _profiles():
+        try:
+            return _detect_with(p, img, scope, dpr, conf, iou, max_det)
+        except VisionUnavailable as exc:
+            errors.append(f"{p['id']}: {exc}")
+    raise VisionUnavailable("; ".join(errors))
+
+
+def _detect_with(p: dict, img: Image.Image, scope: str, dpr: float, conf: float | None, iou: float, max_det: int) -> dict:
+    conf = conf if conf is not None else float(p.get("conf", 0.25))
+    raw = []
+    if p["backend"] == "ultralytics":
+        model = _ultralytics(p["model"])
+        res = model.predict(img.convert("RGB"), conf=conf, iou=iou, verbose=False, max_det=max_det)[0]
+        names = res.names
+        for b in res.boxes:
+            x1, y1, x2, y2 = (float(v) for v in b.xyxy[0].tolist())
+            raw.append((x1, y1, x2, y2, float(b.conf[0]), int(b.cls[0])))
+    else:
+        sess, names = _onnx(p["model"])
+        size = int(p.get("imgsz", 640))
+        arr, r, px, py = _letterbox(img, size)
+        out = sess.run(None, {sess.get_inputs()[0].name: arr})[0]
+        raw = decode_yolo(out, conf, iou, r, px, py, names, img.size)
+    dets = []
+    for x1, y1, x2, y2, s, c in raw[:max_det]:
+        label = names[c] if c < len(names) else str(c)
+        cx, cy = (x1 + x2) / 2, (y1 + y2) / 2
+        u = stable_urn("det", scope, label, round(cx / 24), round(cy / 24))
+        if scope == "desktop":
+            act = f"desktop://pointer/click?x={int(cx)}&y={int(cy)}"
+        else:
+            act = f"browser://page/click?x={round(cx / dpr, 1)}&y={round(cy / dpr, 1)}"
+        dets.append({"urn": u, "kind": "detection", "name": label, "label": label, "conf": round(s, 4),
+                     "rect": {"x": int(x1), "y": int(y1), "w": int(x2 - x1), "h": int(y2 - y1)},
+                     "center": {"x": int(cx), "y": int(cy)}, "in_viewport": True, "actions": [act]})
+    return {"profile": p["id"], "model": p["model"], "backend": p["backend"], "detections": dets}

uriloop/analysis/dom_probe.js

@@ -0,0 +1,108 @@
+// Sonda DOM: wykrywa elementy interaktywne, formularze, zasoby i kandydatów żądań.
+// Zwraca czysty JSON (returnByValue). Bez efektów ubocznych poza atrybutem data-uriloop-idx.
+(() => {
+  const INTERACTIVE = 'a[href],button,input,select,textarea,summary,details,label[for],' +
+    '[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=switch],' +
+    '[role=option],[role=combobox],[role=textbox],[role=searchbox],[onclick],[contenteditable=""],' +
+    '[contenteditable=true],[tabindex]:not([tabindex="-1"])';
+  const out = { page: {}, elements: [], forms: [], headings: [], resources: [], text: '' };
+  const vw = innerWidth, vh = innerHeight;
+
+  const cssEsc = (s) => (window.CSS && CSS.escape) ? CSS.escape(s) : s.replace(/[^\w-]/g, '\\$&');
+  function selectorOf(el) {
+    if (el.id && document.querySelectorAll('#' + cssEsc(el.id)).length === 1) return '#' + cssEsc(el.id);
+    for (const a of ['data-testid', 'data-test', 'data-qa', 'name', 'aria-label']) {
+      const v = el.getAttribute(a);
+      if (v) {
+        const s = `${el.tagName.toLowerCase()}[${a}="${v.replace(/"/g, '\\"')}"]`;
+        try { if (document.querySelectorAll(s).length === 1) return s; } catch (e) {}
+      }
+    }
+    const path = [];
+    for (let n = el; n && n.nodeType === 1 && n !== document.documentElement; n = n.parentElement) {
+      let i = 1;
+      for (let s = n.previousElementSibling; s; s = s.previousElementSibling) if (s.tagName === n.tagName) i++;
+      path.unshift(`${n.tagName.toLowerCase()}:nth-of-type(${i})`);
+      if (n.id && document.querySelectorAll('#' + cssEsc(n.id)).length === 1) { path[0] = '#' + cssEsc(n.id); break; }
+    }
+    return path.join(' > ');
+  }
+  const clean = (s, n = 120) => (s || '').replace(/\s+/g, ' ').trim().slice(0, n);
+  function nameOf(el) {
+    const lbl = el.labels && el.labels[0] ? el.labels[0].innerText : '';
+    const by = el.getAttribute('aria-labelledby');
+    const byText = by ? by.split(/\s+/).map(id => (document.getElementById(id) || {}).innerText || '').join(' ') : '';
+    return clean(el.getAttribute('aria-label') || byText || lbl || el.innerText || (el.type === 'password' ? '' : el.value) ||
+      el.getAttribute('placeholder') || el.getAttribute('title') || el.getAttribute('alt') ||
+      (el.querySelector && el.querySelector('img[alt]') ? el.querySelector('img[alt]').alt : '') || el.name || '');
+  }
+  function kindOf(el) {
+    const t = el.tagName.toLowerCase(), role = el.getAttribute('role'), type = (el.getAttribute('type') || '').toLowerCase();
+    if (t === 'a') return 'navigate';
+    if (t === 'select' || role === 'combobox' || role === 'option') return 'select';
+    if (t === 'textarea' || el.isContentEditable || role === 'textbox' || role === 'searchbox') return 'input';
+    if (t === 'input') {
+      if (['checkbox', 'radio'].includes(type)) return 'toggle';
+      if (['submit', 'image'].includes(type)) return 'submit';
+      if (['button', 'reset'].includes(type)) return 'click';
+      if (type === 'file') return 'upload';
+      return 'input';
+    }
+    if (t === 'button') return (el.form && (type === 'submit' || type === '')) ? 'submit' : 'click';
+    if (['checkbox', 'radio', 'switch'].includes(role)) return 'toggle';
+    return 'click';
+  }
+  function visible(el, r) {
+    if (r.width < 1 || r.height < 1) return false;
+    const cs = getComputedStyle(el);
+    if (cs.visibility === 'hidden' || cs.display === 'none' || +cs.opacity === 0) return false;
+    return true;
+  }
+
+  const seen = new Set();
+  const collect = (root) => {
+    root.querySelectorAll(INTERACTIVE).forEach((el) => {
+      if (seen.has(el)) return; seen.add(el);
+      const r = el.getBoundingClientRect();
+      const vis = visible(el, r);
+      const inView = vis && r.bottom > 0 && r.right > 0 && r.top < vh && r.left < vw;
+      const cx = Math.round(r.left + r.width / 2), cy = Math.round(r.top + r.height / 2);
+      let occluded = false;
+      if (inView) { const hit = document.elementFromPoint(cx, cy); occluded = !!hit && hit !== el && !el.contains(hit) && !hit.contains(el); }
+      const form = el.form || el.closest('form');
+      const idx = out.elements.length;
+      el.setAttribute('data-uriloop-idx', String(idx));
+      out.elements.push({
+        idx, tag: el.tagName.toLowerCase(), role: el.getAttribute('role') || null,
+        type: el.getAttribute('type') || null, kind: kindOf(el), name: nameOf(el),
+        selector: selectorOf(el), href: el.href || null,
+        download: el.hasAttribute('download') ? el.getAttribute('download') : null,
+        value: (el.type === 'password') ? (el.value ? '***' : '') : clean(el.value, 60) || null,
+        checked: ('checked' in el) ? !!el.checked : null,
+        disabled: !!(el.disabled || el.getAttribute('aria-disabled') === 'true'),
+        visible: vis, in_viewport: inView, occluded,
+        rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) },
+        center: { x: cx, y: cy },
+        form: form ? { action: form.action || location.href, method: (form.method || 'get').toUpperCase(), selector: selectorOf(form) } : null,
+        handlers: { onclick: !!el.onclick || el.hasAttribute('onclick') },
+      });
+    });
+    root.querySelectorAll('*').forEach((n) => { if (n.shadowRoot) collect(n.shadowRoot); });
+  };
+  collect(document);
+
+  document.querySelectorAll('form').forEach((f) => out.forms.push({
+    selector: selectorOf(f), action: f.action || location.href, method: (f.method || 'get').toUpperCase(),
+    fields: Array.from(f.elements).filter(e => e.name).map(e => ({ name: e.name, type: e.type, required: !!e.required })),
+  }));
+  document.querySelectorAll('h1,h2,h3,[role=heading]').forEach((h) => {
+    const t = clean(h.innerText, 160); if (t) out.headings.push({ level: h.tagName.toLowerCase(), text: t });
+  });
+  (performance.getEntriesByType('resource') || []).slice(-300).forEach((e) => out.resources.push({
+    url: e.name, initiator: e.initiatorType, bytes: e.transferSize || 0, ms: Math.round(e.duration),
+  }));
+  out.page = { url: location.href, title: document.title, origin: location.origin, w: vw, h: vh,
+    dpr: devicePixelRatio, sx: scrollX, sy: scrollY, ready: document.readyState, lang: document.documentElement.lang || null };
+  out.text = clean(document.body ? document.body.innerText : '', 4000);
+  return out;
+})()

uriloop/analysis/file_transfer.js

@@ -0,0 +1,53 @@
+// Transfer bytes through CDP: no shared host/Chromium filesystem required.
+(() => ({
+  fetch: async ({selector, max_bytes, timeout_ms}) => {
+    const nodes = document.querySelectorAll(selector);
+    if (nodes.length !== 1 || nodes[0].tagName !== 'A') throw Error('link disappeared');
+    const link = nodes[0], url = new URL(link.href);
+    if (!['http:', 'https:'].includes(url.protocol) || url.origin !== location.origin)
+      throw Error('same-origin HTTP link required');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout_ms);
+    try {
+      const response = await fetch(url, {mode: 'same-origin', credentials: 'same-origin',
+        redirect: 'error', signal: controller.signal});
+      if (!response.ok) throw Error('HTTP ' + response.status);
+      if (response.status === 206) throw Error('partial HTTP response');
+      if (+response.headers.get('content-length') > max_bytes) throw Error('file exceeds max_bytes');
+      const reader = response.body.getReader(), chunks = [];
+      let size = 0;
+      for (;;) {
+        const {done, value} = await reader.read();
+        if (done) break;
+        size += value.length;
+        if (size > max_bytes) { await reader.cancel(); throw Error('file exceeds max_bytes'); }
+        chunks.push(value);
+      }
+      let binary = '';
+      for (const chunk of chunks) {
+        for (let offset = 0; offset < chunk.length; offset += 8192)
+          binary += String.fromCharCode(...chunk.subarray(offset, offset + 8192));
+      }
+      return {data: btoa(binary), bytes: size, mime: (response.headers.get('content-type') ||
+        'application/octet-stream').split(';')[0].trim().toLowerCase(),
+        name: link.download || decodeURIComponent(url.pathname.split('/').pop()) || 'download.bin',
+        url: response.url, status: response.status};
+    } finally { clearTimeout(timer); controller.abort(); }
+  },
+  attach: ({selector, data, name, mime, clear}) => {
+    const nodes = document.querySelectorAll(selector);
+    if (nodes.length !== 1) throw Error('file input disappeared');
+    const input = nodes[0];
+    if (input.tagName !== 'INPUT' || input.type !== 'file' || input.disabled)
+      throw Error('active file input required');
+    const transfer = new DataTransfer();
+    if (!clear) {
+      const bytes = Uint8Array.from(atob(data), ch => ch.charCodeAt(0));
+      transfer.items.add(new File([bytes], name, {type: mime}));
+    }
+    input.files = transfer.files;
+    input.dispatchEvent(new Event('input', {bubbles: true}));
+    input.dispatchEvent(new Event('change', {bubbles: true}));
+    return {count: input.files.length};
+  }
+}))()

uriloop/analysis/layers.py

@@ -0,0 +1,211 @@
+"""Warstwowa analiza ekranu.
+
+L0 pixels    — zrzut PNG/WebP, sha256, dHash, różnica względem poprzedniego zrzutu, siatka regionów
+L1 dom       — elementy interaktywne z sondy DOM (selektor, rect, rola, nazwa, stan)
+L2 actions   — każdy element => URN + zestaw Action URI (click/type/navigate/select/toggle)
+L3 network   — żądania CDP + zasoby performance + endpointy formularzy => URN, powiązania element→żądanie
+L4 semantic  — streszczenie: tytuł, nagłówki, formularze, tekst, liczniki; Set-of-Mark (adnotowany zrzut)
+
+Wszystkie funkcje są czyste (dane wejściowe => słownik), więc testowalne bez przeglądarki.
+"""
+from __future__ import annotations
+
+import hashlib
+import io
+from pathlib import Path
+from urllib.parse import urlsplit, urlunsplit
+
+from PIL import Image, ImageDraw, ImageStat
+
+from ..uri import ActionUri, stable_urn
+
+PROBE_JS = (Path(__file__).with_name("dom_probe.js")).read_text(encoding="utf-8")
+LAYERS = ("pixels", "dom", "actions", "network", "semantic")
+
+
+# ---------------- L0: piksele ----------------
+def encode(img: Image.Image, fmt: str = "png", quality: int = 80) -> bytes:
+    buf = io.BytesIO()
+    if fmt == "webp":
+        img.save(buf, "WEBP", quality=quality, method=4)
+    elif fmt == "jpeg":
+        img.convert("RGB").save(buf, "JPEG", quality=quality)
+    else:
+        img.save(buf, "PNG", optimize=True)
+    return buf.getvalue()
+
+
+def dhash(img: Image.Image, size: int = 8) -> str:
+    g = img.convert("L").resize((size + 1, size), Image.BILINEAR)
+    px = g.tobytes()
+    bits = 0
+    for row in range(size):
+        for col in range(size):
+            bits = (bits << 1) | (px[row * (size + 1) + col] > px[row * (size + 1) + col + 1])
+    return f"{bits:0{size * size // 4}x}"
+
+
+def hamming(a: str, b: str) -> int:
+    return bin(int(a, 16) ^ int(b, 16)).count("1")
+
+
+def grid_regions(img: Image.Image, n: int = 8, prev: Image.Image | None = None, scope: str = "screen") -> list[dict]:
+    """Siatka n×n: jasność, wariancja (czy region ma treść), zmiana względem poprzedniej klatki."""
+    w, h = img.size
+    gray = img.convert("L")
+    pgray = prev.convert("L").resize((w, h)) if prev is not None else None
+    out = []
+    for gy in range(n):
+        for gx in range(n):
+            box = (gx * w // n, gy * h // n, (gx + 1) * w // n, (gy + 1) * h // n)
+            cell = gray.crop(box)
+            st = ImageStat.Stat(cell)
+            changed = None
+            if pgray is not None:
+                a = cell.resize((16, 16))
+                b = pgray.crop(box).resize((16, 16))
+                diff = sum(abs(x - y) for x, y in zip(a.tobytes(), b.tobytes())) / (256 * 255)
+                changed = round(diff, 4)
+            cx, cy = (box[0] + box[2]) // 2, (box[1] + box[3]) // 2
+            out.append({
+                "urn": stable_urn("region", scope, n, gx, gy), "gx": gx, "gy": gy,
+                "rect": {"x": box[0], "y": box[1], "w": box[2] - box[0], "h": box[3] - box[1]},
+                "center": {"x": cx, "y": cy}, "mean": round(st.mean[0], 1),
+                "stddev": round(st.stddev[0], 1), "content": st.stddev[0] > 12, "changed": changed,
+            })
+    return out
+
+
+def pixel_layer(img: Image.Image, fmt: str, prev: Image.Image | None = None, grid: int = 8,
+                scope: str = "screen", quality: int = 80) -> tuple[dict, bytes]:
+    data = encode(img, fmt, quality)
+    regions = grid_regions(img, grid, prev, scope)
+    changes = [r["changed"] for r in regions if r["changed"] is not None]
+    layer = {
+        "format": fmt, "width": img.size[0], "height": img.size[1], "bytes": len(data),
+        "sha256": hashlib.sha256(data).hexdigest(), "dhash": dhash(img),
+        "change_ratio": round(sum(c > 0.02 for c in changes) / len(changes), 3) if changes else None,
+        "regions": regions,
+    }
+    return layer, data
+
+
+# ---------------- L1+L2: DOM i akcje ----------------
+def _origin_path(url: str) -> str:
+    u = urlsplit(url or "")
+    return urlunsplit((u.scheme, u.netloc, u.path, "", ""))
+
+
+def element_urn(page_url: str, el: dict, tab_urn: str | None = None) -> str:
+    """Stabilny adres komponentu we wskazanej karcie i stronie (bez query)."""
+    return stable_urn("el", tab_urn or '', _origin_path(page_url), el.get("selector"), el.get("tag"),
+                      el.get("role") or "", (el.get("name") or "")[:60])
+
+
+def actions_for(el: dict, scheme: str = "browser") -> list[str]:
+    u = el["urn"]
+    if el.get("disabled"):
+        return []
+    k = el["kind"]
+    acts = []
+    if k == "navigate" and el.get("href") and not el["href"].startswith("javascript:"):
+        acts.append(str(ActionUri(scheme, "page", "navigate", {"url": el["href"]})))
+        if el['href'].startswith(('http://', 'https://')):
+            acts.append(str(ActionUri(scheme, 'tabs', 'open', {'urn': u})))
+        if el.get('download') is not None:
+            acts.append(str(ActionUri(scheme, 'file', 'fetch', {'urn': u})))
+    if k == 'upload':
+        acts.append(str(ActionUri(scheme, 'page', 'attach', {'urn': u, 'clear': True})))
+    if k in ("input",):
+        if el.get('type') == 'password':
+            acts.append(str(ActionUri(scheme, 'page', 'secret', {'urn':u, 'env':'URILOOP_SECRET_PASSWORD'})))
+        else:
+            acts.append(str(ActionUri(scheme, "page", "type", {"urn": u, "text": ""})))
+    if k in ("navigate", "click", "submit", "toggle", "select", "upload", "input"):
+        acts.insert(0, str(ActionUri(scheme, "page", "click", {"urn": u})))
+    return acts
+
+
+def dom_layers(probe: dict) -> tuple[list[dict], list[dict]]:
+    page_url = probe.get("page", {}).get("url", "")
+    elements = []
+    for el in probe.get("elements", []):
+        e = dict(el)
+        e["urn"] = element_urn(page_url, el, probe.get('page', {}).get('tab_urn'))
+        e["actions"] = actions_for(e)
+        elements.append(e)
+    forms = []
+    for f in probe.get("forms", []):
+        forms.append({**f, "urn": stable_urn("form", probe.get('page', {}).get('tab_urn') or '', _origin_path(page_url), f["selector"]),
+                      "endpoint": stable_urn("endpoint", f["method"], _origin_path(f["action"]))})
+    return elements, forms
+
+
+# ---------------- L3: sieć ----------------
+def network_layer(requests: list[dict], probe: dict, elements: list[dict], forms: list[dict]) -> dict:
+    reqs = [dict(r) for r in requests]
+    by_url: dict[str, str] = {}
+    for r in reqs:
+        r.setdefault("urn", stable_urn("req", r.get("method", "GET"), r["url"].split("#")[0], r.get("id", "")))
+        r["endpoint"] = stable_urn("endpoint", r.get("method", "GET"), _origin_path(r["url"]))
+        by_url.setdefault(r["url"].split("#")[0], r["urn"])
+    resources = []
+    for res in probe.get("resources", []):
+        resources.append({**res, "urn": stable_urn("res", res["url"].split("#")[0]),
+                          "request": by_url.get(res["url"].split("#")[0])})
+    links = []
+    for e in elements:
+        target = None
+        if e.get("href"):
+            target = stable_urn("endpoint", "GET", _origin_path(e["href"]))
+        elif e.get("kind") == "submit" and e.get("form"):
+            target = stable_urn("endpoint", e["form"]["method"], _origin_path(e["form"]["action"]))
+        if target:
+            e["triggers"] = target
+            links.append({"element": e["urn"], "endpoint": target})
+    endpoints = sorted({r["endpoint"] for r in reqs} | {f["endpoint"] for f in forms} | {lk["endpoint"] for lk in links})
+    return {"requests": reqs, "resources": resources, "links": links, "endpoints": endpoints,
+            "failed": [r["urn"] for r in reqs if r.get("failed") or (r.get("status") or 0) >= 400]}
+
+
+# ---------------- L4: semantyka + Set-of-Mark ----------------
+def semantic_layer(probe: dict, elements: list[dict], forms: list[dict]) -> dict:
+    vis = [e for e in elements if e.get("in_viewport") and not e.get("occluded")]
+    kinds: dict[str, int] = {}
+    for e in elements:
+        kinds[e["kind"]] = kinds.get(e["kind"], 0) + 1
+    page = probe.get("page", {})
+    return {
+        "title": page.get("title"), "url": page.get("url"), "lang": page.get("lang"),
+        "headings": probe.get("headings", [])[:20], "forms": len(forms), "kinds": kinds,
+        "visible_actions": [{"mark": i + 1, "urn": e["urn"], "kind": e["kind"], "name": e["name"]}
+                            for i, e in enumerate(vis[:60])],
+        "text_excerpt": (probe.get("text") or "")[:800],
+    }
+
+
+def annotate(img: Image.Image, elements: list[dict], dpr: float = 1.0) -> Image.Image:
+    """Set-of-Mark: numerowane ramki widocznych elementów (dla VLM i człowieka)."""
+    out = img.convert("RGB").copy()
+    d = ImageDraw.Draw(out)
+    palette = {"navigate": (37, 99, 235), "submit": (220, 38, 38), "input": (22, 163, 74),
+               "toggle": (202, 138, 4), "select": (147, 51, 234), "click": (234, 88, 12), "upload": (8, 145, 178)}
+    vis = [e for e in elements if e.get("in_viewport") and not e.get("occluded")]
+    for i, e in enumerate(vis[:60], 1):
+        r = e["rect"]
+        x0, y0 = r["x"] * dpr, r["y"] * dpr
+        x1, y1 = x0 + r["w"] * dpr, y0 + r["h"] * dpr
+        col = palette.get(e["kind"], (100, 100, 100))
+        d.rectangle([x0, y0, x1, y1], outline=col, width=2)
+        label = str(i)
+        d.rectangle([x0, max(0, y0 - 14), x0 + 7 * len(label) + 6, max(14, y0)], fill=col)
+        d.text((x0 + 3, max(0, y0 - 13)), label, fill=(255, 255, 255))
+    return out
+
+
+def summarize(sem: dict, net: dict | None) -> str:
+    k = ", ".join(f"{v} {n}" for n, v in sorted(sem.get("kinds", {}).items()))
+    s = f"{sem.get('title') or sem.get('url')}: {k or 'brak elementów'}"
+    if net:
+        s += f"; {len(net['requests'])} żądań, {len(net['failed'])} błędnych"
+    return s