@ultimat3/scraping 30.9.0 → 31.0.0

package/README.md

@@ -237,21 +237,28 @@ which is why `onSettled` hands a failed run its last attempt's `usage`. No quota
 
 ### The clock, and a test's
 
-A run waits on the PROCESS's clock — `scrapeClock()`, the system's — unless its definition pins
-one with `clock:`. A test replaces it the way it replaces the queue driver:
+A run waits on the PROCESS's clock — `@ultimat3/core`'s `ambientClock()`, the system's unless
+`clock` in `apps/<app>/runtime.ts` says otherwise — unless its definition pins one with `clock:`.
+Since 31.0.0 the clocks are core's `SleepClock`s; this package has none of its own. A test
+replaces the process clock through core's installer, which answers its release:
 
 ```ts
-import { noWaitClock, resetScrapeClock, setScrapeClock } from '@ultimat3/scraping';
+import { noWaitClock } from '@ultimat3/core';
+import { installClock } from '@ultimat3/core/adapter';
 
-setScrapeClock(noWaitClock); // in a beforeEach
-resetScrapeClock(); // in the afterEach
+const release = installClock(noWaitClock); // in a beforeEach
+release(); // in the afterEach
 ```
 
-| Clock | Sleeping | For |
+| Clock (`@ultimat3/core`) | Sleeping | For |
 |---|---|---|
-| `systemScrapeClock` | waits | production |
+| `systemClock` | waits | production |
 | `noWaitClock` | one turn of the event loop, whatever was asked; `now()` and deadlines are real | a test whose run waits on something that really happens in the same process — an answer the test publishes |
-| `testScrapeClock()` | advances virtual time and yields a microtask | a test of a timeout: thirty seconds pass in none |
+| `frozenClock()` | advances virtual time and yields a microtask | a test of a timeout: thirty seconds pass in none |
+
+The browser is chosen the same way: `scrapeDriver` in `apps/<app>/runtime.ts`, which the boot
+installs through `installScrapeDriver` on `@ultimat3/scraping/adapter` (the `.` barrel has no
+setter); a definition's own `driver:` overrides it.
 
 A third-party driver takes part by reading three `SessionInit` fields: dial `proxy` or throw
 `egressUnsupported()`, pass `usage` to `pageOverTarget` and its HTTP transport, and answer
