@reclaimprotocol/agent 0.1.35 → 0.1.37

package/lib/mcp/tools/verification/proxy-callback-events.js

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Forwarder_instances, _Forwarder_client, _Forwarder_deps, _Forwarder_abort, _Forwarder_forwarded, _Forwarder_failed, _Forwarder_lastError, _Forwarder_recent, _Forwarder_unacked, _Forwarder_host, _Forwarder_running, _Forwarder_loop, _Forwarder_tick, _Forwarder_forward, _ForwarderRegistry_forwarders;
+var _Forwarder_instances, _Forwarder_client, _Forwarder_deps, _Forwarder_abort, _Forwarder_forwarded, _Forwarder_failed, _Forwarder_lastError, _Forwarder_recent, _Forwarder_unacked, _Forwarder_held, _Forwarder_host, _Forwarder_running, _Forwarder_loop, _Forwarder_tick, _Forwarder_hold, _Forwarder_forward, _ForwarderRegistry_forwarders;
 import { badRequest } from '@hapi/boom';
 import assert from 'node:assert';
 import { setTimeout as delay } from 'node:timers/promises';
@@ -21,15 +21,25 @@ const POLL_MS = 2000;
 const MAX_BACKOFF_MS = 30000;
 const FORWARD_TIMEOUT_MS = 10000;
 const BATCH = 50;
