@crawlcheck/sdk 1.0.4 → 1.0.6

package/dist/gen/openapi.d.ts

@@ -105,32 +105,33 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/changes": {
+    "/api/v1/visitor": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** What moved: one event per resolve-answer section that changed when an answer was rebuilt (crawl_policy, delivery, machine_files, capabilities, entity, findings). ?since=<ISO time>, ?domain= for one domain's history, ?limit= up to 500. Re-resolve only the domains listed */
-        get: operations["resolveChangesV1"];
+        /** Visitor Resolve: is this request really from the agent its user agent names? ?ip=&ua= returns verified (inside the operator's published ranges), spoofed, unverifiable or not_a_known_agent. Nothing about the visitor is stored */
+        get: operations["visitorResolveV1"];
         put?: never;
-        post?: never;
+        /** Visitor Resolve for 1-100 requests at once: {visitors: [{ip, ua}]} */
+        post: operations["visitorResolveBatchV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/mcp/servers": {
+    "/api/v1/conduct": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Remote MCP servers the official MCP Registry lists on a domain, each with what its endpoint answered to the MCP handshake (initialize + tools/list; no tool is ever called): outcome, protocol version, tool count, tool-list hash and drift. Public */
-        get: operations["mcpServersForHost"];
+        /** Agent conduct record: for every verifiable agent, what it did on crawlcheck.io (verified by source address) - robots.txt respected or disallowed paths fetched, peak requests per minute against the site limit, conditional requests - plus how often its name is forged and what sites found when they checked visitors claiming it. Signed */
+        get: operations["conductV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -139,15 +140,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/mcp/index": {
+    "/api/v1/conduct/{agent}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The MCP Registry import and observation cycle: servers imported, endpoints observed this cycle by outcome (initialized, auth_required, unreachable, ...), tool-list drift, the most recent observations. Public */
-        get: operations["mcpIndex"];
+        /** The conduct record for one agent, e.g. GPTBot, signed on its own */
+        get: operations["conductAgentV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -156,67 +157,68 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/preflight": {
+    "/api/v1/mcp/lock": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Make an MCP tool lockfile for a server (?url=): handshake and tools/list only; per-tool SHA-256 of {name, description, inputSchema, annotations} and a list hash. Signed (crawlcheck-mcp-lock). Spec /spec/mcp-lockfile */
+        get: operations["mcpLockUrl"];
         put?: never;
-        /** The policy engine: before an action, POST {domain, action (read|cite|connect|transact|administer), agent?, template?, policy?} and receive a signed decision receipt (allow | warn | require_confirmation | block | unsupported) bound to the resolve answer it was made from. When the decision is not allow, alternatives[] names what to do instead (rescan, a machine file, a corroborated profile, an MCP endpoint that completed the handshake, human review), each from CrawlCheck’s own observations. A policy can only make the decision stricter. Templates: safe_citation, safe_data_retrieval, safe_api_connect, safe_mcp_tool, safe_commerce, safe_oauth, support_escalation */
-        post: operations["preflightV1"];
+        /** Make a lockfile from a tools/list result you hold ({tools:[...], url?}) or a server URL ({url}) */
+        post: operations["mcpLockTools"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/resolve": {
+    "/api/v1/mcp/lock/check": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Before acting on a domain: one signed answer. Crawler policy as declared (robots.txt per crawler), delivery as observed per identity, machine files, capabilities with policy classes and certificate, entity reciprocity and the open findings (top one in full without a licence), each section declared/observed/not_measured with its time. No overall score. An unknown domain answers not_measured and a measurement is requested */
-        get: operations["resolveDomainV1"];
+        get?: never;
         put?: never;
-        /** Batch resolve: POST {domains:[..]} (1-100) and receive each domain's signed ResolveV1 answer in one response */
-        post: operations["resolveBatchV1"];
+        /** Compare a lockfile with the server's current tools ({lock, tools} or {lock, url}): verdict unchanged | changed | unreachable, decision connect | block, tools added, removed and modified, the description text that moved. Signed (crawlcheck-mcp-lock-check) */
+        post: operations["mcpLockCheck"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/schemas/resolve.json": {
+    "/api/v1/mcp/scan": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** JSON Schema (2020-12) for the /api/v1/resolve answer */
-        get: operations["resolveSchema"];
+        /** Tool-poisoning scan of a remote MCP server (?url=): handshake and tools/list only, no tool is called; every tool text checked for hidden characters, instructions aimed at the model, requests for secrets or the conversation, and instructions about other tools. Signed */
+        get: operations["mcpScanUrl"];
         put?: never;
-        post?: never;
+        /** The same scan over a tools/list result you send ({tools:[...]}, up to 300) or a server URL ({url}). Signed */
+        post: operations["mcpScanTools"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/machine-record": {
+    "/api/v1/rights-feed": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The unified machine record for one observation: subject, grade, findings (top one in full without a licence), capabilities with verification, evidence roots and verifier links */
-        get: operations["getMachineRecordV1"];
+        /** Rights feed for crawler operators: the index of signed weekly editions covering the top 10,000 sites (per site: robots.txt groups to apply to any URL with your own token, Content-Signal, TDM-Rep, ai.txt, page directives, terms AI clauses, and the answer per use at the root); latest edition, the one being built, totals per use. Spec at /spec/rights-feed */
+        get: operations["rightsFeedIndex"];
         put?: never;
         post?: never;
         delete?: never;
@@ -225,15 +227,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/fix/cache": {
+    "/api/v1/rights-feed/{id}/{file}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** STALE_CACHE_SERVED fix plan: the homepage fetched now, its Age, the cache layers in purge order (innermost first), the declared HTML lifetime, a fresh-read comparison, and whether a purge clears the finding and keeps it cleared */
-        get: operations["fixStaleCache"];
+        /** One file of a finished rights-feed edition: manifest.json (signed crawlcheck-rights-feed: parts with sha256 and counts) or part-NNNN.ndjson.gz (one signed crawlcheck-rights line per site) */
+        get: operations["rightsFeedFile"];
         put?: never;
         post?: never;
         delete?: never;
@@ -242,15 +244,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/fix/chain": {
+    "/api/v1/rights": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** MACHINE_CHAIN_HEAVY fix plan: the files read before the page and the absent-file 404s, measured reductions with the chain size after each, and the step at which the detector stops firing */
-        get: operations["fixMachineChain"];
+        /** Rights Resolve: one permission answer per use (train, ground, summarize, cite, transact) for a domain and path, merged from robots.txt (the agent's own RFC 9309 group), Content-Signal, ai.txt, TDM-Rep, robots meta, X-Robots-Tag and the terms page; every value names the signal, URL and line or clause that decided it, with the conflicts. Signed */
+        get: operations["rightsV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -259,15 +261,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/fix/code": {
+    "/api/v1/read-equivalence": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** PAGE_IS_MOSTLY_CODE fix plan: the measured byte breakdown, ordered steps with the ratio after each, the step at which the detector stops firing, or the markup/text change needed when moving code cannot clear it */
-        get: operations["fixMostlyCode"];
+        /** Read-equivalence certificate for one URL: the main text served to GPTBot, ClaudeBot and PerplexityBot compared word by word with what a browser receives at the same moment; verdict per identity with the diff ratio and the sentences only one side received. Signed */
+        get: operations["readEquivalenceV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -276,15 +278,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/corroboration": {
+    "/api/v1/claims": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Each observer's reading of the identity-dependent findings side by side (primary Worker vs the independent second observer), with a corroboration status per finding */
-        get: operations["getCorroboration"];
+        /** Self-claim ledger: what a site says about itself (telephone, email, address, hours, prices, refund window, founded, years in business, API rate limits) from its own pages, each value with first_seen and last_seen, plus the claim changes CrawlCheck recorded. Signed */
+        get: operations["selfClaimsV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -293,117 +295,118 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/explain": {
+    "/api/v1/origin": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One finding explained: rule and revision, compared fetches, valid time, Merkle proof of the decision in the signed manifest */
-        get: operations["explainFinding"];
+        /** Canonical origin for an anchored passage (?passage=<anchor id>): which page published it first and which carry copies, from the copies' rel=canonical, Internet Archive first captures, declared dates and CrawlCheck's own sightings. Signed */
+        get: operations["originByAnchorV1"];
         put?: never;
-        post?: never;
+        /** Canonical origin for {text, urls[]} (up to 8 pages): the same decision for any passage and set of pages; pages a copy names as canonical are added automatically */
+        post: operations["originV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/observe/enroll": {
+    "/api/v1/content-clock": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Content-change clock for a page: a hash of its main content (chrome, ads, cookie banners and scripts removed; dates, times and tokens masked), when that content was first seen, the bounds of the last observed change, and what the page itself declares (Last-Modified, dateModified, article:modified_time) with whether the two agree. Read at most every 10 minutes; signed */
+        get: operations["contentClockV1"];
         put?: never;
-        /** Enrol an independent observer (open observer protocol v1): an Ed25519 key, an id ind:<name>, operator and network, signed with the key it enrols; the id is bound to the first key that claims it */
-        post: operations["enrolObserver"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/observe/check": {
+    "/api/v1/cited-by": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** The cited-by index: for ?url= a page or ?domain= a site, how often agents cited it through CrawlCheck (citation anchors, cite preflights), by how many distinct citing networks, how many distinct passages, and whether the quoted text is still on the page (latest recheck per anchor). Citer counts and agent names withheld below 3 citing networks */
+        get: operations["citedByV1"];
         put?: never;
-        /** Run the Worker's own checks on an observation or enrolment without storing it: shape, key against the directory entry (the live directory, or one you send), signature. The fixtures at /observer/fixtures.json run against it */
-        post: operations["checkObservation"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/data/inventory": {
+    "/api/v1/anchor": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Everything held about a domain, signed: each family of stored keys with counts and bytes, what is kept after deletion and why. Licence for the domain or owner */
-        get: operations["dataInventory"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Citation notarization: {url, text} fetches the page, finds the quoted passage in its visible text and returns a signed anchor (URL, text-fragment selector, passage hash, page text hash, time) that also joins the day's OpenTimestamps-anchored Merkle seal. 422 when the passage is not on the page. 30 per hour per address */
+        post: operations["anchorCreateV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/data/export": {
+    "/api/v1/anchor/{id}/watch": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Export everything held about a domain in signed parts: part 0 = the inventory and every stored row; then archived records with the bytes each fetch received; then receipts, dispute resolutions and observations */
-        get: operations["dataExport"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Correction propagation: {webhook} (https, public host). The anchor is rechecked every 15 minutes; when its status changes (present / no_longer_present / page_unreachable, the last only after two failed checks) the webhook receives a signed crawlcheck-anchor-check with previous_status. Up to 5 webhooks per anchor; POST /api/v1/anchor also takes webhook */
+        post: operations["anchorWatchV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/data/delete": {
+    "/api/v1/anchor/sink/{token}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** A test webhook: use https://crawlcheck.io/api/v1/anchor/sink/<token> as a webhook and read the last 10 deliveries here (kept one day) */
+        get: operations["anchorSinkV1"];
         put?: never;
-        /** Delete everything held about a domain: {domain, confirm: domain, inventory_sha256} starts a job (an inventory issued in the last 24 hours is required); POST {job} continues it. Ends in a signed deletion record */
-        post: operations["dataDelete"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/data/deletion": {
+    "/api/v1/anchor/{id}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A signed deletion record: counts per family and the digest of the deleted-key list, never the data */
-        get: operations["dataDeletionRecord"];
+        /** An anchor and its seal state. ?recheck=1 refetches the page and returns a signed crawlcheck-anchor-check: present, no_longer_present or page_unreachable. A passage edited away is no_longer_present, never false */
+        get: operations["anchorGetV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -412,15 +415,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/trace/coverage": {
+    "/api/v1/visitor/arrival": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Trace coverage: per scan, how many findings and claims link their own rule span, how many stage errors name a span, broken parent links, malformed or duplicate ids, dropped spans. ?id= one record (counts public; unlinked codes with a licence); without id the last 300 scans and the latest CI result */
-        get: operations["traceCoverage"];
+        /** A site's own Cloudflare Worker reports one agent request (ua, path, verdict) after answering it; the site is proven by the CF-Worker header Cloudflare sets on Worker subrequests. Counts toward the Agent Traffic Index and the network figures on /data. 403 from anything that is not a Worker subrequest */
+        get: operations["visitorArrivalV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -429,68 +432,66 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/trace/ci": {
+    "/api/v1/traffic-index": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The latest trace CI result (schema violations, broken parent links, unlinked findings) and its history */
-        get: operations["traceCiResult"];
+        /** The Agent Traffic Index, month to date: per agent, how many reporting sites it visited, fetches, verified / forged / unverifiable by source address, machine-file share. Agent rows only above a 5-site floor; no site named. Signed */
+        get: operations["trafficIndexV1"];
         put?: never;
-        /** Callable only by this repository's trace workflow (GitHub OIDC, audience crawlcheck-trace): phase sample returns real traces (TraceV1) to validate; phase report stores the verdict */
-        post: operations["traceCi"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/disputes": {
+    "/api/v1/traffic-index/{month}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The dispute and correction ledger: every dispute filed against a finding, its state and verdict. ?id=dsp1:… returns one dispute with its readings and events; ?domain= filters */
-        get: operations["disputeLedger"];
+        /** A monthly edition of the Agent Traffic Index (YYYY-MM). Complete months are final and signed once */
+        get: operations["trafficIndexMonthV1"];
         put?: never;
-        /** File a dispute against one finding on one record: {report_id, code, path?, ground: misread|fixed|network|rule, statement}. Accepted at once with a licence for the domain or the owner session; otherwise answers 202 with a token to serve at /.well-known/crawlcheck-dispute.txt */
-        post: operations["fileDispute"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/disputes/confirm": {
+    "/api/v1/visitor/stats": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Daily counts of visitor checks for the last 14 days, by verdict and claimed agent. Counts only */
+        get: operations["visitorStatsV1"];
         put?: never;
-        /** After serving the token at https://<domain>/.well-known/crawlcheck-dispute.txt, accept the dispute */
-        post: operations["confirmDisputeOwnership"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/disputes/resolution": {
+    "/api/v1/decisions/{sha256}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A signed dispute resolution (machine record). Verify offline: node crawlcheck-verify.mjs resolution.json */
-        get: operations["getDisputeResolution"];
+        /** Check a CrawlCheck-Receipt header: a site sends the decision receipt digest it received (and ?host= its own host) and gets accept plus the checks behind it (host matches, not expired, decision allow or warn) and the full signed receipt. Receipts are held until a day after they expire */
+        get: operations["decisionCheckV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -499,33 +500,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/disputes/verify": {
+    "/api/v1/decisions": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Check a stored resolution server side: hash, key id, key published, signature, verdict re-derived, readings after the dispute */
-        get: operations["verifyDisputeResolution"];
+        /** Daily counts for the last 14 days: preflight decisions issued, and CrawlCheck-Receipt headers checked by sites (found, accepted, by decision and action). Counts only */
+        get: operations["decisionStatsV1"];
         put?: never;
-        /** Check a resolution you hold */
-        post: operations["verifyDisputeResolutionPost"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/datasets": {
+    "/api/v1/resolve-prefix/{prefix}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The dataset catalogue: counts per lane and day, the latest day's breakdown, the field dictionary and the technology list. Public */
-        get: operations["datasetCatalogue"];
+        /** Private lookup: send 2-8 hex characters of sha256(domain) and receive every measured domain's signed ResolveV1 answer in that bucket, so the domain you are about to act on is never sent. Pick your match locally */
+        get: operations["resolvePrefixV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -534,15 +534,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/datasets/sample": {
+    "/api/v1/snapshot": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** 25 measured rows from the latest files. Public */
-        get: operations["datasetSample"];
+        /** The daily signed snapshot of every public Resolve answer: the latest manifest, the snapshot in progress, and the finished snapshots kept (newest 7). CC BY 4.0, no key */
+        get: operations["resolveSnapshotIndex"];
         put?: never;
         post?: never;
         delete?: never;
@@ -551,15 +551,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/datasets/file": {
+    "/api/v1/snapshot/{id}/{file}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One lane's file for one day, CSV or NDJSON, filterable. Needs a licence key with dataset access */
-        get: operations["datasetFile"];
+        /** One file of a finished snapshot: manifest.json (signed crawlcheck-snapshot: parts with sha256 and record counts) or part-NNNN.ndjson.gz (gzip NDJSON, one signed ResolveV1 answer per line). Immutable once published */
+        get: operations["resolveSnapshotFile"];
         put?: never;
         post?: never;
         delete?: never;
@@ -568,15 +568,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/datasets/state": {
+    "/api/v1/changes": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One US state's local businesses across every day it was scanned. Needs a key with the local lane */
-        get: operations["datasetState"];
+        /** What moved: one event per resolve-answer section that changed when an answer was rebuilt (crawl_policy, delivery, machine_files, capabilities, entity, findings). ?since=<ISO time>, ?domain= for one domain's history, ?limit= up to 500. Re-resolve only the domains listed */
+        get: operations["resolveChangesV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -585,32 +585,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/datasets/request": {
+    "/api/mcp/servers": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Remote MCP servers the official MCP Registry lists on a domain, each with what its endpoint answered to the MCP handshake (initialize + tools/list; no tool is ever called): outcome, protocol version, tool count, tool-list hash and drift. Public */
+        get: operations["mcpServersForHost"];
         put?: never;
-        /** Ask for dataset access. Public, one request a minute per address */
-        post: operations["datasetRequest"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/lanes": {
+    "/api/mcp/index": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The day's scan lanes and their quotas (SaaS 5,000, government and education 2,500, one US state's local businesses 5,000): measured, unmeasured, kinds detected, the state in rotation. Public */
-        get: operations["scanLanes"];
+        /** The MCP Registry import and observation cycle: servers imported, endpoints observed this cycle by outcome (initialized, auth_required, unreachable, ...), tool-list drift, the most recent observations. Public */
+        get: operations["mcpIndex"];
         put?: never;
         post?: never;
         delete?: never;
@@ -619,49 +619,50 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/census": {
+    "/api/v1/preflight": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The agentic-web census: the frame (a frozen Tranco top-1,000 list), every run, the latest figures with their denominators, and the change since the first run (percentage points and sites that gained or lost each property). Public */
-        get: operations["agenticWebCensus"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** The policy engine: before an action, POST {domain, action (read|cite|connect|transact|administer), agent?, template?, policy?} and receive a signed decision receipt (allow | warn | require_confirmation | block | unsupported) bound to the resolve answer it was made from. When the decision is not allow, alternatives[] names what to do instead (rescan, a machine file, a corroborated profile, an MCP endpoint that completed the handshake, human review), each from CrawlCheck’s own observations. A policy can only make the decision stricter. Templates: safe_citation, safe_data_retrieval, safe_api_connect, safe_mcp_tool, safe_commerce, safe_oauth, support_escalation */
+        post: operations["preflightV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/census/records": {
+    "/api/v1/resolve": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One run's per-site records in frame order: the raw readings (statuses, sizes, SHA-256 of what each identity was served, the robots.txt text, each machine file) and the derived fields every figure counts */
-        get: operations["censusRecords"];
+        /** Before acting on a domain: one signed answer. Crawler policy as declared (robots.txt per crawler), delivery as observed per identity, machine files, capabilities with policy classes and certificate, entity reciprocity and the open findings (top one in full without a licence), each section declared/observed/not_measured with its time. No overall score. An unknown domain answers not_measured and a measurement is requested */
+        get: operations["resolveDomainV1"];
         put?: never;
-        post?: never;
+        /** Batch resolve: POST {domains:[..]} (1-100) and receive each domain's signed ResolveV1 answer in one response */
+        post: operations["resolveBatchV1"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/census/frame": {
+    "/schemas/resolve.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The census sampling frame: the Tranco list id and configuration, the members measured, and the counts excluded by the publish filter and by opt-out */
-        get: operations["censusFrame"];
+        /** JSON Schema (2020-12) for the /api/v1/resolve answer */
+        get: operations["resolveSchema"];
         put?: never;
         post?: never;
         delete?: never;
@@ -670,15 +671,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/registry/capabilities": {
+    "/api/v1/machine-record": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The capability registry: every measured site that declares agent capabilities, with counts by invocation policy class; ?domain= returns one site's capabilities declared beside observed, its mismatches and its signed capability certificate. Public */
-        get: operations["capabilityRegistry"];
+        /** The unified machine record for one observation: subject, grade, findings (top one in full without a licence), capabilities with verification, evidence roots and verifier links */
+        get: operations["getMachineRecordV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -687,33 +688,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/registry/capabilities/verify": {
+    "/api/fix/cache": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Recompute a site's capability certificate from its stored record and verify it: hash, key id, published key, Ed25519 signature */
-        get: operations["verifyCapabilityCertificate"];
+        /** STALE_CACHE_SERVED fix plan: the homepage fetched now, its Age, the cache layers in purge order (innermost first), the declared HTML lifetime, a fresh-read comparison, and whether a purge clears the finding and keeps it cleared */
+        get: operations["fixStaleCache"];
         put?: never;
-        /** Verify a capability certificate you hold (the JSON from /api/registry/capabilities?domain=) */
-        post: operations["verifyCapabilityCertificatePost"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/registry/capabilities/feed.json": {
+    "/api/fix/chain": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The capability registry as a JSON Feed 1.1: one item per site, updated when it is measured again */
-        get: operations["capabilityRegistryFeed"];
+        /** MACHINE_CHAIN_HEAVY fix plan: the files read before the page and the absent-file 404s, measured reductions with the chain size after each, and the step at which the detector stops firing */
+        get: operations["fixMachineChain"];
         put?: never;
         post?: never;
         delete?: never;
@@ -722,15 +722,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/capabilities": {
+    "/api/fix/code": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Declared agent capabilities with safety class, verification state and declaration-vs-behaviour mismatches, from the latest scan */
-        get: operations["listVerifiedCapabilities"];
+        /** PAGE_IS_MOSTLY_CODE fix plan: the measured byte breakdown, ordered steps with the ratio after each, the step at which the detector stops firing, or the markup/text change needed when moving code cannot clear it */
+        get: operations["fixMostlyCode"];
         put?: never;
         post?: never;
         delete?: never;
@@ -739,15 +739,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/reports/{id}": {
+    "/api/corroboration": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A stored report as PublicReportV1 (licence or read-scoped API key) */
-        get: operations["getReportV1"];
+        /** Each observer's reading of the identity-dependent findings side by side (primary Worker vs the independent second observer), with a corroboration status per finding */
+        get: operations["getCorroboration"];
         put?: never;
         post?: never;
         delete?: never;
@@ -756,15 +756,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/locate": {
+    "/api/explain": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Check every source locator in a record against the stored page: each extracted value's UTF-8 byte range is cut from the sealed page bytes (re-hashed first) and compared with the recorded value. With finding=CODE, the same for a finding: the robots.txt lines, the HTML tag served where a file should be, the empty <urlset>, an absence re-checked over the whole stored file, a manifest field */
-        get: operations["locateFacts"];
+        /** One finding explained: rule and revision, compared fetches, valid time, Merkle proof of the decision in the signed manifest */
+        get: operations["explainFinding"];
         put?: never;
         post?: never;
         delete?: never;
@@ -773,49 +773,49 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/sdk/index.json": {
+    "/api/observe/enroll": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** @crawlcheck/sdk versions: tarball URL, sha256, npm integrity string, the verifier it bundles and the number of API paths it is typed from. Install: npm i @crawlcheck/sdk (npm), or npm i https://crawlcheck.io/sdk/crawlcheck-sdk-<version>.tgz. Public */
-        get: operations["sdkVersions"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Enrol an independent observer (open observer protocol v1): an Ed25519 key, an id ind:<name>, operator and network, signed with the key it enrols; the id is bound to the first key that claims it */
+        post: operations["enrolObserver"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/conformance/index.json": {
+    "/api/observe/check": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The conformance suite: real bundles and receipts of crawlcheck.io's own scans (valid in three manifest eras, incomplete, unsealed, tampered one field at a time, contradictory, foreign-key) with the exact output a conforming verifier must give for every check, each file's SHA-256, and the runner (/conformance/run.mjs) that checks a verifier against all of them. Public */
-        get: operations["conformanceIndex"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Run the Worker's own checks on an observation or enrolment without storing it: shape, key against the directory entry (the live directory, or one you send), signature. The fixtures at /observer/fixtures.json run against it */
+        post: operations["checkObservation"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/receipt": {
+    "/api/data/inventory": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A signed remediation receipt by its id (rc1:<sha256>): the record before a fix, the declared fix, when it went live, the record after and the verification verdict with the files that changed, signed Ed25519 over sha256(canonical JSON). Returned with the server's own check; &download=1 gives the file for the offline verifier (node crawlcheck-verify.mjs receipt.json). The id is unguessable: whoever holds it can open it */
-        get: operations["getReceipt"];
+        /** Everything held about a domain, signed: each family of stored keys with counts and bytes, what is kept after deletion and why. Licence for the domain or owner */
+        get: operations["dataInventory"];
         put?: never;
         post?: never;
         delete?: never;
@@ -824,49 +824,49 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/receipt/verify": {
+    "/api/data/export": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Export everything held about a domain in signed parts: part 0 = the inventory and every stored row; then archived records with the bytes each fetch received; then receipts, dispute resolutions and observations */
+        get: operations["dataExport"];
         put?: never;
-        /** Verify any remediation receipt: POST its JSON; receipt_hash, key_id, key_published, signature. Public */
-        post: operations["verifyReceipt"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/receipts": {
+    "/api/data/delete": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A site's receipts, newest first (licence or owner) */
-        get: operations["listReceipts"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Delete everything held about a domain: {domain, confirm: domain, inventory_sha256} starts a job (an inventory issued in the last 24 hours is required); POST {job} continues it. Ends in a signed deletion record */
+        post: operations["dataDelete"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/rules": {
+    "/api/data/deletion": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The rulebook: every finding code the scanner can raise, with what it means, its level, its fix and its share of counted scans. Public. ?code= returns one rule */
-        get: operations["rulebook"];
+        /** A signed deletion record: counts per family and the digest of the deleted-key list, never the data */
+        get: operations["dataDeletionRecord"];
         put?: never;
         post?: never;
         delete?: never;
@@ -875,15 +875,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/schemas/rulebook.json": {
+    "/api/trace/coverage": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** JSON Schema (2020-12) for /api/rules: RulebookV1 and RuleV1, the same definitions /api/v1/schema carries */
-        get: operations["getRulebookSchema"];
+        /** Trace coverage: per scan, how many findings and claims link their own rule span, how many stage errors name a span, broken parent links, malformed or duplicate ids, dropped spans. ?id= one record (counts public; unlinked codes with a licence); without id the last 300 scans and the latest CI result */
+        get: operations["traceCoverage"];
         put?: never;
         post?: never;
         delete?: never;
@@ -892,100 +892,103 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/lineage-coverage": {
+    "/api/trace/ci": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The lineage coverage matrix: for every finding family, how many real findings carry each link of the evidence path (exact source locator, extraction, claim/observation, rule input, decision, score contribution, verified) and the replay of the rule over sealed bytes, computed from the newest stored records. Public, cached six hours */
-        get: operations["lineageCoverage"];
+        /** The latest trace CI result (schema violations, broken parent links, unlinked findings) and its history */
+        get: operations["traceCiResult"];
         put?: never;
-        post?: never;
+        /** Callable only by this repository's trace workflow (GitHub OIDC, audience crawlcheck-trace): phase sample returns real traces (TraceV1) to validate; phase report stores the verdict */
+        post: operations["traceCi"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/lineage": {
+    "/api/disputes": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One finding's evidence path, cell by cell, with the rule replayed over the sealed bytes where its input is sealed (and the reason where it is not). Gated like /api/explain: the top finding is free, a code lookup needs a licence for the domain */
-        get: operations["findingLineage"];
+        /** The dispute and correction ledger: every dispute filed against a finding, its state and verdict. ?id=dsp1:… returns one dispute with its readings and events; ?domain= filters */
+        get: operations["disputeLedger"];
         put?: never;
-        post?: never;
+        /** File a dispute against one finding on one record: {report_id, code, path?, ground: misread|fixed|network|rule, statement}. Accepted at once with a licence for the domain or the owner session; otherwise answers 202 with a token to serve at /.well-known/crawlcheck-dispute.txt */
+        post: operations["fileDispute"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/workflow": {
+    "/api/disputes/confirm": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One finding on one site, end to end: detected, exact evidence, fix recommended, impact projected, implementation recorded, rescanned, corroborated by a second observer, signed receipt, regression watch, outcomes. Every step is a link to the record that proves it, with done:true only when that record exists. Public for the exemplar sites on /workflow; a licence for the domain or the owner otherwise */
-        get: operations["fixChain"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** After serving the token at https://<domain>/.well-known/crawlcheck-dispute.txt, accept the dispute */
+        post: operations["confirmDisputeOwnership"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/workflow/record": {
+    "/api/disputes/resolution": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** A signed dispute resolution (machine record). Verify offline: node crawlcheck-verify.mjs resolution.json */
+        get: operations["getDisputeResolution"];
         put?: never;
-        /** Record a fix: finds the newest record that carried the code and the first after it that did not, issues the signed remediation receipt with the declared fix inside it, and queues the second observer on the fixed URL (licence for the domain, or owner) */
-        post: operations["recordFixChain"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/observation": {
+    "/api/disputes/verify": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One signed second-observer observation in full: the envelope (fetches with status, headers kept, sha256 of each body), the run key's Ed25519 signature, GitHub's OIDC token binding the key to the enrolled workflow, the checks run on receipt and the readings derived from the bytes. Public */
-        get: operations["getObservation"];
+        /** Check a stored resolution server side: hash, key id, key published, signature, verdict re-derived, readings after the dispute */
+        get: operations["verifyDisputeResolution"];
         put?: never;
-        post?: never;
+        /** Check a resolution you hold */
+        post: operations["verifyDisputeResolutionPost"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/outcomes": {
+    "/api/datasets": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** What the owner's connected sources counted either side of a receipt's anchor day: Search Console clicks and impressions, Business Profile actions, verified crawler fetches from the site's own log, beacon arrivals, enquiries through the form and anything posted to /api/outcome. One named source per series, per-day means compared, a missing day never zero, a thin window reported as thin. A coincidence in time, stated as one: it never claims the fix caused the movement (licence for the domain, or owner) */
-        get: operations["fixOutcomes"];
+        /** The dataset catalogue: counts per lane and day, the latest day's breakdown, the field dictionary and the technology list. Public */
+        get: operations["datasetCatalogue"];
         put?: never;
         post?: never;
         delete?: never;
@@ -994,15 +997,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/evidence/export": {
+    "/api/datasets/sample": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Evidence line: one signed file carrying every measurement (with its evidence bundle), receipt, certificate day and seal for a domain and period; verifies offline with crawlcheck-verify.mjs (Evidence add-on, Agency, or owner) */
-        get: operations["evidenceExport"];
+        /** 25 measured rows from the latest files. Public */
+        get: operations["datasetSample"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1011,15 +1014,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/evidence/ledger": {
+    "/api/datasets/file": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Evidence line: one row per measured day in the window with the day's reading, archived records and seal state, plus receipts and certificate history (Evidence add-on, Agency, or owner) */
-        get: operations["evidenceLedger"];
+        /** One lane's file for one day, CSV or NDJSON, filterable. Needs a licence key with dataset access */
+        get: operations["datasetFile"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1028,15 +1031,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/evidence/receipts": {
+    "/api/datasets/state": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Evidence line: every remediation receipt across every domain on the key, newest first (Evidence add-on, Agency, or owner) */
-        get: operations["evidenceReceipts"];
+        /** One US state's local businesses across every day it was scanned. Needs a key with the local lane */
+        get: operations["datasetState"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1045,32 +1048,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/benchmark": {
+    "/api/datasets/request": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Intelligence line: corpus percentile and next band, cohort metrics, and the rarity of each visible finding across daily-measured sites (Intelligence add-on, Growth, or owner) */
-        get: operations["benchmark"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Ask for dataset access. Public, one request a minute per address */
+        post: operations["datasetRequest"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/portfolio/compare": {
+    "/api/lanes": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Intelligence line: two to 40 domains side by side from their latest records, with the spread and the finding codes shared across them (Intelligence add-on, Growth, or owner) */
-        get: operations["portfolioCompare"];
+        /** The day's scan lanes and their quotas (SaaS 5,000, government and education 2,500, one US state's local businesses 5,000): measured, unmeasured, kinds detected, the state in rotation. Public */
+        get: operations["scanLanes"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1079,32 +1082,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/verify/bulk": {
+    "/api/census": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** The agentic-web census: the frame (a frozen Tranco top-1,000 list), every run, the latest figures with their denominators, and the change since the first run (percentage points and sites that gained or lost each property). Public */
+        get: operations["agenticWebCensus"];
         put?: never;
-        /** Intelligence line: run every server-side verifier on up to 25 ids in one call (Intelligence add-on, Growth, or owner) */
-        post: operations["verifyBulk"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/rollback": {
+    "/api/census/records": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Compare the record before a fix with the record after it (licence or owner): findings cleared and new by fingerprint, rows now passing and now failing, every machine file whose bytes changed, a verdict (improved / unchanged / mixed / regressed), each regression pinned to the changed file it reads, and the rollback step for that file (restore the stored bytes, or remove a file that did not exist before) */
-        get: operations["verifyAndRollback"];
+        /** One run's per-site records in frame order: the raw readings (statuses, sizes, SHA-256 of what each identity was served, the robots.txt text, each machine file) and the derived fields every figure counts */
+        get: operations["censusRecords"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1113,15 +1116,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/rollback/file": {
+    "/api/census/frame": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The exact bytes a machine file served in a given record, from the artifact store, re-hashed before they are returned (licence or owner) */
-        get: operations["rollbackFile"];
+        /** The census sampling frame: the Tranco list id and configuration, the members measured, and the counts excluded by the publish filter and by opt-out */
+        get: operations["censusFrame"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1130,51 +1133,50 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/impact": {
+    "/api/registry/capabilities": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** What fixing one thing changes on a record (licence or owner): per fix - robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair - the findings and rows it clears, the ones it clears only together with another fix, the root causes it closes, the certificate criteria it flips and the score and letter after */
-        get: operations["fixImpact"];
+        /** The capability registry: every measured site that declares agent capabilities, with counts by invocation policy class; ?domain= returns one site's capabilities declared beside observed, its mismatches and its signed capability certificate. Public */
+        get: operations["capabilityRegistry"];
         put?: never;
-        /** The same with a body: {id, fix:[ids]} */
-        post: operations["fixImpactPost"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/whatif": {
+    "/api/registry/capabilities/verify": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Recompute the score and letter for a record with any set of failing rows passing and findings cleared (licence or owner): the combined effect, which individual points cannot give, plus the least set that reaches the next letter */
-        get: operations["whatIf"];
+        /** Recompute a site's capability certificate from its stored record and verify it: hash, key id, published key, Ed25519 signature */
+        get: operations["verifyCapabilityCertificate"];
         put?: never;
-        /** The same, with rows to fix: {id, fix:[{section_id,row}], clear:[codes]} */
-        post: operations["whatIfPost"];
+        /** Verify a capability certificate you hold (the JSON from /api/registry/capabilities?domain=) */
+        post: operations["verifyCapabilityCertificatePost"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/ns": {
+    "/registry/capabilities/feed.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The CrawlCheck vocabulary (https://crawlcheck.io/ns#) as RDFS in JSON-LD: every class and property the JSON-LD export uses, with labels and comments */
-        get: operations["getVocabulary"];
+        /** The capability registry as a JSON Feed 1.1: one item per site, updated when it is measured again */
+        get: operations["capabilityRegistryFeed"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1183,15 +1185,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/schemas/openlineage-facets.json": {
+    "/api/capabilities": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** JSON Schema for CrawlCheck's OpenLineage facets (CrawlCheckRunFacet, CrawlCheckFetchFacet, CrawlCheckReportFacet), each extending the OpenLineage 2-0-2 BaseFacet */
-        get: operations["getOpenLineageFacetSchema"];
+        /** Declared agent capabilities with safety class, verification state and declaration-vs-behaviour mismatches, from the latest scan */
+        get: operations["listVerifiedCapabilities"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1200,15 +1202,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/schemas/machine-experience-record.json": {
+    "/api/v1/reports/{id}": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** JSON Schema (2020-12) for the sealed scan manifest: every fetch a scan made, as which identity, with which headers, what came back and whether the bytes were kept; validated against 221 sealed manifests */
-        get: operations["getMachineExperienceRecordSchema"];
+        /** A stored report as PublicReportV1 (licence or read-scoped API key) */
+        get: operations["getReportV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1217,15 +1219,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/schema": {
+    "/api/locate": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** JSON Schema for every v1 response */
-        get: operations["getSchemaV1"];
+        /** Check every source locator in a record against the stored page: each extracted value's UTF-8 byte range is cut from the sealed page bytes (re-hashed first) and compared with the recorded value. With finding=CODE, the same for a finding: the robots.txt lines, the HTML tag served where a file should be, the empty <urlset>, an absence re-checked over the whole stored file, a manifest field */
+        get: operations["locateFacts"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1234,121 +1236,117 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/keys": {
+    "/sdk/index.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** List the scoped API keys on a licence (names, scopes, last use; never the keys) */
-        get: operations["listApiKeys"];
+        /** @crawlcheck/sdk versions: tarball URL, sha256, npm integrity string, the verifier it bundles and the number of API paths it is typed from. Install: npm i @crawlcheck/sdk (npm), or npm i https://crawlcheck.io/sdk/crawlcheck-sdk-<version>.tgz. Public */
+        get: operations["sdkVersions"];
         put?: never;
-        /** Create a scoped API key (shown once; stored as a SHA-256) */
-        post: operations["createApiKey"];
-        /** Revoke an API key by id */
-        delete: operations["revokeApiKey"];
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/share": {
+    "/conformance/index.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** The conformance suite: real bundles and receipts of crawlcheck.io's own scans (valid in three manifest eras, incomplete, unsealed, tampered one field at a time, contradictory, foreign-key) with the exact output a conforming verifier must give for every check, each file's SHA-256, and the runner (/conformance/run.mjs) that checks a verifier against all of them. Public */
+        get: operations["conformanceIndex"];
         put?: never;
-        /** Create a scoped share link for one report (licence required; up to 90 days; revocable) */
-        post: operations["createShareLink"];
-        /** Revoke a share link created with the same licence */
-        delete: operations["revokeShareLink"];
+        post?: never;
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/scan/licensed": {
+    "/api/receipt": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** A signed remediation receipt by its id (rc1:<sha256>): the record before a fix, the declared fix, when it went live, the record after and the verification verdict with the files that changed, signed Ed25519 over sha256(canonical JSON). Returned with the server's own check; &download=1 gives the file for the offline verifier (node crawlcheck-verify.mjs receipt.json). The id is unguessable: whoever holds it can open it */
+        get: operations["getReceipt"];
         put?: never;
-        /** Scan a domain on the licensed lane (valid licence key required; 60 scans per ten minutes per key; 404 without a key) */
-        post: operations["scanDomainLicensed"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/tool/wba": {
+    "/api/receipt/verify": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Audit a Web Bot Auth key directory: no redirects, content type, RFC 7638 thumbprints, and which keys the directory's own signatures prove */
-        get: operations["checkBotKeyDirectory"];
+        get?: never;
         put?: never;
-        /** Verify a pasted Web Bot Auth request: the agent's directory, then the request's signature against a key the directory proves it holds */
-        post: operations["verifySignedBotRequest"];
+        /** Verify any remediation receipt: POST its JSON; receipt_hash, key_id, key_published, signature. Public */
+        post: operations["verifyReceipt"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/tool/verify": {
+    "/api/receipts": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** A site's receipts, newest first (licence or owner) */
+        get: operations["listReceipts"];
         put?: never;
-        /** Adjudicate crawler identity claims in raw access-log lines against each operator's published IP ranges */
-        post: operations["verifyCrawlerLog"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/depth": {
+    "/api/rules": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** The rulebook: every finding code the scanner can raise, with what it means, its level, its fix and its share of counted scans. Public. ?code= returns one rule */
+        get: operations["rulebook"];
         put?: never;
-        /** Crawl the URLs the site declares and map the links between them: orphans, undeclared pages, per-page status, canonical, text ratio, JSON-LD, noindex. Up to 300 pages in one pass; pages up to 500 (Watch, Studio) or 5000 (Agency, Network) runs as a background job in chunks of 300, advanced by every poll of /api/depth/{id} and every hour. Sites declaring more than the cap are sampled across path families. Licence-gated; 404 without a key. Returns 202 with a job id */
-        post: operations["depthCrawl"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/depth/{id}": {
+    "/schemas/rulebook.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The depth-crawl record for a job id: orphans, undeclared, pages[], medians and stated limits */
-        get: operations["depthResult"];
+        /** JSON Schema (2020-12) for /api/rules: RulebookV1 and RuleV1, the same definitions /api/v1/schema carries */
+        get: operations["getRulebookSchema"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1357,15 +1355,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/usage": {
+    "/api/lineage-coverage": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** This key's monthly scan quota and usage; every keyed response also carries x-crawlcheck-quota-* headers */
-        get: operations["usage"];
+        /** The lineage coverage matrix: for every finding family, how many real findings carry each link of the evidence path (exact source locator, extraction, claim/observation, rule input, decision, score contribution, verified) and the replay of the rule over sealed bytes, computed from the newest stored records. Public, cached six hours */
+        get: operations["lineageCoverage"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1374,15 +1372,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/verify": {
+    "/api/lineage": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Every verifier in one call: record digest, seal + Bitcoin anchor, manifest signature (WBA Ed25519), stored manifest bytes, kept artifacts, decision pointers, provenance envelope, self-audit. Public */
-        get: operations["verifyRecord"];
+        /** One finding's evidence path, cell by cell, with the rule replayed over the sealed bytes where its input is sealed (and the reason where it is not). Gated like /api/explain: the top finding is free, a code lookup needs a licence for the domain */
+        get: operations["findingLineage"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1391,15 +1389,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/bundle": {
+    "/api/workflow": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One evidence bundle that verifies offline: signed manifest + public key, record digest, Merkle path, the day's .ots bytes; the sealed subject with a licence covering the domain. Verify with /crawlcheck-verify.mjs. Public */
-        get: operations["evidenceBundle"];
+        /** One finding on one site, end to end: detected, exact evidence, fix recommended, impact projected, implementation recorded, rescanned, corroborated by a second observer, signed receipt, regression watch, outcomes. Every step is a link to the record that proves it, with done:true only when that record exists. Public for the exemplar sites on /workflow; a licence for the domain or the owner otherwise */
+        get: operations["fixChain"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1408,7 +1406,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/reconstruction/ci": {
+    "/api/workflow/record": {
         parameters: {
             query?: never;
             header?: never;
@@ -1417,23 +1415,23 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** The weekly reconstruction run, callable only by this repository's reconstruction workflow (GitHub OIDC token, audience crawlcheck-reconstruction). The 20 oldest archived reports resolved through the projections and from the permanent store alone, plus two finding-to-artifact traversals each; green only when every part is identical */
-        post: operations["reconstructionCi"];
+        /** Record a fix: finds the newest record that carried the code and the first after it that did not, issues the signed remediation receipt with the declared fix inside it, and queues the second observer on the fixed URL (licence for the domain, or owner) */
+        post: operations["recordFixChain"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/reconstruction": {
+    "/api/observation": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The last reconstruction test: the oldest archived records' evidence paths (record, report node, decision nodes, manifest node, every verifier check) resolved through the 90-day projections and again from the permanent store alone (R2 archive + seal records), compared byte for byte after canonical serialisation. Public */
-        get: operations["reconstructionTest"];
+        /** One signed second-observer observation in full: the envelope (fetches with status, headers kept, sha256 of each body), the run key's Ed25519 signature, GitHub's OIDC token binding the key to the enrolled workflow, the checks run on receipt and the readings derived from the bytes. Public */
+        get: operations["getObservation"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1442,15 +1440,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/graph/{id}": {
+    "/api/outcomes": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Resolve a finding id (f1:), decision id (d1:), manifest/artifact sha256 or report id to its graph object: evidence, rule, provenance, supporting experiences, seal, onward links. Licence-gated */
-        get: operations["graphResolve"];
+        /** What the owner's connected sources counted either side of a receipt's anchor day: Search Console clicks and impressions, Business Profile actions, verified crawler fetches from the site's own log, beacon arrivals, enquiries through the form and anything posted to /api/outcome. One named source per series, per-day means compared, a missing day never zero, a thin window reported as thin. A coincidence in time, stated as one: it never claims the fix caused the movement (licence for the domain, or owner) */
+        get: operations["fixOutcomes"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1459,32 +1457,32 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/batch": {
+    "/api/evidence/export": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** Evidence line: one signed file carrying every measurement (with its evidence bundle), receipt, certificate day and seal for a domain and period; verifies offline with crawlcheck-verify.mjs (Evidence add-on, Agency, or owner) */
+        get: operations["evidenceExport"];
         put?: never;
-        /** Queue up to 100 domains (500 on Agency/Network) for the same audit /api/v1/scan runs; worked at minutes 17 past each hour UTC; optional signed https webhook on completion */
-        post: operations["batchSubmit"];
+        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/batch/{id}": {
+    "/api/evidence/ledger": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Batch state and per-domain results (grade, overall, refused, report links) */
-        get: operations["batchStatus"];
+        /** Evidence line: one row per measured day in the window with the day's reading, archived records and seal state, plus receipts and certificate history (Evidence add-on, Agency, or owner) */
+        get: operations["evidenceLedger"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1493,15 +1491,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/flow": {
+    "/api/evidence/receipts": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The observed data flow for a domain: where each crawler identity's path dies (edge, robots.txt as a file, robots.txt rules) and which stores it reached. Uses the latest record on file, or scans first when there is none (fresh=1). Answer-engine output is drawn, never measured */
-        get: operations["crawlerFlow"];
+        /** Evidence line: every remediation receipt across every domain on the key, newest first (Evidence add-on, Agency, or owner) */
+        get: operations["evidenceReceipts"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1510,15 +1508,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/flow/gate": {
+    "/api/benchmark": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** CI gate for a domain the key covers: 200 pass, 412 fail when a crawler path open at the last sealed scan closed, a file broke, or a declared path is violated at critical/high */
-        get: operations["flowGate"];
+        /** Intelligence line: corpus percentile and next band, cohort metrics, and the rarity of each visible finding across daily-measured sites (Intelligence add-on, Growth, or owner) */
+        get: operations["benchmark"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1527,51 +1525,49 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/flow/declared": {
+    "/api/portfolio/compare": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The owner's declared flow for a domain the key covers, with parity against the latest scan */
-        get: operations["flowDeclaredGet"];
-        /** Set the declared flow: agents {id: reach|blocked|any}, stores {id: present|absent|any}, or {seed: observed} to start from the latest scan */
-        put: operations["flowDeclaredPut"];
+        /** Intelligence line: two to 40 domains side by side from their latest records, with the spread and the finding codes shared across them (Intelligence add-on, Growth, or owner) */
+        get: operations["portfolioCompare"];
+        put?: never;
         post?: never;
-        /** Remove the declared flow */
-        delete: operations["flowDeclaredDelete"];
+        delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/tool/robots": {
+    "/api/verify/bulk": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Resolve every named answer engine, search index and training crawler against a domain's robots.txt the way a crawler does: most-specific group only, longest match, allow wins a tie */
-        get: operations["robotsResolve"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Intelligence line: run every server-side verifier on up to 25 ids in one call (Intelligence add-on, Growth, or owner) */
+        post: operations["verifyBulk"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/tool/llms": {
+    "/api/rollback": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Draft an llms.txt from the domain's own homepage and up to 25 declared pages, using their titles and descriptions. A draft, not a publication */
-        get: operations["llmsDraft"];
+        /** Compare the record before a fix with the record after it (licence or owner): findings cleared and new by fingerprint, rows now passing and now failing, every machine file whose bytes changed, a verdict (improved / unchanged / mixed / regressed), each regression pinned to the changed file it reads, and the rollback step for that file (restore the stored bytes, or remove a file that did not exist before) */
+        get: operations["verifyAndRollback"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1580,15 +1576,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/video": {
+    "/api/rollback/file": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** One YouTube video against the video anchor model: twelve checks, each naming what it reads. Cached six hours */
-        get: operations["videoCheck"];
+        /** The exact bytes a machine file served in a given record, from the artifact store, re-hashed before they are returned (licence or owner) */
+        get: operations["rollbackFile"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1597,15 +1593,51 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/video/channel": {
+    "/api/impact": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Every upload on a channel, read 50 at a time. The upload list is free; the per-check tally (checks=1) is for Watch licences and above */
-        get: operations["videoChannel"];
+        /** What fixing one thing changes on a record (licence or owner): per fix - robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair - the findings and rows it clears, the ones it clears only together with another fix, the root causes it closes, the certificate criteria it flips and the score and letter after */
+        get: operations["fixImpact"];
+        put?: never;
+        /** The same with a body: {id, fix:[ids]} */
+        post: operations["fixImpactPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/whatif": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Recompute the score and letter for a record with any set of failing rows passing and findings cleared (licence or owner): the combined effect, which individual points cannot give, plus the least set that reaches the next letter */
+        get: operations["whatIf"];
+        put?: never;
+        /** The same, with rows to fix: {id, fix:[{section_id,row}], clear:[codes]} */
+        post: operations["whatIfPost"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/ns": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The CrawlCheck vocabulary (https://crawlcheck.io/ns#) as RDFS in JSON-LD: every class and property the JSON-LD export uses, with labels and comments */
+        get: operations["getVocabulary"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1614,15 +1646,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/video/site": {
+    "/schemas/openlineage-facets.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The site half: homepage plus up to 60 sitemap pages read for YouTube embeds, facades and page-builder widgets, VideoObject nodes and their required properties, and - with a handle - how many of the channel's videos the site carries */
-        get: operations["videoSite"];
+        /** JSON Schema for CrawlCheck's OpenLineage facets (CrawlCheckRunFacet, CrawlCheckFetchFacet, CrawlCheckReportFacet), each extending the OpenLineage 2-0-2 BaseFacet */
+        get: operations["getOpenLineageFacetSchema"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1631,15 +1663,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/fix/robots": {
+    "/schemas/machine-experience-record.json": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The served robots.txt, corrected: * group rules copied into every named group that lacked them, a Sitemap line added when the file never named the sitemap it serves, a minimal replacement when the served file was HTML. Every change is listed at the top of the file */
-        get: operations["fixRobots"];
+        /** JSON Schema (2020-12) for the sealed scan manifest: every fetch a scan made, as which identity, with which headers, what came back and whether the bytes were kept; validated against 221 sealed manifests */
+        get: operations["getMachineExperienceRecordSchema"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1648,15 +1680,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/fix/entitymap": {
+    "/api/v1/schema": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** A starter entitymap.json built from the latest scan record: name, phone, coordinates and every declared service area as entities with SERVES relations. Fields the page never stated are marked TODO, never guessed. Needs a prior scan */
-        get: operations["fixEntitymap"];
+        /** JSON Schema for every v1 response */
+        get: operations["getSchemaV1"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1665,7 +1697,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/entity/observe": {
+    "/api/keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List the scoped API keys on a licence (names, scopes, last use; never the keys) */
+        get: operations["listApiKeys"];
+        put?: never;
+        /** Create a scoped API key (shown once; stored as a SHA-256) */
+        post: operations["createApiKey"];
+        /** Revoke an API key by id */
+        delete: operations["revokeApiKey"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/share": {
         parameters: {
             query?: never;
             header?: never;
@@ -1674,23 +1725,93 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        /** File a profile page as the owner's browser saw it, for the entity corroboration section. Consulted only where the scanner's own fetch was unverifiable; never overrides a live result; the row is labelled owner-browser. Licence-gated and bound to the licence's domains; the page's canonical must name the url's host. Kept 30 days */
-        post: operations["entityObserve"];
+        /** Create a scoped share link for one report (licence required; up to 90 days; revocable) */
+        post: operations["createShareLink"];
+        /** Revoke a share link created with the same licence */
+        delete: operations["revokeShareLink"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/scan/licensed": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Scan a domain on the licensed lane (valid licence key required; 60 scans per ten minutes per key; 404 without a key) */
+        post: operations["scanDomainLicensed"];
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/public/counts": {
+    "/api/tool/wba": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The figures this site quotes about itself: sites_measured, domains_in_corpus (two different quantities), crawler_visits (a rolling window), queue, identities_sent, sections, sections_scored (derived from the weights map), findings_published, guides_published and an at timestamp. CORS open, cached 60 seconds */
-        get: operations["publicCounts"];
+        /** Audit a Web Bot Auth key directory: no redirects, content type, RFC 7638 thumbprints, and which keys the directory's own signatures prove */
+        get: operations["checkBotKeyDirectory"];
+        put?: never;
+        /** Verify a pasted Web Bot Auth request: the agent's directory, then the request's signature against a key the directory proves it holds */
+        post: operations["verifySignedBotRequest"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Adjudicate crawler identity claims in raw access-log lines against each operator's published IP ranges */
+        post: operations["verifyCrawlerLog"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/depth": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Crawl the URLs the site declares and map the links between them: orphans, undeclared pages, per-page status, canonical, text ratio, JSON-LD, noindex. Up to 300 pages in one pass; pages up to 500 (Watch, Studio) or 5000 (Agency, Network) runs as a background job in chunks of 300, advanced by every poll of /api/depth/{id} and every hour. Sites declaring more than the cap are sampled across path families. Licence-gated; 404 without a key. Returns 202 with a job id */
+        post: operations["depthCrawl"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/depth/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The depth-crawl record for a job id: orphans, undeclared, pages[], medians and stated limits */
+        get: operations["depthResult"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1699,15 +1820,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/registry": {
+    "/api/usage": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** The registry: which measured domains serve an llms.txt, an agents.md, a media kit, a reciprocity-tested entity graph, an AI access policy that names crawlers, or agent-callable surfaces */
-        get: operations["registry"];
+        /** This key's monthly scan quota and usage; every keyed response also carries x-crawlcheck-quota-* headers */
+        get: operations["usage"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1716,15 +1837,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/telemetry": {
+    "/api/verify": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Verified-crawler telemetry observed at this origin */
-        get: operations["telemetry"];
+        /** Every verifier in one call: record digest, seal + Bitcoin anchor, manifest signature (WBA Ed25519), stored manifest bytes, kept artifacts, decision pointers, provenance envelope, self-audit. Public */
+        get: operations["verifyRecord"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1733,15 +1854,15 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/corpus/state": {
+    "/api/bundle": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Coverage of the public dataset by platform, rendering, size, language and kind */
-        get: operations["corpusState"];
+        /** One evidence bundle that verifies offline: signed manifest + public key, record digest, Merkle path, the day's .ots bytes; the sealed subject with a licence covering the domain. Verify with /crawlcheck-verify.mjs. Public */
+        get: operations["evidenceBundle"];
         put?: never;
         post?: never;
         delete?: never;
@@ -1750,724 +1871,1780 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-}
-export type webhooks = Record<string, never>;
-export interface components {
-    schemas: {
-        ScanRecord: {
-            /** @description Report id; the report renders at /r/{id} and the record at /r/{id}.json */
-            id?: string;
-            domain?: string;
-            /**
-             * @description null when the origin refused the scanner or the scan could not be graded
-             * @enum {string|null}
-             */
-            grade?: "A" | "B" | "C" | "D" | "F" | null;
-            /** @description AI visibility: reach, then read, then quote */
-            overall?: number | null;
-            /** @description The homepage and a path that cannot exist answered identically: a wall, not a site. Nothing is scored */
-            refused?: boolean;
-            section_scores?: {
-                id?: string;
-                title?: string;
-                score?: number | null;
-            }[];
-            findings?: {
-                code?: string;
-                severity?: number;
-                path?: string;
-                title?: string;
-                detail?: string;
-                evidence?: unknown;
-            }[];
-            /** @description Invariants checked on this record itself; a finding here is a defect in the scanner, never in the site */
-            self_audit?: Record<string, never>;
+    "/api/reconstruction/ci": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        VerifyResult: {
-            tally?: {
-                verified?: number;
-                spoofed?: number;
-                unverifiable?: number;
-                no_bot?: number;
-            };
-            forged_rate_pct?: number | null;
-            denominator_note?: string;
-            rows?: Record<string, never>[];
+        get?: never;
+        put?: never;
+        /** The weekly reconstruction run, callable only by this repository's reconstruction workflow (GitHub OIDC token, audience crawlcheck-reconstruction). The 20 oldest archived reports resolved through the projections and from the permanent store alone, plus two finding-to-artifact traversals each; green only when every part is identical */
+        post: operations["reconstructionCi"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/reconstruction": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The last reconstruction test: the oldest archived records' evidence paths (record, report node, decision nodes, manifest node, every verifier check) resolved through the 90-day projections and again from the permanent store alone (R2 archive + seal records), compared byte for byte after canonical serialisation. Public */
+        get: operations["reconstructionTest"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/graph/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Resolve a finding id (f1:), decision id (d1:), manifest/artifact sha256 or report id to its graph object: evidence, rule, provenance, supporting experiences, seal, onward links. Licence-gated */
+        get: operations["graphResolve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/batch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Queue up to 100 domains (500 on Agency/Network) for the same audit /api/v1/scan runs; worked at minutes 17 past each hour UTC; optional signed https webhook on completion */
+        post: operations["batchSubmit"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/batch/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Batch state and per-domain results (grade, overall, refused, report links) */
+        get: operations["batchStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/flow": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The observed data flow for a domain: where each crawler identity's path dies (edge, robots.txt as a file, robots.txt rules) and which stores it reached. Uses the latest record on file, or scans first when there is none (fresh=1). Answer-engine output is drawn, never measured */
+        get: operations["crawlerFlow"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/flow/gate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** CI gate for a domain the key covers: 200 pass, 412 fail when a crawler path open at the last sealed scan closed, a file broke, or a declared path is violated at critical/high */
+        get: operations["flowGate"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/flow/declared": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The owner's declared flow for a domain the key covers, with parity against the latest scan */
+        get: operations["flowDeclaredGet"];
+        /** Set the declared flow: agents {id: reach|blocked|any}, stores {id: present|absent|any}, or {seed: observed} to start from the latest scan */
+        put: operations["flowDeclaredPut"];
+        post?: never;
+        /** Remove the declared flow */
+        delete: operations["flowDeclaredDelete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool/robots": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Resolve every named answer engine, search index and training crawler against a domain's robots.txt the way a crawler does: most-specific group only, longest match, allow wins a tie */
+        get: operations["robotsResolve"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/tool/llms": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Draft an llms.txt from the domain's own homepage and up to 25 declared pages, using their titles and descriptions. A draft, not a publication */
+        get: operations["llmsDraft"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/video": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** One YouTube video against the video anchor model: twelve checks, each naming what it reads. Cached six hours */
+        get: operations["videoCheck"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/video/channel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Every upload on a channel, read 50 at a time. The upload list is free; the per-check tally (checks=1) is for Watch licences and above */
+        get: operations["videoChannel"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/video/site": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The site half: homepage plus up to 60 sitemap pages read for YouTube embeds, facades and page-builder widgets, VideoObject nodes and their required properties, and - with a handle - how many of the channel's videos the site carries */
+        get: operations["videoSite"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/fix/robots": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The served robots.txt, corrected: * group rules copied into every named group that lacked them, a Sitemap line added when the file never named the sitemap it serves, a minimal replacement when the served file was HTML. Every change is listed at the top of the file */
+        get: operations["fixRobots"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/fix/entitymap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** A starter entitymap.json built from the latest scan record: name, phone, coordinates and every declared service area as entities with SERVES relations. Fields the page never stated are marked TODO, never guessed. Needs a prior scan */
+        get: operations["fixEntitymap"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/entity/observe": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** File a profile page as the owner's browser saw it, for the entity corroboration section. Consulted only where the scanner's own fetch was unverifiable; never overrides a live result; the row is labelled owner-browser. Licence-gated and bound to the licence's domains; the page's canonical must name the url's host. Kept 30 days */
+        post: operations["entityObserve"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/public/counts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The figures this site quotes about itself: sites_measured, domains_in_corpus (two different quantities), crawler_visits (a rolling window), queue, identities_sent, sections, sections_scored (derived from the weights map), findings_published, guides_published and an at timestamp. CORS open, cached 60 seconds */
+        get: operations["publicCounts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** The registry: which measured domains serve an llms.txt, an agents.md, a media kit, a reciprocity-tested entity graph, an AI access policy that names crawlers, or agent-callable surfaces */
+        get: operations["registry"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/telemetry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Verified-crawler telemetry observed at this origin */
+        get: operations["telemetry"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/corpus/state": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Coverage of the public dataset by platform, rendering, size, language and kind */
+        get: operations["corpusState"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        ScanRecord: {
+            /** @description Report id; the report renders at /r/{id} and the record at /r/{id}.json */
+            id?: string;
+            domain?: string;
+            /**
+             * @description null when the origin refused the scanner or the scan could not be graded
+             * @enum {string|null}
+             */
+            grade?: "A" | "B" | "C" | "D" | "F" | null;
+            /** @description AI visibility: reach, then read, then quote */
+            overall?: number | null;
+            /** @description The homepage and a path that cannot exist answered identically: a wall, not a site. Nothing is scored */
+            refused?: boolean;
+            section_scores?: {
+                id?: string;
+                title?: string;
+                score?: number | null;
+            }[];
+            findings?: {
+                code?: string;
+                severity?: number;
+                path?: string;
+                title?: string;
+                detail?: string;
+                evidence?: unknown;
+            }[];
+            /** @description Invariants checked on this record itself; a finding here is a defect in the scanner, never in the site */
+            self_audit?: Record<string, never>;
+        };
+        VerifyResult: {
+            tally?: {
+                verified?: number;
+                spoofed?: number;
+                unverifiable?: number;
+                no_bot?: number;
+            };
+            forged_rate_pct?: number | null;
+            denominator_note?: string;
+            rows?: Record<string, never>[];
+        };
+        PublicReportV1: {
+            schema: string;
+            /** @constant */
+            version: "1.0";
+            id: string | null;
+            domain: string | null;
+            path?: string | null;
+            scanned_host?: string | null;
+            scanned_at: string | null;
+            score_version?: number | null;
+            grade: string | null;
+            overall: number | null;
+            grade_detail?: {
+                capped?: boolean;
+                cap?: string | null;
+                cap_reason?: string | null;
+            };
+            sections: {
+                id?: string | null;
+                title?: string | null;
+                /** @description null means not measured, never zero */
+                score?: number | null;
+            }[];
+            findings: {
+                code?: string | null;
+                path?: string | null;
+                severity?: number | null;
+                title?: string | null;
+                detail?: string | null;
+                meaning?: string | null;
+                evidence?: string | null;
+                fid?: string | null;
+                decision_id?: string | null;
+                graph?: string | null;
+                /** @description true on an unlicensed read for every finding but the top one: title, severity and path are present, the rest is withheld */
+                locked?: boolean;
+                /** @description code|path; stable across scans of the same domain; null on a locked finding */
+                fingerprint?: string | null;
+                /**
+                 * @description lifecycle on this scan; null when the domain has no stored history
+                 * @enum {string|null}
+                 */
+                state?: "new" | "persisted" | "worsened" | "improved" | "regressed" | "resolved" | "rule-changed" | null;
+                first_seen?: string | null;
+                scans_seen?: number | null;
+                recurrences?: number | null;
+                /** @description bitemporal: when the condition held on the site (valid_from / valid_to as after-by intervals between observations; null ends are unknown or still open) and when CrawlCheck recorded it (recorded_at, superseded_at) */
+                valid_time?: Record<string, never> | null;
+            }[];
+            /** @description Set on an unlicensed read: every finding is listed by title, severity and path; detail, evidence and code beyond the top one are withheld */
+            findings_withheld?: string | null;
+            findings_summary?: {
+                total?: number | null;
+                serious?: number | null;
+                by_severity?: Record<string, never> | null;
+            } | null;
+            /** @description Observer build, vantage, rule version, observed and stored times, sealed manifest */
+            provenance?: Record<string, never> | null;
+            /** @description Findings that share one cause or one fix, formed only from evidence in this record (e.g. robots.txt, the sitemap and llms.txt all answering with the site's HTML page). With a licence: cause, fix, generators, evidence and members. An unlicensed v1 read is built from the locked record, so the list is empty there; /api/v1/machine-record shows a group the top finding belongs to, by kind and size */
+            root_causes?: unknown[] | null;
+            /** @description One line per fix that would change this record (robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair), best first: findings and rows it clears, the other fixes some of its rows also need, the score and letter after (the formula rerun), root causes it closes and certificate criteria it flips. Null on an unlicensed read; /api/impact has the names */
+            fix_impact?: unknown[] | null;
+            /** @description combined {all_rows_fixed, all_findings_cleared, both} and next_letter {target, reachable, ...} are recomputed, never summed. What each decision moved. rows[]: every failing scored row with points = the score recomputed with that row passing minus the score now (same formula, Reach + 15 ceiling included), points_section_average, and why a row moves nothing; withheld (rows_withheld) where the fix list is. Findings move no points: each finding's score_effect states the letter cap it sets, whether it binds, and the letter without it. */
+            score_ledger?: Record<string, never> | null;
+            /** @description Counts and ratios behind the reading: sections_scored, identities_answered, fetches_kept, stage_failures, non_observations, vantages. No composite number, because the parts do not combine into one honestly */
+            confidence?: Record<string, never> | null;
+            /** @description Each stated fact with two times: when CrawlCheck observed it (observed_from, observed_last, removed_at) and when the site says it became true (valid time, null when the site does not say) */
+            bitemporal?: Record<string, never> | null;
+            /** @description What was not measured on this scan and why; an unmeasured subject is never scored as a pass or a fail */
+            non_observations?: {
+                subject?: string | null;
+                state?: string | null;
+                reason?: string | null;
+                attempted?: boolean | null;
+            }[] | null;
+            /** @description Each value carries locators[] (one per source): bytes [start, end) in the page this scan received, line, col, scope (meta[og:title], script[ld+json]#0, title, page text) and match (value | property | normalised | partial), or {found:false, why}; check them with /api/locate. Each business fact (name, phone, address, email, founder) with every value the site stated and where it stated it, and whether the statements agree */
+            fact_lineage?: Record<string, never> | null;
+            checks?: {
+                path?: string | null;
+                status?: number | null;
+                bytes?: number | null;
+            }[];
+            agentview?: {
+                label?: string | null;
+                status?: number | null;
+                words?: number | null;
+            }[];
+            nap?: Record<string, never> | null;
+            headroom?: {
+                gain?: number | null;
+                failing?: number | null;
+            } | null;
+            history?: {
+                at?: string | null;
+                overall?: number | null;
+                score_version?: number | null;
+            }[];
+            proof: {
+                digest?: string | null;
+                algorithm?: string | null;
+                anchored?: string | null;
+                verify?: string | null;
+            };
+            links?: Record<string, never>;
+        };
+        /** @description One observation in one shape (GET /api/v1/machine-record, MCP machine_record): subject, observation, findings (top in full without a licence; the rest locked), capabilities with safety class and verification state, evidence roots and verifier links */
+        MachineRecordV1: {
+            /** @constant */
+            kind: "crawlcheck-machine-record";
+            version: string;
+            subject: Record<string, never>;
+            observation: Record<string, never>;
+            /** @description each open finding carries trust {freshness, confidence {level, means, basis[]}, contradictions[]} */
+            findings: unknown[];
+            /** @description observed_at, age_hours, latest_report_id, is_latest, newer_scan_exists, last_second_reading_at */
+            freshness?: Record<string, never>;
+            /** @description With a licence: one line per fix that would change this record, best first (findings and rows it clears, other fixes some rows also need, score and letter after, root causes closed, certificate criteria flipped). Without: {fixes_available, best_single_fix {letter_after, score_after, findings_cleared, rows_cleared}} and no names */
+            fix_impact?: unknown[] | Record<string, never> | null;
+            /** @description score, letter, cap and the points each failing row moves (rows open with a licence); each open finding carries score_effect {points: 0, cap, binding, letter_without_it, says} */
+            score_ledger?: Record<string, never> | null;
+            /** @description counts and ratios plus vantages; no composite number; levels: contested | cross_vantage_confirmed | reproduced | single_reading */
+            confidence?: Record<string, never>;
+            /** @description site (the site contradicts itself) and between_networks_open (observers disagree), for findings this caller can open */
+            contradictions?: Record<string, never>;
+            findings_summary?: Record<string, never> | null;
+            findings_withheld?: string | null;
+            capabilities: Record<string, never>;
+            evidence: Record<string, never>;
+            access: Record<string, never>;
+        };
+        ErrorV1: {
+            error: {
+                code: string;
+                status?: number;
+                message: string;
+            };
+        };
+        /** @description GET /api/bundle: one file that checks offline with /crawlcheck-verify.mjs. A field that cannot be filled (an anonymous download, an unsealed day, a record from before manifests) is null with a *_withheld / *_missing / why reason, never omitted */
+        EvidenceBundleV1: {
+            /** @constant */
+            kind: "crawlcheck-evidence-bundle";
+            version: number;
+            generated_at?: string;
+            report: {
+                id: string | null;
+                domain: string | null;
+                path?: string | null;
+                scanned_at: string | null;
+                score_version?: number | null;
+                archived?: boolean;
+            };
+            verifier: {
+                url: string;
+                sha256: string;
+                run?: string;
+                page?: string;
+            };
+            proves?: string[];
+            does_not_prove?: string[];
+            manifest: {
+                sha256: string;
+                body: string | null;
+                body_missing?: string | null;
+                signature?: {
+                    alg?: string | null;
+                    kid?: string | null;
+                    message?: string | null;
+                    sig?: string | null;
+                    signed_at?: string | null;
+                } | null;
+                key?: {
+                    jwk?: {
+                        /** @constant */
+                        kty: "OKP";
+                        /** @constant */
+                        crv: "Ed25519";
+                        x: string;
+                    };
+                    kid?: string;
+                    published_in?: string;
+                } | null;
+                key_missing?: string | null;
+            } | null;
+            record: {
+                digest: string | null;
+                subject: string | null;
+                subject_withheld?: string | null;
+                recipe?: string | null;
+                decision_leaves?: Record<string, never>[] | null;
+                lineage_leaves?: Record<string, never>[] | null;
+                leaves_withheld?: string | null;
+            } | null;
+            seal: {
+                /** @enum {unknown} */
+                state: "sealed" | "pending" | "unsealed" | "unverifiable" | "unknown";
+                day?: string | null;
+                root?: string | null;
+                path?: {
+                    /** @enum {unknown} */
+                    side: "left" | "right";
+                    hash: string;
+                }[];
+                leaves_that_day?: number | null;
+                sealed_at?: string | null;
+                calendars?: string[];
+                ots_base64?: string | null;
+                bitcoin_block?: number | null;
+                recipe?: string | null;
+                why?: string | null;
+            } | null;
+            /** @description sec8: every bundle is scanned before it is served; a section that matched is null and carries <section>_withheld */
+            publish_guard?: {
+                checked?: string[];
+                withheld?: {
+                    section?: string;
+                    matched?: string[];
+                }[];
+            };
+            /** @description Who can read which representation of a scan: /docs/api#disclosure */
+            disclosure?: string;
+        } & {
+            [key: string]: string;
+        };
+        /** @description A signed remediation receipt (GET /api/receipt?id=). receipt_id = rc1: + sha256 of the canonical JSON of every field except receipt_id and signature; signature = Ed25519 over 'crawlcheck-receipt-v1\n' + that sha256 */
+        RemediationReceiptV1: {
+            receipt_id: string;
+            /** @constant */
+            kind: "crawlcheck-remediation-receipt";
+            /** @constant */
+            v: 1;
+            issued_at: string;
+            issuer: {
+                observer?: string | null;
+                version_id?: string | null;
+                version_tag?: string | null;
+                key: {
+                    kid: string;
+                    jwk: Record<string, never>;
+                    published_in?: string | null;
+                };
+            };
+            subject: {
+                domain: string;
+            };
+            before: components["schemas"]["ReceiptSideV1"];
+            after: components["schemas"]["ReceiptSideV1"];
+            declared_fix: {
+                kind?: string;
+                declared_by?: string | null;
+                declared_at?: string | null;
+                plugin_version?: string | null;
+                fixes?: string[] | null;
+                note?: string | null;
+            };
+            deployed: {
+                at?: string | null;
+                basis?: string | null;
+            };
+            verification: {
+                /** @enum {unknown} */
+                verdict: "improved" | "unchanged" | "mixed" | "regressed";
+                summary?: string | null;
+                comparable?: boolean;
+                findings?: Record<string, never>;
+                rows?: Record<string, never>;
+                files?: {
+                    path?: string;
+                    state?: string;
+                    before_sha256?: string | null;
+                    after_sha256?: string | null;
+                    before_status?: number | null;
+                    after_status?: number | null;
+                }[];
+                rollback_needed?: boolean;
+                rollback_steps?: Record<string, never>[];
+                method?: string | null;
+            };
+            links?: Record<string, never>;
+            signature: {
+                v?: number | null;
+                /** @constant */
+                alg: "Ed25519";
+                kid: string;
+                over?: string | null;
+                receipt_sha256: string;
+                message: string;
+                sig: string;
+                signed_at?: string | null;
+                canonical?: string | null;
+            };
+        };
+        /** @description tr1: one scan's trace (GET /api/trace?id=, owner; sampled by the trace CI job). W3C Trace Context ids. Every span's parent is the scan span (root_span_id) or a span of this trace; the scan span's own parent is the caller's span when the scan joined a caller's trace (parent). */
+        TraceV1: {
+            id: string | null;
+            domain?: string | null;
+            scanned_at?: string | null;
+            traced: boolean;
+            why?: string | null;
+            trace_id?: string;
+            root_span_id?: string;
+            traceparent?: string;
+            parent?: {
+                span_id?: string;
+                source?: string | null;
+                previous_trace_id?: string | null;
+            } | null;
+            scan_id?: string | null;
+            started_at?: string | null;
+            total_ms?: number | null;
+            dropped?: number;
+            recorded_through?: unknown;
+            spans?: components["schemas"]["SpanV1"][];
+            errors?: {
+                error_id?: string | null;
+                stage?: string | null;
+                span_id: string | null;
+                error?: string | null;
+            }[];
+            findings?: {
+                code?: string | null;
+                decision_id?: string | null;
+                span_id?: string | null;
+                parent_span_id?: string | null;
+                parent_stage?: string | null;
+                reads?: number | null;
+            }[];
+            coverage?: Record<string, never>;
+            slowest?: unknown[];
+            decisions_with_spans?: number | null;
+            note?: string | null;
+        } & unknown;
+        /** @description tr1: one span: a stage of the scan, or (kind rule) one decision, started when its rule decided. */
+        SpanV1: {
+            span_id: string;
+            parent_span_id: string;
+            stage: string;
+            /** @enum {unknown} */
+            kind?: "rule";
+            start_ms: number;
+            dur_ms?: number | null;
+            /** @enum {unknown} */
+            status: "ok" | "error" | "inputs_disputed";
+            error_id?: string | null;
+            code?: string | null;
+            path?: string | null;
+            decision_id?: string | null;
+            reads?: {
+                experience_id?: string | null;
+                fetched_in?: string | null;
+                stage?: string | null;
+                fetched_after_rule?: boolean;
+            }[];
+            parent_basis?: string | null;
+        };
+        /** @description dsp1: a signed resolution of a dispute against one finding (GET /api/disputes/resolution?id=). Verifies offline with crawlcheck-verify.mjs: hash, key id, Ed25519 signature, and the verdict re-derived from the recorded readings by the published decision table. */
+        DisputeResolutionV1: {
+            resolution_id: string;
+            /** @constant */
+            kind: "crawlcheck-dispute-resolution";
+            /** @constant */
+            v: 1;
+            schema?: string | null;
+            dispute_id: string;
+            issued_at: string;
+            issuer: {
+                observer?: string | null;
+                version_id?: string | null;
+                version_tag?: string | null;
+                key?: {
+                    kid?: string;
+                    jwk?: Record<string, never>;
+                    published_in?: string;
+                };
+            };
+            subject: {
+                domain: string;
+                record: Record<string, never>;
+                finding: {
+                    code?: string;
+                    path?: string | null;
+                    fid?: string | null;
+                    decision_id?: string | null;
+                    title?: string | null;
+                    severity?: number | null;
+                    rule_revision?: number | null;
+                };
+            };
+            dispute: {
+                filed_at?: string;
+                /** @enum {unknown} */
+                ground?: "misread" | "fixed" | "network" | "rule";
+                ground_text?: string | null;
+                statement?: string;
+                ownership?: {
+                    method?: string;
+                    at?: string;
+                    url?: string | null;
+                    sha256?: string | null;
+                } | null;
+            };
+            remeasurement: {
+                replay: {
+                    reproduces?: boolean | null;
+                    rule?: string | null;
+                    read?: unknown;
+                    why?: string | null;
+                    rule_revision?: number | null;
+                    over?: string | null;
+                };
+                observers: {
+                    /** @enum {unknown} */
+                    role: "primary" | "independent";
+                    observer_id: string;
+                    network_class?: string | null;
+                    network?: string | null;
+                    at?: string | null;
+                    finding_present: boolean | null;
+                    inputs_agree?: boolean | null;
+                    method?: string | null;
+                    reading?: string | null;
+                    side?: Record<string, never> | null;
+                    observation?: Record<string, never> | null;
+                }[];
+                deadline?: string | null;
+                independent_wait_hours?: number | null;
+            };
+            decision: {
+                /** @enum {unknown} */
+                verdict: "upheld" | "corrected" | "fixed_since" | "vantage_dependent" | "no_longer_observed" | "inconclusive";
+                verdict_text?: string | null;
+                /** @enum {unknown} */
+                effect: "stands" | "withdrawn" | "stands_for_record" | "stands_with_scope" | "stands_unresolved";
+                effect_text?: string | null;
+                rule?: string | null;
+                table?: string | null;
+                derived_by?: string | null;
+            };
+            links?: Record<string, never>;
+            signature: {
+                /** @constant */
+                v?: 1;
+                /** @constant */
+                alg: "Ed25519";
+                kid: string;
+                /** @constant */
+                over?: "resolution_sha256";
+                resolution_sha256: string;
+                message: string;
+                sig: string;
+                signed_at?: string;
+                canonical?: string;
+            };
+        };
+        /** @description Every finding the scanner can raise (GET /api/rules): what it means, its level, its fix and its share of counted scans. */
+        RulebookV1: {
+            ok?: boolean;
+            /** @constant */
+            kind: "crawlcheck-rulebook";
+            /** @constant */
+            v: 1;
+            generated_at: string;
+            score_version?: number | null;
+            schema?: string | null;
+            counts: {
+                rules: number;
+                by_kind?: {
+                    [key: string]: number;
+                };
+                by_family?: {
+                    [key: string]: number;
+                };
+                revised?: number;
+                scored?: number;
+            };
+            scans_counted?: number | null;
+            severity_scale: {
+                level?: string;
+            }[];
+            method?: {
+                revisions?: string | null;
+                share?: string | null;
+                grade?: string | null;
+            };
+            /** @description every rule; with ?code= only that rule (counts still describe the whole rulebook) */
+            rules: components["schemas"]["RuleV1"][];
+            filter?: {
+                code?: string | null;
+            } | null;
+        };
+        /** @description One rule: the code, what it means, its level, its current revision, its fix and its share of counted scans. */
+        RuleV1: {
+            code: string;
+            /**
+             * @description self_audit: a defect in CrawlCheck's own record, never in the site
+             * @enum {unknown}
+             */
+            kind: "scan" | "answer_correlation" | "capability_mismatch" | "self_audit";
+            family: {
+                id: string;
+                label: string;
+            };
+            title: string | null;
+            meaning?: string | null;
+            severity: {
+                level?: string | null;
+            };
+            /** @description raised on a graded scan record; refusals, answer runs, capability mismatches and self-audit findings are not */
+            scored?: boolean;
+            measured_on?: string | null;
+            revision: {
+                current: number;
+                /** @description when the current revision took effect; null while the rule is at revision 1 */
+                revised_at?: string | null;
+            };
+            fix?: {
+                advice?: string | null;
+                effort?: string | null;
+                endpoint?: string | null;
+            };
+            share_of_scans: {
+                pct: number | null;
+                scans?: number | null;
+                of_scans?: number | null;
+                basis: string;
+            };
+            links?: {
+                self?: string | null;
+                api?: string | null;
+                glossary?: string[];
+                workflow?: string | null;
+                lineage?: string | null;
+                explain_template?: string | null;
+            };
+        };
+        /** @description What the owner's connected outcome sources counted either side of a receipt's anchor day (GET /api/outcomes). One series per named source; per-day values compared; a series with no source is connected:false with how_to_connect; a window under 7 measured days is usable:false with why. Never a claim of cause. */
+        FixOutcomesV1: {
+            ok?: boolean;
+            /** @constant */
+            kind: "crawlcheck-fix-outcomes";
+            /** @constant */
+            v: 1;
+            generated_at?: string;
+            cached?: boolean;
+            receipt: {
+                id: string;
+                domain: string;
+                verdict?: string | null;
+                findings_cleared?: string[];
+                url?: string;
+                anchor: {
+                    at?: string;
+                    /** Format: date */
+                    day: string;
+                    basis: string;
+                };
+            };
+            window: {
+                days: number;
+                before: {
+                    from?: string | null;
+                    to?: string | null;
+                };
+                after: {
+                    from?: string | null;
+                    to?: string | null;
+                    days_elapsed?: number;
+                    complete?: boolean;
+                };
+            };
+            connected: number;
+            usable: number;
+            series: {
+                key: string;
+                label: string;
+                source: string;
+                /** @enum {unknown} */
+                mode: "daily" | "events";
+                connected: boolean;
+                note?: string;
+                how_to_connect?: string | null;
+                before?: components["schemas"]["OutcomeSideV1"] | null;
+                after?: components["schemas"]["OutcomeSideV1"] | null;
+                delta_per_day?: number | null;
+                pct?: number | null;
+                usable: boolean;
+                why: string;
+            }[];
+            not_measured?: {
+                key?: string;
+                why?: string;
+            }[];
+            summary?: string;
+            reading?: string;
+            not_proof: string;
+            how_to_cite?: string;
+        };
+        OutcomeSideV1: {
+            from?: string | null;
+            to?: string | null;
+            days: number;
+            measured: number;
+            sum: number;
+            per_day: number | null;
+        };
+        ReceiptSideV1: {
+            report_id: string | null;
+            scanned_at: string | null;
+            grade?: string | null;
+            score?: number | null;
+            score_version?: number | null;
+            refused?: boolean;
+            findings?: number | null;
+            manifest_sha256?: string | null;
+            decision_root?: string | null;
+            trace_id?: string | null;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    scan: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /**
+                     * @description A bare domain or a full URL
+                     * @example example.com
+                     */
+                    domain: string;
+                    /**
+                     * @description unlisted: the report is reachable only by its link; the scan is sealed and archived but enters no public registry, dataset, history or resolve answer. private: needs a licence for the domain (or the owner); the report opens only for that licence holder or the owner and is not archived or listed anywhere (default public)
+                     * @enum {unknown}
+                     */
+                    visibility?: "public" | "unlisted" | "private";
+                };
+            };
+        };
+        responses: {
+            /** @description The scan record */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ScanRecord"];
+                };
+            };
+            /** @description Not a public domain (reserved names such as .example and .invalid included), or no JSON body */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Rate limited: 5 requests per 10 seconds per address; a scan of the same domain still running (code scan_in_progress); or the daily total of free scans reached (code daily_budget). Retry-After says when. A rescan of a domain scanned in the last 2 minutes returns that report (field cached) instead of fetching the site again; a domain where nothing answered returns 200 with unreachable: true, id: null and nothing stored */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Free scans paused (code scans_paused); keyed scans are unaffected */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    scanDomainV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    domain: string;
+                };
+            };
+        };
+        responses: {
+            /** @description PublicReportV1 */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PublicReportV1"];
+                };
+            };
+            /** @description ErrorV1: bad_request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description ErrorV1: rate_limited */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    reportAgentOutcomeV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description accepted */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description invalid report */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description 500 reports a day per address */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
-        PublicReportV1: {
-            schema: string;
-            /** @constant */
-            version: "1.0";
-            id: string | null;
-            domain: string | null;
-            path?: string | null;
-            scanned_host?: string | null;
-            scanned_at: string | null;
-            score_version?: number | null;
-            grade: string | null;
-            overall: number | null;
-            grade_detail?: {
-                capped?: boolean;
-                cap?: string | null;
-                cap_reason?: string | null;
+    };
+    agentOutcomesV1: {
+        parameters: {
+            query: {
+                domain: string;
             };
-            sections: {
-                id?: string | null;
-                title?: string | null;
-                /** @description null means not measured, never zero */
-                score?: number | null;
-            }[];
-            findings: {
-                code?: string | null;
-                path?: string | null;
-                severity?: number | null;
-                title?: string | null;
-                detail?: string | null;
-                meaning?: string | null;
-                evidence?: string | null;
-                fid?: string | null;
-                decision_id?: string | null;
-                graph?: string | null;
-                /** @description true on an unlicensed read for every finding but the top one: title, severity and path are present, the rest is withheld */
-                locked?: boolean;
-                /** @description code|path; stable across scans of the same domain; null on a locked finding */
-                fingerprint?: string | null;
-                /**
-                 * @description lifecycle on this scan; null when the domain has no stored history
-                 * @enum {string|null}
-                 */
-                state?: "new" | "persisted" | "worsened" | "improved" | "regressed" | "resolved" | "rule-changed" | null;
-                first_seen?: string | null;
-                scans_seen?: number | null;
-                recurrences?: number | null;
-                /** @description bitemporal: when the condition held on the site (valid_from / valid_to as after-by intervals between observations; null ends are unknown or still open) and when CrawlCheck recorded it (recorded_at, superseded_at) */
-                valid_time?: Record<string, never> | null;
-            }[];
-            /** @description Set on an unlicensed read: every finding is listed by title, severity and path; detail, evidence and code beyond the top one are withheld */
-            findings_withheld?: string | null;
-            findings_summary?: {
-                total?: number | null;
-                serious?: number | null;
-                by_severity?: Record<string, never> | null;
-            } | null;
-            /** @description Observer build, vantage, rule version, observed and stored times, sealed manifest */
-            provenance?: Record<string, never> | null;
-            /** @description Findings that share one cause or one fix, formed only from evidence in this record (e.g. robots.txt, the sitemap and llms.txt all answering with the site's HTML page). With a licence: cause, fix, generators, evidence and members. An unlicensed v1 read is built from the locked record, so the list is empty there; /api/v1/machine-record shows a group the top finding belongs to, by kind and size */
-            root_causes?: unknown[] | null;
-            /** @description One line per fix that would change this record (robots, sitemap, llms, entitymap, edge-bots, cache, page-code, chain, hsts, host-pair), best first: findings and rows it clears, the other fixes some of its rows also need, the score and letter after (the formula rerun), root causes it closes and certificate criteria it flips. Null on an unlicensed read; /api/impact has the names */
-            fix_impact?: unknown[] | null;
-            /** @description combined {all_rows_fixed, all_findings_cleared, both} and next_letter {target, reachable, ...} are recomputed, never summed. What each decision moved. rows[]: every failing scored row with points = the score recomputed with that row passing minus the score now (same formula, Reach + 15 ceiling included), points_section_average, and why a row moves nothing; withheld (rows_withheld) where the fix list is. Findings move no points: each finding's score_effect states the letter cap it sets, whether it binds, and the letter without it. */
-            score_ledger?: Record<string, never> | null;
-            /** @description Counts and ratios behind the reading: sections_scored, identities_answered, fetches_kept, stage_failures, non_observations, vantages. No composite number, because the parts do not combine into one honestly */
-            confidence?: Record<string, never> | null;
-            /** @description Each stated fact with two times: when CrawlCheck observed it (observed_from, observed_last, removed_at) and when the site says it became true (valid time, null when the site does not say) */
-            bitemporal?: Record<string, never> | null;
-            /** @description What was not measured on this scan and why; an unmeasured subject is never scored as a pass or a fail */
-            non_observations?: {
-                subject?: string | null;
-                state?: string | null;
-                reason?: string | null;
-                attempted?: boolean | null;
-            }[] | null;
-            /** @description Each value carries locators[] (one per source): bytes [start, end) in the page this scan received, line, col, scope (meta[og:title], script[ld+json]#0, title, page text) and match (value | property | normalised | partial), or {found:false, why}; check them with /api/locate. Each business fact (name, phone, address, email, founder) with every value the site stated and where it stated it, and whether the statements agree */
-            fact_lineage?: Record<string, never> | null;
-            checks?: {
-                path?: string | null;
-                status?: number | null;
-                bytes?: number | null;
-            }[];
-            agentview?: {
-                label?: string | null;
-                status?: number | null;
-                words?: number | null;
-            }[];
-            nap?: Record<string, never> | null;
-            headroom?: {
-                gain?: number | null;
-                failing?: number | null;
-            } | null;
-            history?: {
-                at?: string | null;
-                overall?: number | null;
-                score_version?: number | null;
-            }[];
-            proof: {
-                digest?: string | null;
-                algorithm?: string | null;
-                anchored?: string | null;
-                verify?: string | null;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-agent-outcomes */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    aiAccuracyV1: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-ai-accuracy */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description not tracked or not measured */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    domainLifecycleV1: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-domain */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    visitorResolveV1: {
+        parameters: {
+            query: {
+                ip?: string;
+                ua: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-visitor */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    visitorResolveBatchV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-visitor with results[] */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    conductV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-conduct */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    conductAgentV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agent: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-conduct with one agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description not observed, or not verifiable */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    mcpLockUrl: {
+        parameters: {
+            query: {
+                url: string;
             };
-            links?: Record<string, never>;
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        /** @description One observation in one shape (GET /api/v1/machine-record, MCP machine_record): subject, observation, findings (top in full without a licence; the rest locked), capabilities with safety class and verification state, evidence roots and verifier links */
-        MachineRecordV1: {
-            /** @constant */
-            kind: "crawlcheck-machine-record";
-            version: string;
-            subject: Record<string, never>;
-            observation: Record<string, never>;
-            /** @description each open finding carries trust {freshness, confidence {level, means, basis[]}, contradictions[]} */
-            findings: unknown[];
-            /** @description observed_at, age_hours, latest_report_id, is_latest, newer_scan_exists, last_second_reading_at */
-            freshness?: Record<string, never>;
-            /** @description With a licence: one line per fix that would change this record, best first (findings and rows it clears, other fixes some rows also need, score and letter after, root causes closed, certificate criteria flipped). Without: {fixes_available, best_single_fix {letter_after, score_after, findings_cleared, rows_cleared}} and no names */
-            fix_impact?: unknown[] | Record<string, never> | null;
-            /** @description score, letter, cap and the points each failing row moves (rows open with a licence); each open finding carries score_effect {points: 0, cap, binding, letter_without_it, says} */
-            score_ledger?: Record<string, never> | null;
-            /** @description counts and ratios plus vantages; no composite number; levels: contested | cross_vantage_confirmed | reproduced | single_reading */
-            confidence?: Record<string, never>;
-            /** @description site (the site contradicts itself) and between_networks_open (observers disagree), for findings this caller can open */
-            contradictions?: Record<string, never>;
-            findings_summary?: Record<string, never> | null;
-            findings_withheld?: string | null;
-            capabilities: Record<string, never>;
-            evidence: Record<string, never>;
-            access: Record<string, never>;
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-mcp-lock */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description no tool list returned */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
-        ErrorV1: {
-            error: {
-                code: string;
-                status?: number;
-                message: string;
+    };
+    mcpLockTools: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": Record<string, never>;
             };
         };
-        /** @description GET /api/bundle: one file that checks offline with /crawlcheck-verify.mjs. A field that cannot be filled (an anonymous download, an unsealed day, a record from before manifests) is null with a *_withheld / *_missing / why reason, never omitted */
-        EvidenceBundleV1: {
-            /** @constant */
-            kind: "crawlcheck-evidence-bundle";
-            version: number;
-            generated_at?: string;
-            report: {
-                id: string | null;
-                domain: string | null;
-                path?: string | null;
-                scanned_at: string | null;
-                score_version?: number | null;
-                archived?: boolean;
+        responses: {
+            /** @description crawlcheck-mcp-lock */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
             };
-            verifier: {
+        };
+    };
+    mcpLockCheck: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": Record<string, never>;
+            };
+        };
+        responses: {
+            /** @description crawlcheck-mcp-lock-check */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description no lockfile */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    mcpScanUrl: {
+        parameters: {
+            query: {
                 url: string;
-                sha256: string;
-                run?: string;
-                page?: string;
             };
-            proves?: string[];
-            does_not_prove?: string[];
-            manifest: {
-                sha256: string;
-                body: string | null;
-                body_missing?: string | null;
-                signature?: {
-                    alg?: string | null;
-                    kid?: string | null;
-                    message?: string | null;
-                    sig?: string | null;
-                    signed_at?: string | null;
-                } | null;
-                key?: {
-                    jwk?: {
-                        /** @constant */
-                        kty: "OKP";
-                        /** @constant */
-                        crv: "Ed25519";
-                        x: string;
-                    };
-                    kid?: string;
-                    published_in?: string;
-                } | null;
-                key_missing?: string | null;
-            } | null;
-            record: {
-                digest: string | null;
-                subject: string | null;
-                subject_withheld?: string | null;
-                recipe?: string | null;
-                decision_leaves?: Record<string, never>[] | null;
-                lineage_leaves?: Record<string, never>[] | null;
-                leaves_withheld?: string | null;
-            } | null;
-            seal: {
-                /** @enum {unknown} */
-                state: "sealed" | "pending" | "unsealed" | "unverifiable" | "unknown";
-                day?: string | null;
-                root?: string | null;
-                path?: {
-                    /** @enum {unknown} */
-                    side: "left" | "right";
-                    hash: string;
-                }[];
-                leaves_that_day?: number | null;
-                sealed_at?: string | null;
-                calendars?: string[];
-                ots_base64?: string | null;
-                bitcoin_block?: number | null;
-                recipe?: string | null;
-                why?: string | null;
-            } | null;
-            /** @description sec8: every bundle is scanned before it is served; a section that matched is null and carries <section>_withheld */
-            publish_guard?: {
-                checked?: string[];
-                withheld?: {
-                    section?: string;
-                    matched?: string[];
-                }[];
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-mcp-scan */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description read limit */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            /** @description Who can read which representation of a scan: /docs/api#disclosure */
-            disclosure?: string;
-        } & {
-            [key: string]: string;
         };
-        /** @description A signed remediation receipt (GET /api/receipt?id=). receipt_id = rc1: + sha256 of the canonical JSON of every field except receipt_id and signature; signature = Ed25519 over 'crawlcheck-receipt-v1\n' + that sha256 */
-        RemediationReceiptV1: {
-            receipt_id: string;
-            /** @constant */
-            kind: "crawlcheck-remediation-receipt";
-            /** @constant */
-            v: 1;
-            issued_at: string;
-            issuer: {
-                observer?: string | null;
-                version_id?: string | null;
-                version_tag?: string | null;
-                key: {
-                    kid: string;
-                    jwk: Record<string, never>;
-                    published_in?: string | null;
+    };
+    mcpScanTools: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": Record<string, never>;
+            };
+        };
+        responses: {
+            /** @description crawlcheck-mcp-scan */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description neither tools nor url */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    rightsFeedIndex: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-rights-feed-index */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
                 };
             };
-            subject: {
-                domain: string;
-            };
-            before: components["schemas"]["ReceiptSideV1"];
-            after: components["schemas"]["ReceiptSideV1"];
-            declared_fix: {
-                kind?: string;
-                declared_by?: string | null;
-                declared_at?: string | null;
-                plugin_version?: string | null;
-                fixes?: string[] | null;
-                note?: string | null;
-            };
-            deployed: {
-                at?: string | null;
-                basis?: string | null;
+        };
+    };
+    rightsFeedFile: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                file: string;
             };
-            verification: {
-                /** @enum {unknown} */
-                verdict: "improved" | "unchanged" | "mixed" | "regressed";
-                summary?: string | null;
-                comparable?: boolean;
-                findings?: Record<string, never>;
-                rows?: Record<string, never>;
-                files?: {
-                    path?: string;
-                    state?: string;
-                    before_sha256?: string | null;
-                    after_sha256?: string | null;
-                    before_status?: number | null;
-                    after_status?: number | null;
-                }[];
-                rollback_needed?: boolean;
-                rollback_steps?: Record<string, never>[];
-                method?: string | null;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description manifest or gzip part */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/gzip": unknown;
+                };
             };
-            links?: Record<string, never>;
-            signature: {
-                v?: number | null;
-                /** @constant */
-                alg: "Ed25519";
-                kid: string;
-                over?: string | null;
-                receipt_sha256: string;
-                message: string;
-                sig: string;
-                signed_at?: string | null;
-                canonical?: string | null;
+            /** @description no such edition or file */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
         };
-        /** @description tr1: one scan's trace (GET /api/trace?id=, owner; sampled by the trace CI job). W3C Trace Context ids. Every span's parent is the scan span (root_span_id) or a span of this trace; the scan span's own parent is the caller's span when the scan joined a caller's trace (parent). */
-        TraceV1: {
-            id: string | null;
-            domain?: string | null;
-            scanned_at?: string | null;
-            traced: boolean;
-            why?: string | null;
-            trace_id?: string;
-            root_span_id?: string;
-            traceparent?: string;
-            parent?: {
-                span_id?: string;
-                source?: string | null;
-                previous_trace_id?: string | null;
-            } | null;
-            scan_id?: string | null;
-            started_at?: string | null;
-            total_ms?: number | null;
-            dropped?: number;
-            recorded_through?: unknown;
-            spans?: components["schemas"]["SpanV1"][];
-            errors?: {
-                error_id?: string | null;
-                stage?: string | null;
-                span_id: string | null;
-                error?: string | null;
-            }[];
-            findings?: {
-                code?: string | null;
-                decision_id?: string | null;
-                span_id?: string | null;
-                parent_span_id?: string | null;
-                parent_stage?: string | null;
-                reads?: number | null;
-            }[];
-            coverage?: Record<string, never>;
-            slowest?: unknown[];
-            decisions_with_spans?: number | null;
-            note?: string | null;
-        } & unknown;
-        /** @description tr1: one span: a stage of the scan, or (kind rule) one decision, started when its rule decided. */
-        SpanV1: {
-            span_id: string;
-            parent_span_id: string;
-            stage: string;
-            /** @enum {unknown} */
-            kind?: "rule";
-            start_ms: number;
-            dur_ms?: number | null;
-            /** @enum {unknown} */
-            status: "ok" | "error" | "inputs_disputed";
-            error_id?: string | null;
-            code?: string | null;
-            path?: string | null;
-            decision_id?: string | null;
-            reads?: {
-                experience_id?: string | null;
-                fetched_in?: string | null;
-                stage?: string | null;
-                fetched_after_rule?: boolean;
-            }[];
-            parent_basis?: string | null;
+    };
+    rightsV1: {
+        parameters: {
+            query: {
+                domain: string;
+                path?: string;
+                agent?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        /** @description dsp1: a signed resolution of a dispute against one finding (GET /api/disputes/resolution?id=). Verifies offline with crawlcheck-verify.mjs: hash, key id, Ed25519 signature, and the verdict re-derived from the recorded readings by the published decision table. */
-        DisputeResolutionV1: {
-            resolution_id: string;
-            /** @constant */
-            kind: "crawlcheck-dispute-resolution";
-            /** @constant */
-            v: 1;
-            schema?: string | null;
-            dispute_id: string;
-            issued_at: string;
-            issuer: {
-                observer?: string | null;
-                version_id?: string | null;
-                version_tag?: string | null;
-                key?: {
-                    kid?: string;
-                    jwk?: Record<string, never>;
-                    published_in?: string;
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-rights */
+            200: {
+                headers: {
+                    [name: string]: unknown;
                 };
-            };
-            subject: {
-                domain: string;
-                record: Record<string, never>;
-                finding: {
-                    code?: string;
-                    path?: string | null;
-                    fid?: string | null;
-                    decision_id?: string | null;
-                    title?: string | null;
-                    severity?: number | null;
-                    rule_revision?: number | null;
+                content: {
+                    "application/json": unknown;
                 };
             };
-            dispute: {
-                filed_at?: string;
-                /** @enum {unknown} */
-                ground?: "misread" | "fixed" | "network" | "rule";
-                ground_text?: string | null;
-                statement?: string;
-                ownership?: {
-                    method?: string;
-                    at?: string;
-                    url?: string | null;
-                    sha256?: string | null;
-                } | null;
-            };
-            remeasurement: {
-                replay: {
-                    reproduces?: boolean | null;
-                    rule?: string | null;
-                    read?: unknown;
-                    why?: string | null;
-                    rule_revision?: number | null;
-                    over?: string | null;
+            /** @description not a public domain */
+            400: {
+                headers: {
+                    [name: string]: unknown;
                 };
-                observers: {
-                    /** @enum {unknown} */
-                    role: "primary" | "independent";
-                    observer_id: string;
-                    network_class?: string | null;
-                    network?: string | null;
-                    at?: string | null;
-                    finding_present: boolean | null;
-                    inputs_agree?: boolean | null;
-                    method?: string | null;
-                    reading?: string | null;
-                    side?: Record<string, never> | null;
-                    observation?: Record<string, never> | null;
-                }[];
-                deadline?: string | null;
-                independent_wait_hours?: number | null;
+                content?: never;
             };
-            decision: {
-                /** @enum {unknown} */
-                verdict: "upheld" | "corrected" | "fixed_since" | "vantage_dependent" | "no_longer_observed" | "inconclusive";
-                verdict_text?: string | null;
-                /** @enum {unknown} */
-                effect: "stands" | "withdrawn" | "stands_for_record" | "stands_with_scope" | "stands_unresolved";
-                effect_text?: string | null;
-                rule?: string | null;
-                table?: string | null;
-                derived_by?: string | null;
+            /** @description the site could not be read */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            links?: Record<string, never>;
-            signature: {
-                /** @constant */
-                v?: 1;
-                /** @constant */
-                alg: "Ed25519";
-                kid: string;
-                /** @constant */
-                over?: "resolution_sha256";
-                resolution_sha256: string;
-                message: string;
-                sig: string;
-                signed_at?: string;
-                canonical?: string;
+            /** @description read limit */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
         };
-        /** @description Every finding the scanner can raise (GET /api/rules): what it means, its level, its fix and its share of counted scans. */
-        RulebookV1: {
-            ok?: boolean;
-            /** @constant */
-            kind: "crawlcheck-rulebook";
-            /** @constant */
-            v: 1;
-            generated_at: string;
-            score_version?: number | null;
-            schema?: string | null;
-            counts: {
-                rules: number;
-                by_kind?: {
-                    [key: string]: number;
+    };
+    readEquivalenceV1: {
+        parameters: {
+            query: {
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-read-equivalence */
+            200: {
+                headers: {
+                    [name: string]: unknown;
                 };
-                by_family?: {
-                    [key: string]: number;
+                content: {
+                    "application/json": unknown;
                 };
-                revised?: number;
-                scored?: number;
             };
-            scans_counted?: number | null;
-            severity_scale: {
-                level?: string;
-            }[];
-            method?: {
-                revisions?: string | null;
-                share?: string | null;
-                grade?: string | null;
+            /** @description not a public http(s) URL */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description read limit */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            /** @description every rule; with ?code= only that rule (counts still describe the whole rulebook) */
-            rules: components["schemas"]["RuleV1"][];
-            filter?: {
-                code?: string | null;
-            } | null;
         };
-        /** @description One rule: the code, what it means, its level, its current revision, its fix and its share of counted scans. */
-        RuleV1: {
-            code: string;
-            /**
-             * @description self_audit: a defect in CrawlCheck's own record, never in the site
-             * @enum {unknown}
-             */
-            kind: "scan" | "answer_correlation" | "capability_mismatch" | "self_audit";
-            family: {
-                id: string;
-                label: string;
+    };
+    selfClaimsV1: {
+        parameters: {
+            query: {
+                domain: string;
             };
-            title: string | null;
-            meaning?: string | null;
-            severity: {
-                level?: string | null;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-claims */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
             };
-            /** @description raised on a graded scan record; refusals, answer runs, capability mismatches and self-audit findings are not */
-            scored?: boolean;
-            measured_on?: string | null;
-            revision: {
-                current: number;
-                /** @description when the current revision took effect; null while the rule is at revision 1 */
-                revised_at?: string | null;
+            /** @description not a public domain */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            fix?: {
-                advice?: string | null;
-                effort?: string | null;
-                endpoint?: string | null;
+            /** @description the site could not be read */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            share_of_scans: {
-                pct: number | null;
-                scans?: number | null;
-                of_scans?: number | null;
-                basis: string;
+            /** @description read limit */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
-            links?: {
-                self?: string | null;
-                api?: string | null;
-                glossary?: string[];
-                workflow?: string | null;
-                lineage?: string | null;
-                explain_template?: string | null;
+        };
+    };
+    originByAnchorV1: {
+        parameters: {
+            query: {
+                passage: string;
             };
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        /** @description What the owner's connected outcome sources counted either side of a receipt's anchor day (GET /api/outcomes). One series per named source; per-day values compared; a series with no source is connected:false with how_to_connect; a window under 7 measured days is usable:false with why. Never a claim of cause. */
-        FixOutcomesV1: {
-            ok?: boolean;
-            /** @constant */
-            kind: "crawlcheck-fix-outcomes";
-            /** @constant */
-            v: 1;
-            generated_at?: string;
-            cached?: boolean;
-            receipt: {
-                id: string;
-                domain: string;
-                verdict?: string | null;
-                findings_cleared?: string[];
-                url?: string;
-                anchor: {
-                    at?: string;
-                    /** Format: date */
-                    day: string;
-                    basis: string;
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-origin */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
                 };
             };
-            window: {
-                days: number;
-                before: {
-                    from?: string | null;
-                    to?: string | null;
+        };
+    };
+    originV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-origin */
+            200: {
+                headers: {
+                    [name: string]: unknown;
                 };
-                after: {
-                    from?: string | null;
-                    to?: string | null;
-                    days_elapsed?: number;
-                    complete?: boolean;
+                content: {
+                    "application/json": unknown;
                 };
             };
-            connected: number;
-            usable: number;
-            series: {
-                key: string;
-                label: string;
-                source: string;
-                /** @enum {unknown} */
-                mode: "daily" | "events";
-                connected: boolean;
-                note?: string;
-                how_to_connect?: string | null;
-                before?: components["schemas"]["OutcomeSideV1"] | null;
-                after?: components["schemas"]["OutcomeSideV1"] | null;
-                delta_per_day?: number | null;
-                pct?: number | null;
-                usable: boolean;
-                why: string;
-            }[];
-            not_measured?: {
-                key?: string;
-                why?: string;
-            }[];
-            summary?: string;
-            reading?: string;
-            not_proof: string;
-            how_to_cite?: string;
         };
-        OutcomeSideV1: {
-            from?: string | null;
-            to?: string | null;
-            days: number;
-            measured: number;
-            sum: number;
-            per_day: number | null;
+    };
+    contentClockV1: {
+        parameters: {
+            query: {
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
         };
-        ReceiptSideV1: {
-            report_id: string | null;
-            scanned_at: string | null;
-            grade?: string | null;
-            score?: number | null;
-            score_version?: number | null;
-            refused?: boolean;
-            findings?: number | null;
-            manifest_sha256?: string | null;
-            decision_root?: string | null;
-            trace_id?: string | null;
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-content-clock */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description page unreadable */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
-    responses: never;
-    parameters: never;
-    requestBodies: never;
-    headers: never;
-    pathItems: never;
-}
-export type $defs = Record<string, never>;
-export interface operations {
-    scan: {
+    citedByV1: {
         parameters: {
-            query?: never;
+            query?: {
+                url?: string;
+                domain?: string;
+            };
             header?: never;
             path?: never;
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": {
-                    /**
-                     * @description A bare domain or a full URL
-                     * @example example.com
-                     */
-                    domain: string;
-                    /**
-                     * @description unlisted: the report is reachable only by its link; the scan is sealed and archived but enters no public registry, dataset, history or resolve answer. private: needs a licence for the domain (or the owner); the report opens only for that licence holder or the owner and is not archived or listed anywhere (default public)
-                     * @enum {unknown}
-                     */
-                    visibility?: "public" | "unlisted" | "private";
-                };
-            };
-        };
+        requestBody?: never;
         responses: {
-            /** @description The scan record */
+            /** @description crawlcheck-cited-by */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["ScanRecord"];
+                    "application/json": unknown;
                 };
             };
-            /** @description Not a public domain (reserved names such as .example and .invalid included), or no JSON body */
+            /** @description give url or domain */
             400: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Rate limited: 5 requests per 10 seconds per address; a scan of the same domain still running (code scan_in_progress); or the daily total of free scans reached (code daily_budget). Retry-After says when. A rescan of a domain scanned in the last 2 minutes returns that report (field cached) instead of fetching the site again; a domain where nothing answered returns 200 with unreachable: true, id: null and nothing stored */
-            429: {
+        };
+    };
+    anchorCreateV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-anchor */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description page unreachable or passage not found */
+            422: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description Free scans paused (code scans_paused); keyed scans are unaffected */
-            503: {
+        };
+    };
+    anchorWatchV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description watching */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description no such anchor */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2475,39 +3652,83 @@ export interface operations {
             };
         };
     };
-    scanDomainV1: {
+    anchorSinkV1: {
         parameters: {
             query?: never;
             header?: never;
-            path?: never;
+            path: {
+                token: string;
+            };
             cookie?: never;
         };
-        requestBody: {
-            content: {
-                "application/json": {
-                    domain: string;
+        requestBody?: never;
+        responses: {
+            /** @description deliveries */
+            200: {
+                headers: {
+                    [name: string]: unknown;
                 };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    anchorGetV1: {
+        parameters: {
+            query?: {
+                recheck?: "1";
+            };
+            header?: never;
+            path: {
+                id: string;
             };
+            cookie?: never;
         };
+        requestBody?: never;
         responses: {
-            /** @description PublicReportV1 */
+            /** @description anchor, seal, and check when asked */
             200: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content: {
-                    "application/json": components["schemas"]["PublicReportV1"];
+                    "application/json": unknown;
                 };
             };
-            /** @description ErrorV1: bad_request */
-            400: {
+            /** @description no such anchor */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
                 content?: never;
             };
-            /** @description ErrorV1: rate_limited */
-            429: {
+        };
+    };
+    visitorArrivalV1: {
+        parameters: {
+            query: {
+                ua: string;
+                path?: string;
+                verdict?: "verified" | "spoofed" | "unverifiable";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description recorded */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description not a Worker subrequest */
+            403: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2515,7 +3736,7 @@ export interface operations {
             };
         };
     };
-    reportAgentOutcomeV1: {
+    trafficIndexV1: {
         parameters: {
             query?: never;
             header?: never;
@@ -2524,8 +3745,8 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description accepted */
-            202: {
+            /** @description crawlcheck-traffic-index */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2533,15 +3754,30 @@ export interface operations {
                     "application/json": unknown;
                 };
             };
-            /** @description invalid report */
-            400: {
+        };
+    };
+    trafficIndexMonthV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                month: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-traffic-index */
+            200: {
                 headers: {
                     [name: string]: unknown;
                 };
-                content?: never;
+                content: {
+                    "application/json": unknown;
+                };
             };
-            /** @description 500 reports a day per address */
-            429: {
+            /** @description no such month */
+            404: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -2549,18 +3785,16 @@ export interface operations {
             };
         };
     };
-    agentOutcomesV1: {
+    visitorStatsV1: {
         parameters: {
-            query: {
-                domain: string;
-            };
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description crawlcheck-agent-outcomes */
+            /** @description crawlcheck-visitor-stats */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2571,18 +3805,20 @@ export interface operations {
             };
         };
     };
-    aiAccuracyV1: {
+    decisionCheckV1: {
         parameters: {
-            query: {
-                domain: string;
+            query?: {
+                host?: string;
             };
             header?: never;
-            path?: never;
+            path: {
+                sha256: string;
+            };
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description crawlcheck-ai-accuracy */
+            /** @description crawlcheck-decision-check */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2591,7 +3827,7 @@ export interface operations {
                     "application/json": unknown;
                 };
             };
-            /** @description not tracked or not measured */
+            /** @description no receipt with that digest is held */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -2600,18 +3836,95 @@ export interface operations {
             };
         };
     };
-    domainLifecycleV1: {
+    decisionStatsV1: {
         parameters: {
-            query: {
-                domain: string;
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-decision-stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    resolvePrefixV1: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                prefix: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description crawlcheck-resolve-prefix */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description more than 100 answers share the prefix; send a longer one */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description the index is built when the first daily snapshot finishes */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
+        };
+    };
+    resolveSnapshotIndex: {
+        parameters: {
+            query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
         requestBody?: never;
         responses: {
-            /** @description crawlcheck-domain */
+            /** @description crawlcheck-snapshot-index */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    resolveSnapshotFile: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                file: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description manifest.json or a gzip part */
             200: {
                 headers: {
                     [name: string]: unknown;
@@ -2620,6 +3933,13 @@ export interface operations {
                     "application/json": unknown;
                 };
             };
+            /** @description unknown or deleted snapshot file */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     resolveChangesV1: {