@@ -389,6 +396,61 @@ The offline drivers honour it, so the crop is provable with no Chrome — `fakeB
 different deterministic bytes per rectangle, which is what lets a component screenshot be tested
 on a machine with no browser — the case CI is.
 
+## A route printed to PDF — `pdf()`, a factory over `action`
+
+```ts
+import type { Ctx } from '@ultimat3/core';
+import { can } from '@ultimat3/policy';
+import { t } from '@ultimat3/schema';
+import { pdf } from '@ultimat3/scraping';
+import { disk } from '@ultimat3/storage';
+
+/** The app's own short-lived signer for the print route — never the framework's. */
+declare function printToken(ctx: Ctx): string;
+
+export const invoicePdf = pdf({
+  input: t.object({ id: t.uuid }),
+  policy: can('invoices:read'),
+  route: ({ input }) => `/invoices/${input.id}/print`,       // a PATH on this app, never a URL
+  key: ({ input, ctx }) => `invoices/${ctx.actor.orgId}/${input.id}.pdf`,
+  storage: () => disk('documents'),                             // a thunk: read per call
+  layout: { format: 'a4', marginMm: { top: 12, bottom: 12 }, printBackground: true },
+  headers: ({ ctx }) => ({ authorization: `Bearer ${printToken(ctx)}` }), // the app's own token
+});
+// → { key, bytes, contentType: 'application/pdf' } — HTTP, OpenAPI, MCP, .job(), .as() included
+```
+
+| Rule | Detail |
+|---|---|
+| it is an `action` | input schema, policy, `rateLimit`, `meter`, `audit` are the action's: refused before a browser starts (`pdf-action.test.ts`). `PRIMITIVE_FACTORIES` row `pdf` |
+| only the app's own origin | `route()` must answer a path; a URL, `//host` or a backslash is `X_SCRAPE_PDF_ROUTE_INVALID` (500, terminal). The origin is `APP_URL`, read per call, or `origin: () => …`; neither is `X_SCRAPE_PDF_ORIGIN_MISSING` (500, terminal) |
+| an error page is never a document | the page's own status is read after `load` and `document.fonts.ready`: 4xx/5xx is `X_SCRAPE_PDF_ROUTE_FAILED` (502; a 4xx terminal, a 5xx/429 retryable) |
+| the layout is checked where `pdf()` is written | `pdfLayoutOf`, as `page.pdf()`: `X_SCRAPE_PDF_OPTIONS_INVALID` at module load |
+| one browser per render | `chromePdfRenderer()` launches Chrome through `@ultimat3/scraping/cdp`, prints over raw CDP (`Page.printToPDF`, `pdf-render.ts`, `pdf-cdp-params.ts`) and closes it in a `finally`; no browser outlives a request, none is shared between tenants. A pool is a measured next step, not shipped |
+| a bounded number of browsers | at most `maxConcurrent` (default 2 — each Chrome is 150-300 MB) per renderer, and every `pdf()` naming no `renderer` shares ONE. The rest queue for `queueTimeoutMs` (default `timeoutMs`) on the clock, then `X_SCRAPE_PDF_BUSY` (503, retryable) — `pdf-slots.ts`, `pdf-render-slots.test.ts` |
+| a dropped request ends its render | the action's `ctx.signal` reaches the renderer: aborted in the queue, it leaves without a slot; aborted mid-print, its browser is killed and the slot freed, and the request's own reason is thrown |
+| headers reach the route's origin only | `Fetch.enable` on the page's session (`pdf-fence.ts`): a request to the route's exact origin (scheme, host, port) continues with `headers` added; every other — a user's `<img src="https://elsewhere">`, a redirect off-site, `169.254.169.254` — is failed `BlockedByClient` before it leaves. Never `Network.setExtraHTTPHeaders`, which sent the token everywhere (`pdf-render-fence.test.ts`) |
+| the sandbox stays on | the default launch keeps Chrome's sandbox (`pdfLaunchOptions`): a print renders user content. The runtime image ships no Chrome; the app's image supplies it and runs it as non-root, which needs unprivileged user namespaces (or Chrome's setuid helper). A container that cannot grant them fails `X_CDP_LAUNCH_FAILED` quoting "No usable sandbox" — opt out there in one visible line, `chromePdfRenderer({ sandbox: false })`. The e2e driver and `x shot` keep `--no-sandbox` for CI runners |
+| the bytes go to storage | `storage().put(key, bytes, { contentType: 'application/pdf' })`; the answer is the key, never the bytes. Serve it with a signed URL |
+| tested with no Chrome | `renderer:` takes any `PdfRenderer`; `chromePdfRenderer({ launch })` takes any `{ connection, close }` — `pdf-render.test.ts` drives it over a fake CDP connection |
+
+Open (`As of 2026-11`): the route must be readable by the printing browser — a private one forwards
+the app's own short-lived credential through `headers`; no session is minted for it.
+
+## The raw-CDP browser — `@ultimat3/scraping/cdp`
+
+The launcher and connection the e2e driver and `x shot` have used since 22.0.0, moved here from
+`@ultimat3/testing` in 31.0.0 because `pdf()` needs them at RUNTIME and testing is a test package.
+Its own entry, off `.`, so a caller that only launches loads no job or storage module.
+This is every name's one home: `@ultimat3/testing` no longer re-exports them (31.0.0, `X_HELPER_COPY`); its `E2E_ERROR_CODES` still lists the four codes.
+
+| Export | What |
+|---|---|
+| `findChrome(env)` · `launchChrome({ executable, timeoutMs })` · `launchFoundChrome(env, timeoutMs)` | `CHROME_PATH`, then the platform's install paths; a throwaway profile, the pipe wire, one relaunch |
+| `cdpConnect({ endpoint, timeoutMs })` · `cdpConnectOver(transport, timeoutMs)` | a CDP connection over a remote WebSocket or any whole-message transport |
+| `CdpBrowserMissingError` · `CdpLaunchFailedError` · `CdpCallFailedError` · `CdpTimeoutError` | `X_CDP_BROWSER_MISSING` · `X_CDP_LAUNCH_FAILED` · `X_CDP_CALL_FAILED` · `X_CDP_TIMEOUT`, registered by `cdp-error-codes.ts` |
+| `CHROME_CANDIDATES` · `CONTAINER_CHROME_ARGS` · `chromeLaunchFlags` · `LAUNCH_*` · `CLOSE_GRACE_MS` · `LAUNCHED_CLOSE_MS` | the flags and the deadlines, derived, never restated |
+
 ## What it owns
 
 | Module | Owns |
@@ -399,6 +461,7 @@ on a machine with no browser — the case CI is.
 | `driver-cdp.ts` / `cdp-*.ts` | the real browser, over a structural CDP port |
 | `driver-fake.ts` / `driver-recorded.ts` / `html-*.ts` | the offline drivers, on Bun's `HTMLRewriter` |
 | `http.ts` / `http-recorded.ts` | the second transport, live and replayed |
+| `intercept.ts` / `pinned-host.ts` / `browser-dial.ts` | `allowHosts`: one name verdict for every driver, then the DNS half for a host a wildcard admitted — resolved and pinned on the HTTP leg and robots read, resolved before release on the browser leg (a private or unresolvable answer is a `refused: 'host'` ring entry). An exact rule and a proxied session are not resolved |
 | `auth.ts` / `session-state.ts` | acquire → persist → reuse → validate → burn. The session key encodes each part (`<sanitised>.<digest>`), so two account names that differ only outside `[a-zA-Z0-9._-]` are two sessions. A stored session is sealed. `burnSession(plan, seen)` takes `recordVersion(record)` of the record the run used, so a record another run saved since is not burned |
 | `event-prompt.ts` | `eventPrompt()` and `answerPrompt()`: a prompt answered from another process, over the job event bus, with the browser open |
 | `cdp-resolver.ts` | a browser rented per session: acquired once, released once |
@@ -406,6 +469,8 @@ on a machine with no browser — the case CI is.
 | `secrets.ts` / `url-secrets.ts` / `browser-record.ts` | what may leave this package — declared secrets, values learned mid-run (`conceal`), the credential-bearing parts of a URL — and how a browser's own string map is read |
 | `expect.ts` | the silent-green alarm |
 | `watchdog.ts` | the wedge and zombie discipline |
+| `pdf-action.ts` / `pdf-render.ts` / `pdf-cdp-params.ts` / `pdf-slots.ts` / `pdf-fence.ts` | `pdf()` over `action`; one page printed over raw CDP; a layout in the protocol's words; the bound on live browsers; the request fence |
+| `cdp.ts` / `cdp-launch*.ts` / `cdp-connection.ts` / `cdp-pipe.ts` / `cdp-wire-watch.ts` / `cdp-errors.ts` | `@ultimat3/scraping/cdp`: the raw-CDP launcher and connection (moved from `@ultimat3/testing` in 31.0.0) |
 | `capture-clip.ts` | the one framing rule — crop, whole page, or a refusal — checked before any driver sees it |
 | `errors.ts` / `error-throws.ts` / `error-throws-session.ts` | this package's `X_*` codes and their retry classification |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/scraping",
-  "version": "30.9.0",
+  "version": "31.0.0",
   "description": "Browser automation as a job: scrape() returns a JobHandle",
   "keywords": [
     "ultimate",
@@ -24,7 +24,9 @@
     "provenance": true
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./adapter": "./src/adapter.ts",
+    "./cdp": "./src/cdp.ts"
   },
   "files": [
     "src",
@@ -41,9 +43,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/core": "30.9.0",
-    "@ultimat3/jobs": "30.9.0",
-    "@ultimat3/schema": "30.9.0",
-    "@ultimat3/storage": "30.9.0"
+    "@ultimat3/action": "31.0.0",
+    "@ultimat3/core": "31.0.0",
+    "@ultimat3/jobs": "31.0.0",
+    "@ultimat3/schema": "31.0.0",
+    "@ultimat3/storage": "31.0.0"
   }
 }

