s-librarykit 0.2.0__tar.gz → 0.3.0__tar.gz

{s_librarykit-0.2.0 → s_librarykit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s-librarykit
-Version: 0.2.0
+Version: 0.3.0
 Summary: Жирный КОРЕНЬ китов: единая error-иерархия, config/retry/paths-утили, checkpoint/resume, транспорт/auth/sessions — общий код для clikit, adapterkit и доменных пакетов.
 Author: Dmitry
 License: MIT

{s_librarykit-0.2.0 → s_librarykit-0.3.0}/librarykit/__init__.py

@@ -10,6 +10,11 @@ from __future__ import annotations
 
 # blocks (W8): GENERIC draft.js richtext block-хелперы (текст/заголовок/список).
 from librarykit import blocks
+
+# antibot warmup-минт (W4): генерик-«монетный двор» одноразовых токенов тёплой
+# страницей (обобщение chatgpt Sentinel). Механика в ките, семантика (trigger/
+# match) — у сервиса. Тянет только stdlib — реэкспорт наверх безопасен.
+from librarykit.antibot import TokenHarvest, WarmupTokenMinter
 from librarykit.auth import (
     CSRF_DEFAULT_HEADER,
     BrowserLoginAuth,
@@ -244,7 +249,7 @@ from librarykit.windows import (
     parse_window,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "__version__",
@@ -383,6 +388,9 @@ __all__ = [
     "CalendarWindow",
     "FixedWindow",
     "parse_window",
+    # antibot: warmup-минт одноразовых токенов тёплой страницей (генерик)
+    "WarmupTokenMinter",
+    "TokenHarvest",
     # pool: балансер N аккаунтов одного сервиса (селектор поверх SessionStore)
     "SessionPool",
     "PoolChoice",

{s_librarykit-0.2.0 → s_librarykit-0.3.0}/librarykit/antibot/__init__.py

@@ -91,6 +91,7 @@ from .page_evaluate import (
     page_fetch,
     sync_page_fetch,
 )
+from .warmup_minter import TokenHarvest, WarmupTokenMinter
 
 # Первичные ролевые имена исполнителей запроса (роль снаружи, вендор — внутри):
 #   ImpersonatedHttpExecutor  — TLS/JA3-impersonate (curl-cffi) [было CurlCffiTransport];
@@ -116,6 +117,9 @@ __all__ = [
     "page_fetch",
     "sync_page_fetch",
     "pick_chrome_impersonate",
+    # warmup-минт одноразовых токенов тёплой страницей (генерик chatgpt-паттерна)
+    "WarmupTokenMinter",
+    "TokenHarvest",
     # первичные ролевые имена (псевдонимы вендор-классов выше)
     "ImpersonatedHttpExecutor",
     "BrowserRequestExecutor",

s_librarykit-0.3.0/librarykit/antibot/warmup_minter.py

@@ -0,0 +1,255 @@
+"""Генерик-«монетный двор» одноразовых токенов тёплой браузер-страницей.
+
+Обобщение эталон-паттерна chatgpt (`sentinel_flow.mint_from_page`): некоторые
+антибот-защиты (ChatGPT Sentinel, ряд signing-схем) выдают СВЕЖИЙ одноразовый
+токен в служебном запросе, который стреляет сама страница при взаимодействии
+(например ввод в композер БЕЗ отправки). Токен НЕ привязан к TLS-сессии браузера
+→ его можно ПЕРЕНЕСТИ во внешний httpx. Браузер нужен лишь чтобы РАЗ в окно TTL
+начеканить неизрасходованный токен; сам запрос браузер НЕ сабмитит (иначе токен
+сгорит и во httpx даст 403).
+
+Механика в ките (нейтральна к сервису), СЕМАНТИКА — у сервиса:
+
+- сервис даёт `trigger(page)` — как спровоцировать служебный запрос (ввод в
+  композер, клик, `page.evaluate` — что угодно, но БЕЗ финальной отправки);
+- сервис даёт `match(request)` — как опознать нужный запрос (по URL/методу);
+- кит навешивает `page.on("request"/"response")`, перехватывает `all_headers()`
+  + `post_data` запроса и тело ответа, снимает cookies из `context`, собирает
+  всё в :class:`TokenHarvest` для внешнего httpx.
+
+Работает поверх нейтральной :class:`librarykit.contract.BrowserSession`
+(`ensure_page()` / `context` / `aclose()`) — движок (CamouFox / CDP-Edge /
+обычный chromium) выбирается фабрикой снаружи, минтеру безразличен.
+"""
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import time
+from collections.abc import Awaitable, Callable, Iterable
+from dataclasses import dataclass, field
+from typing import Any
+
+from librarykit.errors import Blocked
+
+__all__ = ["TokenHarvest", "WarmupTokenMinter"]
+
+
+@dataclass(slots=True)
+class TokenHarvest:
+    """Снимок одного «окна чеканки»: всё нужное внешнему httpx для одного turn'а.
+
+    Собирается :meth:`WarmupTokenMinter.mint` из перехвата служебного запроса
+    (request `all_headers` + `post_data`) и его ответа (тело), плюс cookies живой
+    сессии. Токен внутри `response_body`/`request_body` — как правило ОДНОРАЗОВЫЙ;
+    окно валидности задаёт сервис (см. :meth:`is_expired`).
+    """
+
+    request_headers: dict[str, str]        # живые заголовки служебного запроса (lower-case)
+    request_body: str | None               # сырое тело запроса (proof/turnstile/prepare и пр.)
+    response_body: str | None              # сырое тело ответа (обычно содержит `.token`)
+    cookies: list[dict[str, Any]] = field(default_factory=list)  # снимок context.cookies()
+    minted_at: float = 0.0                 # time.time() момента минта
+
+    def cookie_header(self, domain_substr: str = "") -> str:
+        """Склеить `Cookie:`-заголовок из cookies нужного домена для httpx.
+
+        `domain_substr` — подстрока домена cookie (напр. ``"chatgpt.com"``);
+        пустая строка → берём все cookies. Пары `name=value` через `"; "`.
+        """
+        return "; ".join(
+            f"{c.get('name')}={c.get('value')}"
+            for c in self.cookies
+            if not domain_substr or domain_substr in (c.get("domain") or "")
+        )
+
+    def pick_headers(self, keep: Iterable[str]) -> dict[str, str]:
+        """Подмножество `request_headers` по allowlist (регистронезависимо).
+
+        Возвращает только те заголовки, чьё имя (в нижнем регистре) есть в `keep` —
+        чтобы перенести во внешний httpx лишь живые/нужные (authorization/oai-*/
+        sec-*), не таща служебные (`content-length`, `cookie` и пр.).
+        """
+        wanted = {k.lower() for k in keep}
+        return {k: v for k, v in self.request_headers.items() if k.lower() in wanted}
+
+    def is_expired(self, ttl_s: float, skew: float = 0.0) -> bool:
+        """Окно чеканки исчерпано: `now >= minted_at + ttl_s - skew`.
+
+        `skew` — запас (сек), чтобы обновиться ДО фактического протухания.
+        Не минтился (`minted_at == 0`) → считается протухшим.
+        """
+        if self.minted_at <= 0:
+            return True
+        return time.time() >= (self.minted_at + ttl_s - skew)
+
+
+# Значения `capture`: что ждём от перехвата, прежде чем считать чеканку успешной.
+_CAPTURE_MODES = frozenset({"both", "request", "response"})
+
+
+class WarmupTokenMinter:
+    """Чеканит :class:`TokenHarvest` из служебного запроса тёплой страницы.
+
+    Кит владеет МЕХАНИКОЙ (навесить листенеры, перехватить request/response,
+    снять cookies, не сабмитить), сервис — СЕМАНТИКОЙ (`trigger` провоцирует
+    запрос, `match` опознаёт его). Страница поднимается лениво из нейтральной
+    `session_factory` (`() -> BrowserSession`); при провале «уставшей» тёплой
+    страницы (нет match / исключение) `recreate_on_fail` пересоздаёт сессию и
+    повторяет ОДИН раз со свежей — это чинит деградацию тёплой страницы на 3-м+
+    вызове (эмпирика chatgpt).
+    """
+
+    def __init__(
+        self,
+        session_factory: Callable[[], Any],
+        *,
+        recreate_on_fail: bool = True,
+    ) -> None:
+        self._session_factory = session_factory
+        self._recreate_on_fail = recreate_on_fail
+
+    async def mint(
+        self,
+        *,
+        trigger: Callable[[Any], Awaitable[None]],
+        match: Callable[[Any], bool],
+        timeout_ms: int = 20_000,
+        capture: str = "both",
+    ) -> TokenHarvest:
+        """Начеканить свежий токен: `trigger` стреляет запрос, `match` его ловит.
+
+        - `trigger(page)` — спровоцировать служебный запрос (ввод/клик БЕЗ отправки);
+        - `match(request)` — предикат «это нужный запрос» (по URL/методу);
+        - `timeout_ms` — сколько ждать перехвата после `trigger`;
+        - `capture` — что требуется поймать: ``"request"`` (заголовки+тело запроса),
+          ``"response"`` (тело ответа) или ``"both"`` (по умолчанию).
+
+        Запрос НЕ сабмитится. При провале и `recreate_on_fail` — закрыть сессию и
+        повторить один раз со свежей. Бросает :class:`librarykit.errors.Blocked`,
+        если перехват не удался.
+        """
+        if capture not in _CAPTURE_MODES:
+            raise ValueError(
+                f"capture должен быть одним из {sorted(_CAPTURE_MODES)}, не {capture!r}"
+            )
+
+        session = self._session_factory()
+        try:
+            return await self._mint_once(
+                session, trigger=trigger, match=match, timeout_ms=timeout_ms, capture=capture,
+            )
+        except Exception:
+            if not self._recreate_on_fail:
+                raise
+            await self._safe_aclose(session)
+
+        # Повтор ОДИН раз со свежей сессией (тёплая страница «устала»).
+        fresh = self._session_factory()
+        try:
+            return await self._mint_once(
+                fresh, trigger=trigger, match=match, timeout_ms=timeout_ms, capture=capture,
+            )
+        except Exception:
+            await self._safe_aclose(fresh)
+            raise
+
+    async def _mint_once(
+        self,
+        session: Any,
+        *,
+        trigger: Callable[[Any], Awaitable[None]],
+        match: Callable[[Any], bool],
+        timeout_ms: int,
+        capture: str,
+    ) -> TokenHarvest:
+        """Одна попытка чеканки на конкретной сессии (без пересоздания)."""
+        page = await session.ensure_page()
+        state: dict[str, Any] = {"req_headers": None, "req_body": None, "resp_body": None}
+        pending: list[asyncio.Future[Any]] = []
+
+        async def _grab_request(req: Any) -> None:
+            try:
+                if state["req_headers"] is None and match(req):
+                    state["req_headers"] = dict(await req.all_headers())
+                    state["req_body"] = req.post_data
+            except Exception:  # перехват best-effort, не должен рушить минт
+                pass
+
+        async def _grab_response(resp: Any) -> None:
+            try:
+                req = getattr(resp, "request", None)
+                if state["resp_body"] is None and req is not None and match(req):
+                    body = await resp.body()
+                    if isinstance(body, (bytes, bytearray)):
+                        state["resp_body"] = bytes(body).decode("utf-8", "replace")
+                    elif body is not None:
+                        state["resp_body"] = str(body)
+            except Exception:  # перехват best-effort, не должен рушить минт
+                pass
+
+        def _on_request(req: Any) -> None:
+            pending.append(asyncio.ensure_future(_grab_request(req)))
+
+        def _on_response(resp: Any) -> None:
+            pending.append(asyncio.ensure_future(_grab_response(resp)))
+
+        page.on("request", _on_request)
+        page.on("response", _on_response)
+        try:
+            await trigger(page)  # провоцируем служебный запрос; НЕ сабмитим
+            loop = asyncio.get_running_loop()
+            deadline = loop.time() + timeout_ms / 1000
+            while loop.time() < deadline:
+                if pending:
+                    await asyncio.gather(*pending, return_exceptions=True)
+                    pending.clear()
+                if _is_captured(state, capture):
+                    break
+                await asyncio.sleep(0.05)
+            if pending:  # добрать последние перехваты
+                await asyncio.gather(*pending, return_exceptions=True)
+                pending.clear()
+            cookies = list(await session.context.cookies())
+        finally:
+            with contextlib.suppress(Exception):
+                page.remove_listener("request", _on_request)
+            with contextlib.suppress(Exception):
+                page.remove_listener("response", _on_response)
+
+        if not _is_captured(state, capture):
+            raise Blocked(
+                f"чеканка токена не удалась: служебный запрос не перехвачен "
+                f"(capture={capture!r}, получено: {_captured_keys(state)}). "
+                "Проверь trigger/match и что страница залогинена/тёплая."
+            )
+
+        return TokenHarvest(
+            request_headers=state["req_headers"] or {},
+            request_body=state["req_body"],
+            response_body=state["resp_body"],
+            cookies=cookies,
+            minted_at=time.time(),
+        )
+
+    @staticmethod
+    async def _safe_aclose(session: Any) -> None:
+        """Закрыть сессию, гася любые ошибки закрытия (best-effort cleanup)."""
+        with contextlib.suppress(Exception):
+            await session.aclose()
+
+
+def _is_captured(state: dict[str, Any], capture: str) -> bool:
+    """Достаточно ли перехвачено под режим `capture`."""
+    have_req = state["req_headers"] is not None
+    have_resp = state["resp_body"] is not None
+    if capture == "request":
+        return have_req
+    if capture == "response":
+        return have_resp
+    return have_req and have_resp
+
+
+def _captured_keys(state: dict[str, Any]) -> list[str]:
+    """Что уже поймано (для диагностического сообщения)."""
+    return sorted(k for k, v in state.items() if v is not None)

{s_librarykit-0.2.0 → s_librarykit-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "s-librarykit"
-version = "0.2.0"
+version = "0.3.0"
 description = "Жирный КОРЕНЬ китов: единая error-иерархия, config/retry/paths-утили, checkpoint/resume, транспорт/auth/sessions — общий код для clikit, adapterkit и доменных пакетов."
 readme = "README.md"
 license = { text = "MIT" }

s_librarykit-0.3.0/tests/test_warmup_minter.py

@@ -0,0 +1,319 @@
+"""Тесты генерик-минтера одноразовых токенов (`WarmupTokenMinter` + `TokenHarvest`).
+
+Без реального браузера: фейковая `BrowserSession` (`ensure_page` / `context` /
+`aclose`) с фейковой playwright-подобной страницей, которая на `trigger`
+«эмитит» перехватываемые request/response через сохранённые листенеры. Проверяем:
+- trigger вызывается, match фильтрует, harvest собирает headers/body/cookies;
+- capture-режимы (`request` / `response` / `both`);
+- при провале `recreate_on_fail` пересоздаёт сессию и повторяет один раз;
+- helper'ы `TokenHarvest` (cookie_header / pick_headers / is_expired).
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import pytest
+
+from librarykit import TokenHarvest, WarmupTokenMinter
+from librarykit.antibot import TokenHarvest as TokenHarvestFromAntibot
+from librarykit.antibot import WarmupTokenMinter as MinterFromAntibot
+from librarykit.errors import Blocked
+
+# --------------------------------------------------------------------------- #
+# Фейки playwright-страницы/сессии (форма page.on / request / response)        #
+# --------------------------------------------------------------------------- #
+
+
+class _FakeRequest:
+    def __init__(
+        self,
+        url: str,
+        *,
+        method: str = "POST",
+        headers: dict[str, str] | None = None,
+        post_data: str | None = None,
+    ) -> None:
+        self.url = url
+        self.method = method
+        self._headers = headers or {}
+        self.post_data = post_data
+
+    async def all_headers(self) -> dict[str, str]:
+        return dict(self._headers)
+
+
+class _FakeResponse:
+    def __init__(self, request: _FakeRequest, *, body: bytes = b"") -> None:
+        self.request = request
+        self.url = request.url
+        self._body = body
+
+    async def body(self) -> bytes:
+        return self._body
+
+
+class _FakePage:
+    """Страница: копит листенеры, на `emit_all()` дёргает их эмитируемыми событиями."""
+
+    def __init__(self, events: list[tuple[str, Any]]) -> None:
+        self._listeners: dict[str, list[Any]] = {}
+        self._events = events
+
+    def on(self, event: str, cb: Any) -> None:
+        self._listeners.setdefault(event, []).append(cb)
+
+    def remove_listener(self, event: str, cb: Any) -> None:
+        self._listeners.get(event, []).remove(cb)
+
+    async def emit_all(self) -> None:
+        for event, obj in self._events:
+            for cb in list(self._listeners.get(event, [])):
+                cb(obj)
+
+
+class _FakeContext:
+    def __init__(self, cookies: list[dict[str, Any]]) -> None:
+        self._cookies = cookies
+
+    async def cookies(self) -> list[dict[str, Any]]:
+        return list(self._cookies)
+
+
+class _FakeSession:
+    """BrowserSession-совместимый фейк: ensure_page / context / aclose."""
+
+    def __init__(
+        self,
+        page: _FakePage,
+        cookies: list[dict[str, Any]] | None = None,
+    ) -> None:
+        self._page = page
+        self._context = _FakeContext(cookies or [])
+        self.closed = False
+        self.ensure_calls = 0
+
+    async def ensure_page(self) -> _FakePage:
+        self.ensure_calls += 1
+        return self._page
+
+    @property
+    def context(self) -> _FakeContext:
+        return self._context
+
+    async def aclose(self) -> None:
+        self.closed = True
+
+
+def _finalize_match(req: Any) -> bool:
+    return req.url.endswith("/finalize")
+
+
+async def _emit_trigger(page: Any) -> None:
+    await page.emit_all()
+
+
+def _good_session() -> _FakeSession:
+    req = _FakeRequest(
+        "https://svc.example/backend/sentinel/finalize",
+        headers={"authorization": "Bearer XYZ", "content-length": "42"},
+        post_data='{"proofofwork": "pw", "turnstile": "ts"}',
+    )
+    resp = _FakeResponse(req, body=b'{"token": "REQ-TOKEN"}')
+    page = _FakePage([("request", req), ("response", resp)])
+    cookies = [
+        {"name": "oai-sc", "value": "abc", "domain": ".svc.example"},
+        {"name": "other", "value": "zzz", "domain": ".cdn.other"},
+    ]
+    return _FakeSession(page, cookies)
+
+
+# --------------------------------------------------------------------------- #
+# WarmupTokenMinter.mint                                                       #
+# --------------------------------------------------------------------------- #
+
+
+async def test_mint_collects_headers_body_cookies() -> None:
+    session = _good_session()
+    triggered: list[Any] = []
+
+    async def trigger(page: Any) -> None:
+        triggered.append(page)
+        await page.emit_all()
+
+    minter = WarmupTokenMinter(lambda: session)
+    harvest = await minter.mint(trigger=trigger, match=_finalize_match)
+
+    assert triggered, "trigger должен быть вызван"
+    assert harvest.request_headers["authorization"] == "Bearer XYZ"
+    assert harvest.request_body == '{"proofofwork": "pw", "turnstile": "ts"}'
+    assert harvest.response_body == '{"token": "REQ-TOKEN"}'
+    assert len(harvest.cookies) == 2
+    assert harvest.minted_at > 0
+    # успех НЕ закрывает сессию (тёплую страницу переиспользуют)
+    assert session.closed is False
+
+
+async def test_match_filters_out_unrelated_requests() -> None:
+    req_noise = _FakeRequest("https://svc.example/telemetry/beacon", post_data="noise")
+    req_good = _FakeRequest(
+        "https://svc.example/finalize",
+        headers={"authorization": "Bearer OK"},
+        post_data="good",
+    )
+    resp_good = _FakeResponse(req_good, body=b'{"token": "T"}')
+    page = _FakePage(
+        [("request", req_noise), ("request", req_good), ("response", resp_good)]
+    )
+    session = _FakeSession(page)
+
+    minter = WarmupTokenMinter(lambda: session)
+    harvest = await minter.mint(trigger=_emit_trigger, match=_finalize_match)
+
+    # взят только match'нутый запрос, шум отфильтрован
+    assert harvest.request_body == "good"
+    assert harvest.request_headers == {"authorization": "Bearer OK"}
+
+
+async def test_capture_request_only_ignores_response() -> None:
+    req = _FakeRequest("https://svc.example/finalize", post_data="body")
+    # ответа НЕ эмитим — при capture="request" этого достаточно
+    page = _FakePage([("request", req)])
+    session = _FakeSession(page)
+
+    minter = WarmupTokenMinter(lambda: session)
+    harvest = await minter.mint(
+        trigger=_emit_trigger, match=_finalize_match, capture="request"
+    )
+    assert harvest.request_body == "body"
+    assert harvest.response_body is None
+
+
+async def test_capture_response_only() -> None:
+    req = _FakeRequest("https://svc.example/finalize")
+    resp = _FakeResponse(req, body=b"pure-response")
+    page = _FakePage([("response", resp)])
+    session = _FakeSession(page)
+
+    minter = WarmupTokenMinter(lambda: session)
+    harvest = await minter.mint(
+        trigger=_emit_trigger, match=_finalize_match, capture="response"
+    )
+    assert harvest.response_body == "pure-response"
+    assert harvest.request_headers == {}
+
+
+async def test_mint_rejects_bad_capture_mode() -> None:
+    minter = WarmupTokenMinter(_good_session)
+    with pytest.raises(ValueError, match="capture"):
+        await minter.mint(trigger=_emit_trigger, match=_finalize_match, capture="nope")
+
+
+async def test_recreate_on_fail_retries_with_fresh_session() -> None:
+    # 1-я сессия «уставшая»: ничего не эмитит → timeout; 2-я — здоровая.
+    dead_page = _FakePage([])  # нет событий → match не сработает
+    dead = _FakeSession(dead_page)
+    good = _good_session()
+    sessions = iter([dead, good])
+
+    minter = WarmupTokenMinter(lambda: next(sessions), recreate_on_fail=True)
+    harvest = await minter.mint(
+        trigger=_emit_trigger, match=_finalize_match, timeout_ms=150
+    )
+
+    assert harvest.response_body == '{"token": "REQ-TOKEN"}'
+    assert dead.closed is True, "уставшую сессию закрыли перед повтором"
+    assert good.closed is False, "здоровую сессию не закрывают при успехе"
+
+
+async def test_no_recreate_raises_blocked_on_fail() -> None:
+    dead = _FakeSession(_FakePage([]))
+    minter = WarmupTokenMinter(lambda: dead, recreate_on_fail=False)
+    with pytest.raises(Blocked):
+        await minter.mint(
+            trigger=_emit_trigger, match=_finalize_match, timeout_ms=150
+        )
+    # без recreate_on_fail сессию не закрываем — ею владеет вызывающий
+    assert dead.closed is False
+
+
+async def test_recreate_second_fail_closes_and_raises() -> None:
+    first = _FakeSession(_FakePage([]))
+    second = _FakeSession(_FakePage([]))
+    sessions = iter([first, second])
+
+    minter = WarmupTokenMinter(lambda: next(sessions), recreate_on_fail=True)
+    with pytest.raises(Blocked):
+        await minter.mint(
+            trigger=_emit_trigger, match=_finalize_match, timeout_ms=120
+        )
+    assert first.closed is True
+    assert second.closed is True
+
+
+# --------------------------------------------------------------------------- #
+# TokenHarvest helpers                                                          #
+# --------------------------------------------------------------------------- #
+
+
+def test_cookie_header_filters_by_domain() -> None:
+    h = TokenHarvest(
+        request_headers={},
+        request_body=None,
+        response_body=None,
+        cookies=[
+            {"name": "a", "value": "1", "domain": ".svc.example"},
+            {"name": "b", "value": "2", "domain": ".svc.example"},
+            {"name": "c", "value": "3", "domain": ".other.net"},
+        ],
+        minted_at=time.time(),
+    )
+    assert h.cookie_header("svc.example") == "a=1; b=2"
+    # пустая подстрока → все cookies
+    assert h.cookie_header() == "a=1; b=2; c=3"
+    assert h.cookie_header("nomatch.tld") == ""
+
+
+def test_pick_headers_allowlist_case_insensitive() -> None:
+    h = TokenHarvest(
+        request_headers={
+            "authorization": "Bearer X",
+            "user-agent": "UA",
+            "content-length": "10",
+        },
+        request_body=None,
+        response_body=None,
+        cookies=[],
+        minted_at=time.time(),
+    )
+    picked = h.pick_headers(["Authorization", "USER-AGENT"])
+    assert picked == {"authorization": "Bearer X", "user-agent": "UA"}
+    assert "content-length" not in picked
+
+
+def test_is_expired_ttl_and_skew() -> None:
+    fresh = TokenHarvest(
+        request_headers={}, request_body=None, response_body=None,
+        cookies=[], minted_at=time.time(),
+    )
+    assert fresh.is_expired(ttl_s=600) is False
+    # skew близко к ttl → уже «протух» (обновись заранее)
+    assert fresh.is_expired(ttl_s=600, skew=600) is True
+
+    old = TokenHarvest(
+        request_headers={}, request_body=None, response_body=None,
+        cookies=[], minted_at=time.time() - 1000,
+    )
+    assert old.is_expired(ttl_s=540) is True
+
+    never = TokenHarvest(
+        request_headers={}, request_body=None, response_body=None,
+        cookies=[], minted_at=0.0,
+    )
+    assert never.is_expired(ttl_s=10_000) is True
+
+
+def test_reexport_identity() -> None:
+    # корневой реэкспорт и фасад antibot — те же объекты
+    assert TokenHarvest is TokenHarvestFromAntibot
+    assert WarmupTokenMinter is MinterFromAntibot