+/**
+ * Pages read per poll. A page is `BATCH` events, so a poll can look past up to
+ * 500 pending events. That is enough to reach other sessions behind several
+ * held ones, and still bounds the work of one poll.
+ */
+const MAX_PAGES = 10;
 const RECENT = 10;
 /** Loopback addresses, in the order tried. Dev servers often bind only one. */
 const HOSTS = ['127.0.0.1', '[::1]'];
 /**
  * Polls the org's pending pull events and POSTs each envelope to a local
  * route, like `stripe listen --forward-to`. 2xx responses are acknowledged;
- * anything else (redirects included) stays pending and is retried with
- * exponential backoff. After a failure the batch stops, so events reach the
- * app in order.
+ * anything else (redirects included) stays pending.
+ *
+ * Order holds per session. When an event fails, its session is held: its later
+ * events are not sent or acknowledged, and the failed event is retried with
+ * exponential backoff (2 s, 4 s, ... 30 s). Other sessions keep flowing at the
+ * normal poll rate. Held sessions appear in `status().blocked`, and clear when
+ * the app accepts the event.
  */
 class Forwarder {
     constructor(client, listener, target, deps) {
@@ -44,7 +54,11 @@ class Forwarder {
         /** Delivered to the app but not yet acknowledged; never POSTed twice. */
         );
         /** Delivered to the app but not yet acknowledged; never POSTed twice. */
-        _Forwarder_unacked.set(this, new Set());
+        _Forwarder_unacked.set(this, new Set()
+        /** Held sessions by session id, with the time of their next attempt. */
+        );
+        /** Held sessions by session id, with the time of their next attempt. */
+        _Forwarder_held.set(this, new Map());
         _Forwarder_host.set(this, HOSTS[0]);
         _Forwarder_running.set(this, void 0);
         __classPrivateFieldSet(this, _Forwarder_client, client, "f");
@@ -62,6 +76,7 @@ class Forwarder {
             failed: __classPrivateFieldGet(this, _Forwarder_failed, "f"),
             ...(__classPrivateFieldGet(this, _Forwarder_lastError, "f") ? { lastError: __classPrivateFieldGet(this, _Forwarder_lastError, "f") } : {}),
             recent: [...__classPrivateFieldGet(this, _Forwarder_recent, "f")],
+            blocked: [...__classPrivateFieldGet(this, _Forwarder_held, "f").values()].map((h) => h.blocked),
         };
     }
     async stop() {
@@ -69,16 +84,16 @@ class Forwarder {
         await __classPrivateFieldGet(this, _Forwarder_running, "f");
     }
 }
-_Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_abort = new WeakMap(), _Forwarder_forwarded = new WeakMap(), _Forwarder_failed = new WeakMap(), _Forwarder_lastError = new WeakMap(), _Forwarder_recent = new WeakMap(), _Forwarder_unacked = new WeakMap(), _Forwarder_host = new WeakMap(), _Forwarder_running = new WeakMap(), _Forwarder_instances = new WeakSet(), _Forwarder_loop = async function _Forwarder_loop() {
+_Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_abort = new WeakMap(), _Forwarder_forwarded = new WeakMap(), _Forwarder_failed = new WeakMap(), _Forwarder_lastError = new WeakMap(), _Forwarder_recent = new WeakMap(), _Forwarder_unacked = new WeakMap(), _Forwarder_held = new WeakMap(), _Forwarder_host = new WeakMap(), _Forwarder_running = new WeakMap(), _Forwarder_instances = new WeakSet(), _Forwarder_loop = async function _Forwarder_loop() {
     const sleep = __classPrivateFieldGet(this, _Forwarder_deps, "f").sleep || sleepFor;
     const signal = __classPrivateFieldGet(this, _Forwarder_abort, "f").signal;
     let backoff = 0;
     while (!signal.aborted) {
         let wait = POLL_MS;
         try {
-            const { ok, count } = await __classPrivateFieldGet(this, _Forwarder_instances, "m", _Forwarder_tick).call(this);
-            backoff = ok ? 0 : nextBackoff(backoff);
-            wait = ok ? (count >= BATCH ? 0 : POLL_MS) : backoff;
+            const more = await __classPrivateFieldGet(this, _Forwarder_instances, "m", _Forwarder_tick).call(this);
+            backoff = 0;
+            wait = more ? 0 : POLL_MS;
         }
         catch (err) {
             __classPrivateFieldSet(this, _Forwarder_lastError, err instanceof Error ? err.message : String(err), "f");
@@ -90,37 +105,96 @@ _Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_a
             await sleep(wait, signal);
         }
     }
-}, _Forwarder_tick = async function _Forwarder_tick() {
-    const { data } = await __classPrivateFieldGet(this, _Forwarder_client, "f").call('ListCallbackEvents', {
-        query: { pending: true, limit: BATCH },
-    });
-    const ack = [];
-    let ok = true;
-    for (const item of data.items) {
-        if (__classPrivateFieldGet(this, _Forwarder_abort, "f").signal.aborted) {
-            break;
-        }
-        if (__classPrivateFieldGet(this, _Forwarder_unacked, "f").has(item.id) || await __classPrivateFieldGet(this, _Forwarder_instances, "m", _Forwarder_forward).call(this, item)) {
-            ack.push(item.id);
-        }
-        else {
-            // Stop the batch so later events don't overtake the failed one.
-            ok = false;
-            break;
+}, _Forwarder_tick = 
+/**
+ * Forwards one poll's worth of pending events. Returns whether to poll again
+ * at once: the page limit was hit with events still unread, and progress was
+ * made (so held sessions alone never cause a busy loop).
+ */
+async function _Forwarder_tick() {
+    const now = (__classPrivateFieldGet(this, _Forwarder_deps, "f").now || Date.now)();
+    // Sessions whose later events are skipped in this poll.
+    const skip = new Set();
+    const seen = new Set();
+    let after;
+    let page = 0;
+    let full = false;
+    let progress = false;
+    do {
+        const { data } = await __classPrivateFieldGet(this, _Forwarder_client, "f").call('ListCallbackEvents', {
+            query: { pending: true, limit: BATCH, ...(after ? { after } : {}) },
+        });
+        const ack = [];
+        for (const item of data.items) {
+            if (__classPrivateFieldGet(this, _Forwarder_abort, "f").signal.aborted) {
+                break;
+            }
+            seen.add(item.sessionId);
+            const held = __classPrivateFieldGet(this, _Forwarder_held, "f").get(item.sessionId);
+            if (skip.has(item.sessionId)
+                || (held && held.retryAt > now && !__classPrivateFieldGet(this, _Forwarder_unacked, "f").has(item.id))) {
+                skip.add(item.sessionId);
+                continue;
+            }
+            if (__classPrivateFieldGet(this, _Forwarder_unacked, "f").has(item.id)) {
+                ack.push(item.id);
+                continue;
+            }
+            const outcome = await __classPrivateFieldGet(this, _Forwarder_instances, "m", _Forwarder_forward).call(this, item);
+            if (outcome.ok) {
+                __classPrivateFieldGet(this, _Forwarder_held, "f").delete(item.sessionId);
+                ack.push(item.id);
+            }
+            else {
+                // Hold the session so its later events don't overtake this one.
+                __classPrivateFieldGet(this, _Forwarder_instances, "m", _Forwarder_hold).call(this, item, outcome, now);
+                skip.add(item.sessionId);
+            }
         }
-    }
-    if (ack.length) {
-        for (const id of ack) {
-            __classPrivateFieldGet(this, _Forwarder_unacked, "f").add(id);
+        if (ack.length) {
+            progress = true;
+            for (const id of ack) {
+                __classPrivateFieldGet(this, _Forwarder_unacked, "f").add(id);
+            }
+            await __classPrivateFieldGet(this, _Forwarder_client, "f").call('AcknowledgeCallbackEvents', {
+                body: { ids: ack },
+            });
+            for (const id of ack) {
+                __classPrivateFieldGet(this, _Forwarder_unacked, "f").delete(id);
+            }
         }
-        await __classPrivateFieldGet(this, _Forwarder_client, "f").call('AcknowledgeCallbackEvents', {
-            body: { ids: ack },
-        });
-        for (const id of ack) {
-            __classPrivateFieldGet(this, _Forwarder_unacked, "f").delete(id);
+        // `next` skips what this page returned, including held events.
+        after = data.next;
+        full = data.items.length >= BATCH;
+        page += 1;
+    } while (full && page < MAX_PAGES && !__classPrivateFieldGet(this, _Forwarder_abort, "f").signal.aborted);
+    if (!full) {
+        // The listing was read to its end: forget sessions with nothing pending.
+        for (const sessionId of __classPrivateFieldGet(this, _Forwarder_held, "f").keys()) {
+            if (!seen.has(sessionId)) {
+                __classPrivateFieldGet(this, _Forwarder_held, "f").delete(sessionId);
+            }
         }
     }
-    return { ok, count: data.items.length };
+    return full && progress;
+}, _Forwarder_hold = function _Forwarder_hold(item, outcome, now) {
+    const prev = __classPrivateFieldGet(this, _Forwarder_held, "f").get(item.sessionId);
+    const delay = nextBackoff(prev?.delay || 0);
+    __classPrivateFieldGet(this, _Forwarder_held, "f").set(item.sessionId, {
+        blocked: {
+            sessionId: item.sessionId,
+            event: item.event,
+            eventId: item.id,
+            ...(outcome.httpStatus === undefined
+                ? {}
+                : { httpStatus: outcome.httpStatus }),
+            attempts: (prev?.blocked.attempts || 0) + 1,
+            lastError: outcome.error,
+            since: prev?.blocked.since || new Date(now).toISOString(),
+        },
+        retryAt: now + delay,
+        delay,
+    });
 }, _Forwarder_forward = async function _Forwarder_forward(item) {
     const doFetch = __classPrivateFieldGet(this, _Forwarder_deps, "f").forwardFetch || globalThis.fetch;
     const record = (status, httpStatus) => {
@@ -150,7 +224,7 @@ _Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_a
             if (res.ok) {
                 __classPrivateFieldSet(this, _Forwarder_forwarded, __classPrivateFieldGet(this, _Forwarder_forwarded, "f") + 1, "f");
                 record('delivered', res.status);
-                return true;
+                return { ok: true };
             }
             __classPrivateFieldSet(this, _Forwarder_failed, __classPrivateFieldGet(this, _Forwarder_failed, "f") + 1, "f");
             const url = targetUrl(this.target, host);
@@ -159,7 +233,7 @@ _Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_a
                     + 'followed; call again with the redirect target\'s `path`.'
                 : `${url} returned HTTP ${res.status}`, "f");
             record('failed', res.status);
-            return false;
+            return { ok: false, httpStatus: res.status, error: __classPrivateFieldGet(this, _Forwarder_lastError, "f") };
         }
         catch (err) {
             __classPrivateFieldSet(this, _Forwarder_lastError, err instanceof Error ? err.message : String(err), "f");
@@ -168,7 +242,7 @@ _Forwarder_client = new WeakMap(), _Forwarder_deps = new WeakMap(), _Forwarder_a
     // No loopback address accepted the connection.
     __classPrivateFieldSet(this, _Forwarder_failed, __classPrivateFieldGet(this, _Forwarder_failed, "f") + 1, "f");
     record('failed');
-    return false;
+    return { ok: false, error: __classPrivateFieldGet(this, _Forwarder_lastError, "f") || 'Connection failed' };
 };
 /** The forwarders of one MCP process, one per org key. */
 export class ForwarderRegistry {
@@ -207,17 +281,26 @@ export function proxyCallbackEventsTool(deps = {}) {
             + 'to a local route, like `stripe listen --forward-to`. Call it '
             + 'when the app\'s callback route runs locally. It POSTs each '
             + 'envelope as JSON to `http://127.0.0.1:<port><path>` (loopback '
-            + 'only; also tries `[::1]`) in order, acknowledges 2xx '
-            + 'responses, and retries anything else, redirects included, '
-            + 'with backoff. Creates the listener on first use, so it is not '
+            + 'only; also tries `[::1]`) and acknowledges 2xx responses. '
+            + 'Events of one session arrive in order. When the app rejects '
+            + 'an event, including with a redirect, that session is held and '
+            + 'retried with backoff (2 s up to 30 s) while other sessions '
+            + 'keep flowing. Creates the listener on first use, so it is not '
             + 'read-only. One forwarder runs per org: call again to read '
             + 'status, or with another `port` or `path` to retarget. '
             + '`stop: true` stops forwarding only. Forwarding lasts only '
             + 'while this MCP server runs; production needs '
             + '`create_org_callback_subscription`. Returns `{ forwarding, '
-            + 'target, listener, forwarded, failed, lastError?, recent }`; '
-            + '`listener.expiresAt` is the lease end, and `recent` lists the '
-            + 'last events with `status` and `httpStatus`.',
+            + 'target, listener, forwarded, failed, lastError?, recent, '
+            + 'blocked }`. `listener.expiresAt` is the lease end, and '
+            + '`recent` lists the last events with `status` and '
+            + '`httpStatus`. `blocked` lists each held session as '
+            + '`{ sessionId, event, eventId, httpStatus?, attempts, '
+            + 'lastError?, since }`, and is `[]` when none is held. When '
+            + '`blocked` is not empty, check the app\'s response and logs '
+            + 'for that session. The app must return 2xx for a result that '
+            + 'failed verification, and 5xx only for a temporary error. '
+            + 'Fix the app, and the session resumes on the next retry.',
         inputSchema: {
             type: 'object',
             properties: {

package/lib/old/login-cdp.js

@@ -1,5 +1,5 @@
 import { connectCdp } from "../cdp/client.js";
-import { defaultProfileDir, launchChrome, waitForCdpReady, } from "../cdp/launcher.js";
+import { defaultProfileDir, launchLocalBrowser, waitForCdpReady, } from "../cdp/launcher.js";
 import { ConfigStore } from "../config/store.js";
 import { DEFAULT_LOGIN_URL, oldLoginUrl } from "../consts.js";
 /**
@@ -127,8 +127,7 @@ export async function captureFirebaseTokenViaCdp(opts) {
                 `with --remote-debugging-port=${port} AND a non-default ` +
                 '--user-data-dir, or use the dedicated local login mode.');
         }
-        launchChrome({ port, profileDir: defaultProfileDir() });
-        await waitForCdpReady(port, 10000);
+        await launchLocalBrowser({ port, profileDir: defaultProfileDir() });
         launchedByUs = true;
     }
     const handles = await connectCdp(port);

package/lib/proof/attestor.js

@@ -108,9 +108,8 @@ export async function runAttestorProof(provider, secrets, opts = {}) {
                 extractedParameters: {},
                 verified: false,
                 error: 'No eth proof-owner key available (no RECLAIM_PRIVATE_KEY in env, ' +
-                    '.env, or RECLAIM_PRIVATE_KEY_FILE). Call resolve_owner_key, then ' +
-                    'issue_credentials (generate) or import_credentials (provide one), ' +
-                    'and retry run_proof.',
+                    '.env, or RECLAIM_PRIVATE_KEY_FILE). Call resolve_owner_key, ' +
+                    'which creates a local test key, and retry run_proof.',
                 errorKind: 'missing-owner-key',
             };
         }

package/lib/proof/check-attestor.d.ts

@@ -5,6 +5,7 @@
  */
 import { createClaimOnAttestor } from '@reclaimprotocol/attestor-core';
 import './patch-domhandler.ts';
+import { type ZkFilesState } from './zk-files.ts';
 /**
  * Default time budget for one check. A live run takes about 8 s; a longer
  * budget risks the MCP client's own tool-call timeout.
@@ -37,11 +38,16 @@ export declare const COIN_GECKO_PARAMS: {
     additionalClientOptions: {};
 };
 export type AttestorCheckErrorKind = 
-/** Socket, connection, DNS, TLS, or timeout failure. */
+/** Socket, connection, DNS, TLS, or timeout failure, with the proof files
+ *  ready: the attestor itself didn't answer. */
 'attestor-unreachable'
 /** The attestor answered and rejected or failed the claim. */
  | 'attestor-error'
-/** Local setup (ZK files) failed before the attestor was contacted. */
+/** The proof files are still downloading; the attestor wasn't contacted. */
+ | 'proof-files-downloading'
+/** The proof file download failed; the attestor wasn't contacted. */
+ | 'proof-files-failed'
+/** Other local setup failed before the attestor was contacted. */
  | 'setup-failed';
 export interface AttestorCheckResult {
     ok: boolean;
@@ -50,6 +56,8 @@ export interface AttestorCheckResult {
     extractedParameters?: Record<string, string>;
     error?: string;
     errorKind?: AttestorCheckErrorKind;
+    /** The proof file download state when the check finished. */
+    proofFiles?: ZkFilesState;
 }
 /** Creates the claim on the attestor (`createClaimOnAttestor` by default). */
 export type CreateClaim = (args: Parameters<typeof createClaimOnAttestor>[0]) => Promise<unknown>;
@@ -60,6 +68,8 @@ export interface CheckAttestorOptions {
     createClaim?: CreateClaim;
     /** Replaces the ZK file download in tests. */
     prepare?: () => Promise<void>;
+    /** Reports the ZK file download state (`zkFilesState` by default). */
+    proofFilesState?: () => ZkFilesState;
 }
 /** True when `message` looks like a network failure rather than a rejection. */
 export declare function isNetworkError(message: string | undefined): boolean;

package/lib/proof/check-attestor.js

@@ -7,7 +7,7 @@ import { createClaimOnAttestor } from '@reclaimprotocol/attestor-core';
 import { generateKeypair } from '@reclaimprotocol/client';
 import "./patch-domhandler.js";
 import { claimRejection, ensureAttestorCrypto, parseClaim, resolveAttestorUrl, } from "./proof-core.js";
-import { ensureZkFiles } from "./zk-files.js";
+import { ensureZkFiles, zkFilesState } from "./zk-files.js";
 /**
  * Default time budget for one check. A live run takes about 8 s; a longer
  * budget risks the MCP client's own tool-call timeout.
@@ -87,9 +87,15 @@ export async function checkAttestor(opts = {}) {
         ensureAttestorCrypto();
         await ensureZkFiles();
     });
+    const proofFilesState = opts.proofFilesState ?? zkFilesState;
     const startedAt = Date.now();
     const finish = (outcome) => {
-        return { ...outcome, attestorUrl, durationMs: Date.now() - startedAt };
+        return {
+            ...outcome,
+            attestorUrl,
+            durationMs: Date.now() - startedAt,
+            proofFiles: proofFilesState(),
+        };
     };
     let timer;
     const timeout = new Promise((_, reject) => {
@@ -102,14 +108,7 @@ export async function checkAttestor(opts = {}) {
             await Promise.race([prepare(), timeout]);
         }
         catch (err) {
-            const error = messageOf(err);
-            return finish({
-                ok: false,
-                error,
-                errorKind: error.startsWith(CHECK_TIMEOUT_MESSAGE)
-                    ? 'attestor-unreachable'
-                    : 'setup-failed',
-            });
+            return finish({ ok: false, ...setupFailure(messageOf(err)) });
         }
         const claim = await Promise.race([
             createClaim({
@@ -150,6 +149,37 @@ export async function checkAttestor(opts = {}) {
     finally {
         clearTimeout(timer);
     }
+    /** Classify a failure before the attestor was contacted by the proof
+     *  file download state, so a slow or failed download never reads as an
+     *  unreachable attestor. */
+    function setupFailure(error) {
+        const files = proofFilesState();
+        if (files.status === 'downloading') {
+            const done = files.bytesDownloaded !== undefined
+                ? `, ${files.bytesDownloaded}`
+                    + (files.totalBytes !== undefined ? `/${files.totalBytes}` : '')
+                    + ' bytes'
+                : '';
+            return {
+                error: `proof files are still downloading (${files.method}, `
+                    + `${Math.round(files.elapsedMs / 1000)}s${done}); the attestor `
+                    + 'was not contacted. Run check_attestor again shortly.',
+                errorKind: 'proof-files-downloading',
+            };
+        }
+        if (files.status === 'failed') {
+            return {
+                error: `proof file download failed: ${files.reason}`,
+                errorKind: 'proof-files-failed',
+            };
+        }
+        return {
+            error,
+            errorKind: error.startsWith(CHECK_TIMEOUT_MESSAGE)
+                ? 'attestor-unreachable'
+                : 'setup-failed',
+        };
+    }
 }
 function messageOf(err) {
     return err instanceof Error ? err.message : String(err);

package/lib/proof/check-matchers.d.ts

@@ -0,0 +1,36 @@
+import './patch-domhandler.ts';
+import type { CapturedRequest, ReclaimProvider } from '../provider/schema.ts';
+export interface RevealedSlice {
+    /** Byte offsets in the response body. */
+    from: number;
+    to: number;
+    /** Revealed text, truncated to {@link MAX_SLICE_CHARS}. */
+    text: string;
+    /** Set when the slice is an OPRF-hashed value (plaintext here). */
+    hashed?: true;
+}
+export interface MatcherCheckResult {
+    /** True when the attestor would accept this response. */
+    ok: boolean;
+    /** Where it failed: building the request, selecting what to reveal, or
+     *  checking `responseMatches` on the revealed bytes. */
+    failedAt?: 'request' | 'redaction' | 'match';
+    /** Attestor-core's error, truncated. */
+    reason?: string;
+    /** Params the attestor would extract (regex groups + `paramValues` the
+     *  matches use). */
+    extractedParameters: Record<string, string>;
+    /** The response body slices revealed to the attestor. */
+    revealed: RevealedSlice[];
+    revealedSliceCount: number;
+    revealedBytes: number;
+    bodyBytes: number;
+    /** Set when an OPRF-hashed redaction was checked in plaintext. */
+    note?: string;
+}
+/**
+ * Check `provider`'s matchers against `captured`'s response body, offline.
+ * Uses the captured status and content type, so a non-2xx capture fails the
+ * same way it would at proof time.
+ */
+export declare function checkMatchersOffline(provider: ReclaimProvider, captured: Pick<CapturedRequest, 'status' | 'contentType' | 'responseBody'>): MatcherCheckResult;

package/lib/proof/check-matchers.js

@@ -0,0 +1,161 @@
+/**
+ * Offline matcher check: run a recipe's `responseRedactions` +
+ * `responseMatches` against a captured response with attestor-core's own HTTP
+ * provider, without a network call or a TLS session.
+ *
+ * It replays the two halves of a real proof on a synthetic transcript:
+ *   1. prover side: `providers.http.createRequest` builds the request and
+ *      `getResponseRedactions` picks the response slices to reveal (xPath /
+ *      jsonPath / regex, exactly as at proof time);
+ *   2. attestor side: `providers.http.assertValidProviderReceipt` checks the
+ *      redacted transcript against `responseMatches` and extracts params.
+ *
+ * Hashed (OPRF) slices stay in plaintext here: OPRF needs the attestor, so the
+ * check treats the value as its own nullifier. Everything else is the same
+ * engine the attestor runs.
+ */
+import { CURRENT_ATTESTOR_VERSION, PROVIDER_CTX, providers, redactSlices, } from '@reclaimprotocol/attestor-core';
+// Side-effect: make external domhandler nodes DOM-like so attestor-core's
+// bundled `xpath` accepts them (see patch-domhandler.ts).
+import "./patch-domhandler.js";
+import { LOGGER } from "../logger.js";
+import { buildHttpParams } from "./proof-core.js";
+/** Longest revealed slice returned; the full slice is still checked. */
+const MAX_SLICE_CHARS = 400;
+/** Most revealed slices returned. */
+const MAX_SLICES = 10;
+/** Longest error message returned (attestor errors can embed the base64 of
+ *  a whole element). */
+const MAX_REASON_CHARS = 600;
+/** Placeholder secret header: the request builder needs one secret, and the
+ *  check never sends the request. */
+const OFFLINE_SECRET = { 'X-Reclaim-Offline-Check': '1' };
+/**
+ * Check `provider`'s matchers against `captured`'s response body, offline.
+ * Uses the captured status and content type, so a non-2xx capture fails the
+ * same way it would at proof time.
+ */
+export function checkMatchersOffline(provider, captured) {
+    const http = providers.http;
+    const params = buildHttpParams(provider);
+    const logger = silentLogger();
+    const body = Buffer.from(captured.responseBody ?? '', 'utf8');
+    const head = Buffer.from(`HTTP/1.1 ${captured.status} ${captured.status < 300 ? 'OK' : 'ERR'}\r\n`
+        + `Content-Type: ${captured.contentType || 'text/plain'}\r\n`
+        + `Content-Length: ${body.length}\r\n\r\n`);
+    const response = new Uint8Array(Buffer.concat([head, body]));
+    const empty = {
+        extractedParameters: {},
+        revealed: [],
+        revealedSliceCount: 0,
+        revealedBytes: 0,
+        bodyBytes: body.length,
+    };
+    let request;
+    try {
+        const req = http.createRequest({ headers: OFFLINE_SECRET }, structuredClone(params), logger);
+        const data = typeof req.data === 'string'
+            ? new Uint8Array(Buffer.from(req.data))
+            : req.data;
+        request = redactSlices(data, req.redactions);
+    }
+    catch (err) {
+        return { ...empty, ok: false, failedAt: 'request', reason: reasonOf(err) };
+    }
+    let slices;
+    try {
+        slices = http.getResponseRedactions?.({
+            response, params: structuredClone(params), logger, ctx: PROVIDER_CTX,
+        }) ?? [];
+    }
+    catch (err) {
+        return { ...empty, ok: false, failedAt: 'redaction', reason: reasonOf(err) };
+    }
+    const hidden = slices.filter((s) => !s.hash);
+    const hashed = slices.filter((s) => s.hash);
+    const view = revealedSlices(head.length, response.length, hidden, hashed);
+    const redacted = redactSlices(response, hidden);
+    const seen = {
+        revealed: view.slice(0, MAX_SLICES).map((s) => ({
+            from: s.from,
+            to: s.to,
+            text: truncate(Buffer.from(response.subarray(head.length + s.from, head.length + s.to))
+                .toString('utf8'), MAX_SLICE_CHARS),
+            ...(s.hashed ? { hashed: true } : {}),
+        })),
+        revealedSliceCount: view.length,
+        revealedBytes: view.reduce((n, s) => n + s.to - s.from, 0),
+        bodyBytes: body.length,
+        ...(hashed.length
+            ? {
+                note: 'OPRF-hashed values were checked in plaintext; at proof time '
+                    + 'the attestor sees their nullifier instead.',
+            }
+            : {}),
+    };
+    try {
+        const out = http.assertValidProviderReceipt({
+            clientVersion: CURRENT_ATTESTOR_VERSION,
+            receipt: [
+                { sender: 'client', message: request },
+                { sender: 'server', message: redacted },
+            ],
+            params: structuredClone(params),
+            logger,
+            ctx: PROVIDER_CTX,
+        });
+        // The http provider validates synchronously; a thenable here would mean
+        // a provider we don't run offline.
+        const extracted = out instanceof Promise ? undefined : out;
+        return {
+            ok: true,
+            extractedParameters: extracted?.extractedParameters ?? {},
+            ...seen,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            failedAt: 'match',
+            reason: reasonOf(err),
+            extractedParameters: {},
+            ...seen,
+        };
+    }
+}
+/** Body-relative revealed ranges: the complement of `hidden` within the body,
+ *  merged with the hashed slices (revealed as their nullifier at proof time).
+ */
+function revealedSlices(bodyStart, total, hidden, hashed) {
+    const out = [];
+    let cursor = bodyStart;
+    const sorted = [...hidden].sort((a, b) => a.fromIndex - b.fromIndex);
+    for (const s of sorted) {
+        if (s.fromIndex > cursor) {
+            out.push({ from: cursor - bodyStart, to: s.fromIndex - bodyStart });
+        }
+        cursor = Math.max(cursor, s.toIndex);
+    }
+    if (cursor < total) {
+        out.push({ from: cursor - bodyStart, to: total - bodyStart });
+    }
+    for (const h of hashed) {
+        out.push({
+            from: h.fromIndex - bodyStart, to: h.toIndex - bodyStart, hashed: true,
+        });
+    }
+    return out
+        .filter((s) => s.to > s.from && s.from >= 0)
+        .sort((a, b) => a.from - b.from);
+}
+function reasonOf(err) {
+    return truncate(err instanceof Error ? err.message : String(err), MAX_REASON_CHARS);
+}
+function truncate(s, max) {
+    return s.length > max ? `${s.slice(0, max)}… (${s.length} chars)` : s;
+}
+/** A logger for attestor-core calls that records nothing: the check reports
+ *  its outcome in the result, and the provider logs whole responses. */
+function silentLogger() {
+    return LOGGER.child({ scope: 'check-matchers' }, { level: 'silent' });
+}