package/src/actionability.ts

@@ -4,8 +4,8 @@
 // `waitForSelector('#aceptar:not([disabled])')`, which is this rule, spelled once, by hand, at
 // one call site out of forty.
 
+import type { SleepClock } from '@ultimat3/core';
 import { finiteCount } from '@ultimat3/core';
-import type { ScrapeClock } from './clock';
 import { deadline } from './clock';
 import { notActionable, selectorMissing } from './error-throws';
 import type { ElementSnapshot } from './target';
@@ -71,7 +71,7 @@ export interface ActionabilityWait {
   readonly url: string;
   readonly state: ActionabilityState;
   readonly timeoutMs: number;
-  readonly clock: ScrapeClock;
+  readonly clock: SleepClock;
   readonly pollMs?: number | undefined;
   readonly signal?: AbortSignal | undefined;
   /** Re-read from the live page on EVERY poll. Never a handle captured before the loop. */

package/src/adapter.ts

@@ -0,0 +1,22 @@
+// `@ultimat3/scraping/adapter` — the `scrapeDriver` port: the interface a browser driver
+// implements, the errors it throws, and the boot's installer. The installer lives here and never on
+// the `.` barrel, so `scrapeDriver` in `apps/<app>/runtime.ts` is the one way an app picks a browser.
+
+export type { ScrapeDriver, ScrapeSession, SessionInit } from './driver';
+export { installScrapeDriver, resetScrapeDriver } from './driver';
+export {
+  browserUnreachable,
+  cdpAttachFailed,
+  hostBlocked,
+  notActionable,
+  pageCrashed,
+  profileLocked,
+  remoteRequired,
+  scrapeTimeout,
+  selectorMissing,
+} from './error-throws';
+export { egressUnsupported } from './error-throws-session';
+export { isScrapeError, ScrapeError } from './errors';
+export type { HttpTransportInit, ScrapeHttp } from './http';
+export type { ScrapePage } from './page';
+export type { SecretResolver } from './secrets';

package/src/auth.ts

@@ -17,9 +17,8 @@
 // rejected credential. A rejected credential is `X_SCRAPE_AUTH_FAILED`, terminal, and the refusal
 // is written into the session record so the NEXT attempt fails before reaching the login form.
 
-import type { Logger } from '@ultimat3/core';
+import type { Logger, SleepClock } from '@ultimat3/core';
 import { finiteCount } from '@ultimat3/core';
-import type { ScrapeClock } from './clock';
 import { authFailed, promptUnanswered, scrapeSessionExpired } from './error-throws';
 import type { ScrapePage } from './page';
 import type { ScrapeSecrets } from './secrets';
@@ -45,7 +44,7 @@ export interface PromptRequest<I = unknown> {
   /** 1 for the first prompt of this attempt, 2 for the next. */
   readonly index: number;
   /** The run's clock. A handler that waits, waits on this — never on a timer of its own. */
-  readonly clock: ScrapeClock;
+  readonly clock: SleepClock;
   /** The run's cancellation. A handler that waits past it holds a browser nobody is using. */
   readonly signal: AbortSignal | undefined;
   /**
@@ -110,7 +109,7 @@ export interface PromptInit<I = unknown> {
   readonly input: I;
   readonly page: ScrapePage;
   readonly runId: string;
-  readonly clock: ScrapeClock;
+  readonly clock: SleepClock;
   readonly signal?: AbortSignal | undefined;
   /** The run's secret set. Every answer is concealed in it before the body sees the answer. */
   readonly secrets?: ScrapeSecrets | undefined;
@@ -156,7 +155,7 @@ export interface AuthPlanInput<I> {
   readonly scrape: string;
   readonly auth: ScrapeAuth<I> | undefined;
   readonly key: string;
-  readonly clock: ScrapeClock;
+  readonly clock: SleepClock;
   readonly logger: Logger;
 }
 

package/src/browser-dial.ts

@@ -0,0 +1,55 @@
+// The DNS half of `allowHosts` for the BROWSER leg. The browser dials by itself, so nothing here can
+// pin its socket the way `pinned-host.ts` pins the HTTP leg; what it can do is refuse to release a
+// request whose wildcard-admitted name resolves inward (`10.x`, `169.254.169.254`) — the SSRF a
+// name-only check let through. Chrome's own re-resolution (rebinding) stays open: `wiki/Known-Gaps.md`.
+
+import type { HostRule } from '@ultimat3/core';
+import { classifyAddress, hostMatches } from '@ultimat3/core';
+import { screenDial } from '@ultimat3/core/outbound';
+import type { HostResolve } from './pinned-host';
+
+/** How the browser leg screens: the resolver, and whether a proxy resolves names instead. */
+export interface BrowserDialScreen {
+  readonly allowHosts: readonly HostRule[];
+  readonly resolve: HostResolve;
+  /** Through a proxy the EXIT resolves the name, so this box's answer says nothing — the HTTP leg's rule. */
+  readonly proxied: boolean;
+}
+
+/** The schemes the browser opens a socket for by name. A WebSocket is a dial like any other. */
+const DIALLED_SCHEMES = new Set(['http:', 'https:', 'ws:', 'wss:']);
+
+const isWildcard = (rule: HostRule): boolean => {
+  const cleaned = rule.trim();
+  return cleaned === '*' || cleaned.startsWith('*.');
+};
+
+/**
+ * `undefined` — synchronously — when there is nothing to resolve: a hostless or non-http scheme,
+ * an address literal (core's floor already judged it), a host an EXACT rule names (the app said
+ * that host in a line a reviewer can see), or a proxied session. Otherwise a promise of whether
+ * the request must be REFUSED: one non-public address, or no answer at all, refuses — the browser
+ * would not have reached an unresolvable name either, and failing closed is the only safe read.
+ * Asked only of a URL `interceptVerdict` has already allowed.
+ */
+export function browserDialRefusal(
+  url: string,
+  screen: BrowserDialScreen,
+): Promise<boolean> | undefined {
+  if (screen.proxied) return undefined;
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return undefined;
+  }
+  if (!DIALLED_SCHEMES.has(parsed.protocol)) return undefined;
+  const hostname = parsed.hostname.replace(/^\[|\]$/g, '');
+  if (hostname === '' || classifyAddress(hostname) !== undefined) return undefined;
+  const exact = screen.allowHosts.some((rule) => !isWildcard(rule) && hostMatches(hostname, rule));
+  if (exact) return undefined;
+  return screenDial(parsed, { resolve: screen.resolve }).then(
+    (verdict) => !('pin' in verdict),
+    () => true,
+  );
+}

package/src/cdp-arm.ts

@@ -1,13 +1,16 @@
 // Everything `cdpTarget()` arms on the page BEFORE its first navigation, plus the readers that
 // turn the library's `unknown` event payloads into ring entries. Split out of `cdp-target.ts` on
 // 2026-09-19 for one reason: that file stood at 478 lines against the 500-line ceiling, and the
-// three verbs `press`/`focus`/`accessibility` did not fit under it. The extraction is VERBATIM —
-// the request, console, `pageerror` and `error` handlers are the same code, one file over.
+// three verbs `press`/`focus`/`accessibility` did not fit under it. Since 31.0.0 an allowed request
+// is released only after `browser-dial.ts` screens a wildcard-admitted name's addresses.
 
+import type { SleepClock } from '@ultimat3/core';
+import { resolveDialHost } from '@ultimat3/core/outbound';
+import { type BrowserDialScreen, browserDialRefusal } from './browser-dial';
 import type { CdpBrowserLike, CdpPageLike, CdpRequestLike } from './cdp-port';
-import type { ScrapeClock } from './clock';
 import type { InterceptRules } from './intercept';
 import { interceptVerdict, refusalEntry } from './intercept';
+import type { HostResolve } from './pinned-host';
 import type {
   ConsoleLine,
   ConsoleRing,
@@ -18,13 +21,47 @@ import type {
 } from './rings';
 import { clamped, pageErrorEntry, RESOURCE_TYPES } from './rings';
 
+/**
+ * What the DNS screen reads (`browser-dial.ts`). `resolve` defaults to `Bun.dns`, the one the HTTP
+ * leg uses; `proxied` is true when the session dials through an exit, which resolves names itself.
+ */
+export interface CdpDialInit {
+  readonly resolve?: HostResolve | undefined;
+  readonly proxied?: boolean | undefined;
+}
+
 /** What `arm()` reads: the page it subscribes to, the rules it judges by, the clock it stamps with. */
-export interface CdpArmInit {
+export interface CdpArmInit extends CdpDialInit {
   readonly page: CdpPageLike;
   readonly rules: InterceptRules;
-  readonly clock: ScrapeClock;
+  readonly clock: SleepClock;
 }
 
+const dialScreen = (init: CdpDialInit & { readonly rules: InterceptRules }): BrowserDialScreen => ({
+  allowHosts: init.rules.allowHosts,
+  resolve: init.resolve ?? resolveDialHost,
+  proxied: init.proxied === true,
+});
+
+/**
+ * Release or refuse, after the DNS screen when there is one. Synchronous when nothing needs
+ * resolving — an exact rule's request leaves on the event's own tick, as before this screen.
+ * A refusal is a `host` refusal: the name was admitted, the address it answers is not.
+ */
+const screened = (
+  url: string,
+  screen: BrowserDialScreen,
+  release: () => void,
+  refuse: () => void,
+): void => {
+  const pending = browserDialRefusal(url, screen);
+  if (pending === undefined) {
+    release();
+    return;
+  }
+  pending.then((refused) => (refused ? refuse() : release()), refuse);
+};
+
 const asResourceType = (raw: string): ResourceType =>
   (RESOURCE_TYPES as readonly string[]).includes(raw) ? (raw as ResourceType) : 'other';
 
@@ -121,6 +158,7 @@ export interface CdpSinks {
  */
 export async function arm(init: CdpArmInit, sinks: CdpSinks): Promise<void> {
   const { network, console: console_, pageErrors, crashed } = sinks;
+  const screen = dialScreen(init);
   await init.page.setRequestInterception(true);
   init.page.on('request', (payload) => {
     const request = asRequest(payload);
@@ -133,16 +171,26 @@ export async function arm(init: CdpArmInit, sinks: CdpSinks): Promise<void> {
     const method = readStringFrom(request, 'method') ?? 'GET';
     const verdict = interceptVerdict(url, type, init.rules);
     const at = init.clock.now().getTime();
-    if (verdict === 'allow') {
-      network.push({ method, url: clamped(url), resourceType: type, at });
-      // Caught, never floated: both reject when the target closed mid-request (and on any other
-      // protocol error), and a floated rejection is one Bun ends the process on. The request is
-      // already recorded; there is nothing left to do for a target that is gone.
-      request.continue().catch(() => undefined);
+    // Caught, never floated: both reject when the target closed mid-request (and on any other
+    // protocol error), and a floated rejection is one Bun ends the process on. The request is
+    // already recorded; there is nothing left to do for a target that is gone.
+    const refuse = (reason: 'host' | 'blocked'): void => {
+      network.push(refusalEntry(url, type, reason, at, method));
+      request.abort().catch(() => undefined);
+    };
+    if (verdict !== 'allow') {
+      refuse(verdict);
       return;
     }
-    network.push(refusalEntry(url, type, verdict, at, method));
-    request.abort().catch(() => undefined);
+    screened(
+      url,
+      screen,
+      () => {
+        network.push({ method, url: clamped(url), resourceType: type, at });
+        request.continue().catch(() => undefined);
+      },
+      () => refuse('host'),
+    );
   });
   init.page.on('console', (payload) => {
     console_.push({
@@ -212,13 +260,14 @@ const asPaused = (payload: unknown): PausedRequest | undefined => {
  * `driver-cdp.ts`'s `opened()` closes it — a session whose rule would hold on one tab is refused.
  */
 export async function armBrowser(
-  init: {
+  init: CdpDialInit & {
     readonly browser: CdpBrowserLike;
     readonly rules: InterceptRules;
-    readonly clock: ScrapeClock;
+    readonly clock: SleepClock;
   },
   network: NetworkRing,
 ): Promise<void> {
+  const screen = dialScreen(init);
   const session = await init.browser.target().createCDPSession();
   session.on('Fetch.requestPaused', (payload) => {
     const paused = asPaused(payload);
@@ -226,16 +275,26 @@ export async function armBrowser(
     const type = asResourceType(paused.resourceType.toLowerCase());
     const verdict = interceptVerdict(paused.url, type, init.rules);
     const requestId = { requestId: paused.requestId };
+    const at = init.clock.now().getTime();
     // Caught, never floated, for `arm`'s reason: the target may be gone by the time this answers.
-    if (verdict === 'allow') {
-      session.send('Fetch.continueRequest', requestId).catch(() => undefined);
+    const refuse = (reason: 'host' | 'blocked'): void => {
+      network.push(refusalEntry(paused.url, type, reason, at, paused.method));
+      session
+        .send('Fetch.failRequest', { ...requestId, errorReason: 'BlockedByClient' })
+        .catch(() => undefined);
+    };
+    if (verdict !== 'allow') {
+      refuse(verdict);
       return;
     }
-    const at = init.clock.now().getTime();
-    network.push(refusalEntry(paused.url, type, verdict, at, paused.method));
-    session
-      .send('Fetch.failRequest', { ...requestId, errorReason: 'BlockedByClient' })
-      .catch(() => undefined);
+    screened(
+      paused.url,
+      screen,
+      () => {
+        session.send('Fetch.continueRequest', requestId).catch(() => undefined);
+      },
+      () => refuse('host'),
+    );
   });
   await session.send('Fetch.enable', { patterns: [{ urlPattern: '*' }] });
 }