agentlinkops 0.6.13 → 0.6.16

package/src/page-extraction/metadata.js

@@ -0,0 +1,16 @@
+import { parseDocument } from './html.js';
+
+/** Pure metadata extraction; no requests, supplier calls or judgments. */
+export function extractPageMetadata(html, { baseUrl } = {}) {
+  if (typeof html !== 'string' || !html) return {
+    title: null, h1s: [], meta_description: null, canonical: null,
+    link_counts: null, asset_candidate_reasons: null,
+  };
+  // A private resolution base lets the parser count relative physical links.
+  // It must never escape as a claimed publisher canonical URL.
+  const resolutionBase = baseUrl ?? 'https://page-metadata.invalid/';
+  const parsed = parseDocument(html, resolutionBase, { includeMetadata: true });
+  if (parsed.incomplete) throw Object.assign(new Error('incomplete_document'), { reason: 'incomplete_document' });
+  if (baseUrl === undefined && parsed.metadata.canonical?.startsWith('https://page-metadata.invalid/')) parsed.metadata.canonical = null;
+  return parsed.metadata;
+}

package/src/response-shaping.js

@@ -13,17 +13,18 @@ const pick = (row, keys) => Object.fromEntries(keys.filter(key => row[key] !== u
 const attempt = value => value && typeof value === 'object' ? pick(value, ['state','reason','checkedAt','httpStatus','occurrenceCount','checkerVersion']) : value;
 export function conciseObservationState(state) {
   if (!state || typeof state !== 'object') return state ?? {};
-  const out = pick(state, ['state','uncertain','checked_at','reason','confirmedState','lastChangedAt','firstAbsentAt','consecutiveAbsent','nextCheckAt','lastSuccessfulAt','lastHealthyAt','firstUnavailableAt','unavailableCount','retryNotBefore']);
+  const out = pick(state, ['state','wasEverPresent','uncertain','checked_at','reason','confirmedState','lastChangedAt','firstAbsentAt','consecutiveAbsent','nextCheckAt','lastSuccessfulAt','lastHealthyAt','firstUnavailableAt','unavailableCount','retryNotBefore']);
   if (state.latestAttempt !== undefined) out.latestAttempt = attempt(state.latestAttempt);
   if (state.lastSuccessfulObservation !== undefined) out.lastSuccessfulObservation = attempt(state.lastSuccessfulObservation);
   if (state.lastSuccessfulObservationSameAsLatestAttempt !== undefined) out.lastSuccessfulObservationSameAsLatestAttempt = state.lastSuccessfulObservationSameAsLatestAttempt;
   return out;
 }
 const withState = (row, keys) => ({ ...pick(row, keys), observation_state: conciseObservationState(row.observation_state) });
+const categoryFields=['category_contract','chosen_category','page_assessment','display_category'];
 // An event snapshot (shared/observation-event.js) minus the occurrence list, expectations and
 // signatures: the state, uncertainty, check state, reason, status and timing stay.
 const conciseSnapshot = snapshot => snapshot && typeof snapshot === 'object'
-  ? pick(snapshot, ['state','uncertain','check_state','reason','checked_at','http_status','occurrence_count','occurrences_truncated','source_url','target_url','url','next_check_at','watch_id','target_id'])
+  ? pick(snapshot, ['state','wasEverPresent','uncertain','check_state','reason','checked_at','http_status','occurrence_count','occurrences_truncated','source_url','target_url','url','next_check_at','watch_id','target_id'])
   : snapshot;
 const observationResult = result => result && typeof result === 'object'
   ? { ...pick(result, ['state','reason','checkedAt','httpStatus','checkerVersion','evidence','redirects']), occurrenceCount: result.occurrenceCount ?? result.occurrences?.length ?? 0 }
@@ -34,7 +35,7 @@ const observationResult = result => result && typeof result === 'object'
 export const SHAPES = {
   list_rank_history: { rows: 'items', keeps: ['overview_run_id','slot_at','rank','observed_at','retrieved_at','freshness','outcome','execution','cost'],
     row: r => pick(r, ['overview_run_id','slot_at','rank','observed_at','retrieved_at','freshness','outcome','execution','cost']) },
-  list_link_watches: { rows: 'items', keeps: ['id','source_url','target_url','status','state','observation_state','next_check_at','local_reference'], row: r => withState(r, ['id','source_url','target_url','status','state','next_check_at','local_reference']) },
+  list_link_watches: { rows: 'items', keeps: ['id','workspace_id','project_id','source_url','target_url','status','state','observation_state','next_check_at','local_reference','intent','outreachStatus','lastContactedAt','campaign',...categoryFields], row: r => withState(r, ['id','workspace_id','project_id','source_url','target_url','status','state','next_check_at','local_reference','intent','outreachStatus','lastContactedAt','campaign',...categoryFields]) },
   list_targets: { rows: 'items', keeps: ['id','url','status','state','observation_state','next_check_at'], row: r => withState(r, ['id','url','status','state','next_check_at']) },
   get_target_placements: { rows: 'items', keeps: ['id','source_url','target_url','target_scope','status','state'], row: r => pick(r, ['id','source_url','target_url','target_scope','status','state']) },
   list_check_jobs: { rows: 'items', keeps: ['id','state','type','watch_id','target_id','attempt_count','error_code','created_at','completed_at'], row: r => pick(r, ['id','state','type','watch_id','target_id','attempt_count','error_code','created_at','completed_at']) },

package/src/tool-views.js

@@ -3,25 +3,28 @@
 // script, the MCP router, the CLI index and the generators all read the same definitions.
 // Rules: docs/technical/AGENT-SURFACE-CONTRACT.md (DP-0036).
 
-export const TOOLSETS = ['monitoring','evidence','rank','licensed','discovery','baseline','library','competitors','reports','workspace','notifications','webhooks','admission','disavow','lifecycle','digests'];
+export const TOOLSETS = ['monitoring','classification','evidence','rank','licensed','discovery','baseline','library','competitors','internal-links','reports','workspace','notifications','webhooks','admission','disavow','lifecycle','campaigns','digests'];
 
 // One line per toolset: what the group is for. Printed by the site brief, the REST index and the
 // catalog snapshot so the same wording reaches every client; a toolset without a summary is a
 // gate failure in the measurement script.
 export const TOOLSET_SUMMARIES = {
   admission: 'Project rules, URL previews and retained admission decisions.',
-  disavow: 'Propose, review and export website disavow rules.',
+  disavow: 'Propose, review and export website disavow rules; check the copy Google holds (handoffs).',
   lifecycle: 'Placement costs, expiry, renewal events and currency reports.',
-  digests: 'Own-address digest preferences, delivery history and exact events.',
+  campaigns: 'Campaign contacts and supplied outreach outcomes.',
+  digests: 'Own-address digest delivery history and exact retained events.',
   monitoring: 'Watch earned links and destination URLs: create, list, update, import, export, recheck.',
+  classification: 'Manual link types and tags with retained placement context and metadata.',
   evidence: 'What a check observed: histories, snapshots, change feeds, check jobs, published contacts.',
   rank: 'Synthetic DataForSEO rank schedules and dated history; hosted collection disabled.',
   licensed: 'Licensed source-search evidence and charge custody; operator admission required.',
   discovery: 'Import candidate rows, read stored runs, verify selected candidates, enroll them.',
-  baseline: 'Scoped backlink baselines; supplier admission disabled.',
+  baseline: 'Scoped backlink baselines; new live work requires admission in this deployment.',
   library: 'Read and export the coverage-stated opportunity library.',
-  competitors: 'Competitor sets, dated inventories, scheduled refresh, gap and domain-mix reports.',
-  reports: 'Placement chronology, service assurance and backlink reports.',
+  competitors: 'Competitor sets, dated inventories, scheduled refresh and gap reports.',
+  'internal-links': 'Owned-site page inventories, bounded captures, internal-link health and graph evidence.',
+  reports: 'Placement chronology, service assurance, backlink and domain-mix reports.',
   workspace: 'Workspace, projects, usage, members, invitations, scratch-resource cleanup.',
   notifications: 'Email notification preferences, previews, tests and deliveries.',
   webhooks: 'Webhook endpoints, state, secrets and delivery records.',
@@ -57,15 +60,22 @@ export function oneLiner(description, max = 60) {
   return `${cut.slice(0, Math.max(cut.lastIndexOf(' '), 20)).replace(/[,;:]$/, '')}…`;
 }
 
-// entries: [{ name, description, toolset, tier, readOnly }]. Grouped, one line per command.
-export function manifestText(entries, { max = 28 } = {}) {
+// entries: [{ name, description, toolset, tier, readOnly }]. Grouped under each toolset's summary,
+// one line per command with its core and write markers. Only core commands carry a one-liner;
+// a deferred command's detail is one describe away. Per-command one-liners were cut from 28 to
+// 23 characters as commands were added until the 2,500-token budget (measure:tools) had no room
+// left; names under a toolset summary keep that budget without a further cut per command.
+export function manifestText(entries, { max = 23 } = {}) {
   const groups = new Map(TOOLSETS.map(t => [t, []]));
   for (const entry of entries) (groups.get(entry.toolset) ?? groups.set(entry.toolset, []).get(entry.toolset)).push(entry);
-  const lines = ['Commands by toolset. MCP: `exec search <words>`, `exec describe <name>`, `exec call <name> <json>`. CLI: `agentlinkops tools | describe | call`. Licensed supplier calls require operator admission.'];
+  const lines = ['Commands by toolset. exec help / agentlinkops --help.' + (entries.some(entry=>entry.toolset==='licensed') ? ' Licensed: operator admission.' : '')];
   for (const [toolset, members] of groups) {
     if (!members.length) continue;
-    lines.push(`\n${toolset}:`);
-    for (const entry of members.sort((a, b) => a.name.localeCompare(b.name))) lines.push(`- ${entry.name}${entry.tier === 'core' ? ' (core)' : ''}${entry.readOnly ? '' : ' [write]'}: ${oneLiner(entry.description, max)}`);
+    lines.push(`\n${toolset}:${TOOLSET_SUMMARIES[toolset] ? ` ${TOOLSET_SUMMARIES[toolset]}` : ''}`);
+    for (const entry of members.sort((a, b) => a.name.localeCompare(b.name))) {
+      const core = entry.tier === 'core';
+      lines.push(`- ${entry.name}${core ? ' (core)' : ''}${entry.readOnly ? '' : ' [write]'}${core ? `: ${oneLiner(entry.description, max)}` : ''}`);
+    }
   }
   return lines.join('\n');
 }
@@ -138,7 +148,7 @@ export function viewMembers(entries, view) {
   // stays registered and callable there through exec call and by a direct tools/call.
   if (view === 'default') return [];
   if (view === 'code') return [];
-  const m = /^toolset:([a-z]+)(:readonly)?$/.exec(view);
+  const m = /^toolset:([a-z]+(?:-[a-z]+)*)(:readonly)?$/.exec(view);
   if (!m) throw new Error(`Unknown view ${view}`);
   const members = visible.filter(e => e.toolset === m[1] || e.tier === 'core');
   return m[2] ? members.filter(e => e.readOnly) : members;

package/src/verifier/fetch.js

@@ -1,339 +1,4 @@
-import { validatePublicUrl } from './url.js';
-import { robotsDecision } from './robots.js';
-
-export class VerificationError extends Error {
-  constructor(reason, details = {}) {
-    super(reason);
-    this.name = 'VerificationError';
-    this.reason = reason;
-    Object.assign(this, details);
-  }
-}
-
-function cancelBody(response) {
-  // Cancellation must not extend the request deadline on a misbehaving transport.
-  response.body?.cancel().catch(() => {});
-}
-
-export async function readBounded(response, maxBytes, signal) {
-  const length = response.headers.get('content-length');
-  const encoded = response.headers.get('content-encoding');
-  if (!encoded && length && Number(length) > maxBytes) {
-    cancelBody(response);
-    throw new VerificationError('body_too_large');
-  }
-  const reader = response.body?.getReader();
-  if (!reader) return { text: '', bytes: 0 };
-  const chunks = [];
-  let bytes = 0;
-  try {
-    while (true) {
-      const { done, value } = await withAbort(reader.read(), signal);
-      if (done) break;
-      bytes += value.byteLength;
-      if (bytes > maxBytes) throw new VerificationError('body_too_large');
-      chunks.push(value);
-    }
-    if (!encoded && length && Number(length) !== bytes) throw new VerificationError('incomplete_body');
-    const combined = new Uint8Array(bytes);
-    let offset = 0;
-    for (const chunk of chunks) { combined.set(chunk, offset); offset += chunk.byteLength; }
-    const contentType = response.headers.get('content-type') ?? '';
-    const charset = /charset\s*=\s*["']?([^\s;"']+)/iu.exec(contentType)?.[1] ?? 'utf-8';
-    let text;
-    try { text = new TextDecoder(charset, { fatal: true }).decode(combined); }
-    catch { throw new VerificationError('unsupported_or_invalid_encoding'); }
-    return { text, bytes, data: combined };
-  } catch (error) {
-    reader.cancel().catch(() => {});
-    throw error;
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-function withAbort(promise, signal) {
-  if (signal.aborted) return Promise.reject(new VerificationError('timeout'));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => reject(new VerificationError('timeout'));
-    signal.addEventListener('abort', onAbort, { once: true });
-    promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
-  });
-}
-
-/** One shared budget for robots, redirects, hooks and source-body reads. */
-export const PRODUCT_TOKEN = 'LinktrailBot';
-
-// A day. Anything longer is a publisher saying "not today", and a scheduler that honoured a
-// month-long Retry-After would silently retire the check instead of retrying it.
-export const MAX_RETRY_AFTER_SECONDS = 86_400;
-
-/**
- * RFC 9110 `Retry-After`: delta-seconds or an HTTP-date. Returns null for anything else.
- *
- * Both forms appear in the wild and a parser that reads only the integer form silently discards
- * the date form, which is the one a CDN tends to send.
- */
-export function retryAfterSeconds(value, now = Date.now()) {
-  if (!value) return null;
-  const text = String(value).trim();
-  if (/^\d+$/u.test(text)) {
-    const seconds = Number(text);
-    return Number.isFinite(seconds) ? Math.min(seconds, MAX_RETRY_AFTER_SECONDS) : null;
-  }
-  // `Date.parse` accepts far more than an HTTP-date — it reads "-5" as a year and returns a real
-  // timestamp, which turned a malformed header into a wait of zero. An IMF-fixdate always carries
-  // a month and day name, so requiring a letter is enough to keep the loose parser off junk.
-  if (!/[A-Za-z]/u.test(text)) return null;
-  const at = Date.parse(text);
-  if (!Number.isFinite(at)) return null;
-  // A date already in the past means "now", never a negative wait.
-  return Math.min(Math.max(0, Math.ceil((at - now) / 1000)), MAX_RETRY_AFTER_SECONDS);
-}
-
-export function publicFetcher(options, signal) {
-  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
-  const robotsByOrigin = new Map();
-  // The product token is what robots matches on and never changes. A contact URL may be appended
-  // so a publisher who sees us in their logs can find out who we are — the convention every
-  // reputable crawler follows, and the thing most likely to move a reflexive 403 or 429.
-  //
-  // It defaults to ABSENT on purpose. It was written before AgentLinkOps had a public domain, and a bot
-  // advertising a URL that does not resolve is worse than one advertising nothing: it reads as
-  // impersonation rather than identification. Set it when a real domain exists.
-  const userAgent = options.userAgentContact
-    ? `${PRODUCT_TOKEN}/0.1 (+${String(options.userAgentContact).slice(0, 200)})`
-    : `${PRODUCT_TOKEN}/0.1`;
-  const maxRedirects = Math.min(options.maxRedirects ?? 5, 5);
-  const maxBytes = Math.min(options.maxBytes ?? 2 * 1024 * 1024, 2 * 1024 * 1024);
-
-  async function request(url, context = {}) {
-    const checked = validatePublicUrl(url);
-    if (!checked.valid) throw new VerificationError(`unsafe_url:${checked.reason}`);
-    if (options.beforeFetch) await withAbort(Promise.resolve().then(() => options.beforeFetch(checked.url, { ...context, signal })), signal);
-    let response;
-    try {
-      response = await withAbort(Promise.resolve().then(() => {
-        if (signal.aborted) throw new VerificationError('timeout');
-        // Conditional headers ride only on the request that earned them. A validator belongs
-        // to one resource; across a redirect hop it would be re-sent to a different one, so
-        // the caller drops validators after the first hop and the redirect loop revalidates
-        // the destination from scratch rather than trusting a moved resource's old validators.
-        const conditional = {};
-        if (context.kind === 'source' && context.validators?.etag) conditional['If-None-Match'] = context.validators.etag;
-        if (context.kind === 'source' && context.validators?.lastModified) conditional['If-Modified-Since'] = context.validators.lastModified;
-        return fetchImpl(checked.url, {
-          method: 'GET',
-          redirect: 'manual',
-          credentials: 'omit',
-          signal,
-          headers: {
-            'User-Agent': userAgent,
-            Accept: context.kind === 'robots' ? 'text/plain' : context.accept ?? 'text/html',
-            ...conditional,
-          },
-        });
-      }), signal);
-    } catch (error) {
-      if (error instanceof VerificationError) throw error;
-      throw new VerificationError(signal.aborted ? 'timeout' : 'network_error');
-    }
-    // Custom transports must never silently follow redirects or bypass destination checks.
-    if (response.redirected || (response.url && new URL(response.url).href !== checked.url)) {
-      cancelBody(response);
-      throw new VerificationError('transport_followed_redirect');
-    }
-    return response;
-  }
-
-  async function fetchRobots(origin, diagnostic) {
-    let url = `${origin}/robots.txt`;
-    const seen = new Set();
-    for (let redirects = 0; redirects <= maxRedirects; redirects++) {
-      diagnostic.robotsUrl = url;
-      diagnostic.httpStatus = null;
-      if (seen.has(url)) throw new VerificationError('robots_redirect_loop');
-      seen.add(url);
-      const response = await request(url, { kind: 'robots' });
-      diagnostic.httpStatus = response.status;
-      // A challenge replaces the requested resource, even when its status would
-      // otherwise mean missing robots or a redirect. Never infer policy from it.
-      if (response.headers.get('cf-mitigated') === 'challenge') {
-        cancelBody(response);
-        const retry = retryAfterSeconds(response.headers.get('retry-after'));
-        if (retry !== null) diagnostic.retryAfterSeconds = retry;
-        throw new VerificationError('robots_access_challenge', retry === null ? {} : { retryAfterSeconds: retry });
-      }
-      if ([301, 302, 303, 307, 308].includes(response.status)) {
-        cancelBody(response);
-        const location = response.headers.get('location');
-        if (!location) throw new VerificationError('robots_redirect_missing_location');
-        const next = validatePublicUrl(new URL(location, url).href);
-        if (!next.valid) throw new VerificationError(`unsafe_robots_redirect:${next.reason}`);
-        if (diagnostic.redirects.length < 5) diagnostic.redirects.push({ from: url, to: next.url, status: response.status });
-        url = next.url;
-        continue;
-      }
-      // RFC 9309 §2.3.1.3 and Google's implementation agree: a 4xx on robots.txt means the file is
-      // UNAVAILABLE, and an unavailable robots.txt imposes no restrictions. Only 404 and 410 were
-      // honoured that way here, so a 401 or 403 — a WAF answering before the file is even looked
-      // for — was read as "this publisher forbids us" and refused the whole fetch. Measured on 800
-      // real destinations, that was 39 refusals, about 5% of the run, attributed to publishers who
-      // had said nothing.
-      //
-      // Proceeding is also BETTER REPORTING even when the page then fails: `target_http_403` says
-      // the publisher refused the page, where `robots_http_403` said we never asked.
-      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-        cancelBody(response);
-        return { text: '', reason: response.status === 404 || response.status === 410 ? 'robots_not_found' : `robots_unavailable_${response.status}` };
-      }
-      // 429 and 5xx are the other half of the same rule and stay a refusal: they mean TEMPORARILY
-      // unavailable, and the spec's answer to that is to stay away rather than to assume consent.
-      if (!response.ok) {
-        cancelBody(response);
-        const retry = retryAfterSeconds(response.headers.get('retry-after'));
-        if (retry !== null) diagnostic.retryAfterSeconds = retry;
-        throw new VerificationError(`robots_http_${response.status}`, retry === null ? {} : { retryAfterSeconds: retry });
-      }
-      const body = await readBounded(response, 512 * 1024, signal);
-      if (/text\/html/iu.test(response.headers.get('content-type') ?? '') || /<(?:!doctype|html|body)\b/iu.test(body.text)) {
-        throw new VerificationError('robots_not_plain_text');
-      }
-      return { text: body.text, reason: 'robots_fetched' };
-    }
-    throw new VerificationError('robots_redirect_limit');
-  }
-
-  async function checkRobots(url, trace) {
-    const origin = new URL(url).origin;
-    const diagnostic = { sourceUrl: url, robotsUrl: `${origin}/robots.txt`, httpStatus: null,
-      productToken: PRODUCT_TOKEN, allowed: null, reason: null, matchedRule: null,
-      crawlDelaySeconds: null, fetched: null, redirects: [] };
-    // Write before fetching/evaluating so refusals keep the failing hop, not the
-    // last allowed origin. Both histories are capped by our redirect budget.
-    trace.robots = diagnostic;
-    trace.robotsHistory ??= [];
-    if (trace.robotsHistory.length < 6) trace.robotsHistory.push(diagnostic);
-    try {
-      if (!robotsByOrigin.has(origin)) {
-        const record = await fetchRobots(origin, diagnostic);
-        robotsByOrigin.set(origin, { ...record, diagnostic: structuredClone(diagnostic) });
-      }
-      const record = robotsByOrigin.get(origin);
-      Object.assign(diagnostic, structuredClone(record.diagnostic), { sourceUrl: url });
-      const decision = robotsDecision(record.text, url);
-      Object.assign(diagnostic, decision, { fetched: record.reason });
-      options.onRobots?.(url, decision);
-      if (decision.allowed !== true) throw new VerificationError(decision.reason);
-      if (decision.crawlDelaySeconds > 0 && !options.beforeFetch) {
-        throw new VerificationError('robots_crawl_delay_requires_scheduler');
-      }
-      return diagnostic;
-    } catch (error) {
-      diagnostic.reason = error instanceof VerificationError ? error.reason : 'verification_error';
-      throw error;
-    }
-  }
-
-  return {
-    // Authorize a native browser document without refetching its body through HTTP.
-    // The caller still needs an independently verified browser egress boundary.
-    async authorizeNavigation(url, trace = {}) {
-      const checked = validatePublicUrl(url);
-      if (!checked.valid) throw new VerificationError('unsafe_render_navigation');
-      const robots = await checkRobots(checked.url, trace);
-      if (signal.aborted) throw new VerificationError('timeout');
-      await options.beforeFetch?.(checked.url, { kind: 'source', crawlDelaySeconds: robots.crawlDelaySeconds, signal });
-      if (signal.aborted) throw new VerificationError('timeout');
-      return robots;
-    },
-    /**
-     * Fetches one source document. `{ validators }` turns this into a conditional GET: the
-     * caller passes the ETag/Last-Modified a previous fetch earned, and a 304 comes back as
-     * `{ notModified: true }` rather than an error. A 304 we did not ask for stays an error —
-     * the server revalidating nobody's cache is a defect, not evidence of anything.
-     *
-     * `{ document: true }` fetches a feed or sitemap instead of a page: the Accept header and
-     * the content-type gate admit the XML family rather than HTML. Everything else — robots per
-     * hop, public-destination screening, the redirect budget — is identical, because a feed is
-     * fetched from the same publishers under the same politeness rules as a page.
-     */
-    async source(initialUrl, trace, { validators = null, document = false } = {}) {
-      const accept = document
-        ? 'application/rss+xml, application/atom+xml, application/xml;q=0.9, text/xml;q=0.9, text/plain;q=0.8'
-        : 'text/html';
-      let url = initialUrl;
-      let revalidators = validators;
-      const seen = new Set();
-      for (let redirects = 0; redirects <= maxRedirects; redirects++) {
-        trace.finalUrl = url;
-        if (seen.has(url)) throw new VerificationError('redirect_loop');
-        seen.add(url);
-        const robots = await checkRobots(url, trace);
-        trace.robots = robots;
-        const response = await request(url, { kind: 'source', crawlDelaySeconds: robots.crawlDelaySeconds, validators: revalidators, accept });
-        trace.httpStatus = response.status;
-        trace.sourceResponse = { url, httpStatus: response.status,
-          contentType: /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+/iu.exec(response.headers.get('content-type') ?? '')?.[0].slice(0, 128) ?? null,
-          retryAfterSeconds: retryAfterSeconds(response.headers.get('retry-after')),
-          challenge: response.headers.get('cf-mitigated') === 'challenge' };
-        if (trace.sourceResponse.challenge) {
-          cancelBody(response);
-          const retry = trace.sourceResponse.retryAfterSeconds;
-          throw new VerificationError('access_challenge', retry === null ? {} : { retryAfterSeconds: retry });
-        }
-        if ([301, 302, 303, 307, 308].includes(response.status)) {
-          cancelBody(response);
-          const location = response.headers.get('location');
-          if (!location) throw new VerificationError('redirect_missing_location');
-          let next;
-          try { next = validatePublicUrl(new URL(location, url).href); }
-          catch { throw new VerificationError('invalid_redirect'); }
-          if (!next.valid) throw new VerificationError(`unsafe_redirect:${next.reason}`);
-          trace.redirects.push({ from: url, to: next.url, status: response.status });
-          url = next.url;
-          // Validators were earned for the pre-redirect resource; the destination revalidates
-          // from scratch (see the conditional-header note in `request`).
-          revalidators = null;
-          continue;
-        }
-        if ([404, 410].includes(response.status)) {
-          cancelBody(response);
-          return { response, body: null };
-        }
-        if (response.status === 304) {
-          cancelBody(response);
-          if (!revalidators) throw new VerificationError('not_modified_without_baseline');
-          return { response, body: null, notModified: true,
-            validators: { etag: response.headers.get('etag') ?? revalidators.etag ?? null,
-              lastModified: response.headers.get('last-modified') ?? revalidators.lastModified ?? null } };
-        }
-        if (response.status !== 200) {
-          cancelBody(response);
-          // A 429 or a 503 may state WHEN to come back. We keep it and never act on it here:
-          // sleeping inside a request holds an origin lease and a worker for someone else's
-          // backoff, and this system already decided that **the cron is the sleep**. Surfacing it
-          // lets a scheduler re-queue at the stated time, the same way a robots crawl delay is
-          // handed to the scheduler rather than slept on.
-          throw new VerificationError(`source_http_${response.status}`,
-            retryAfterSeconds(response.headers.get('retry-after')) === null ? {}
-              : { retryAfterSeconds: retryAfterSeconds(response.headers.get('retry-after')) });
-        }
-        const contentType = response.headers.get('content-type') ?? '';
-        // The document gate admits the XML family (`application/xml`, `text/xml`,
-        // `application/rss+xml`, `application/atom+xml`) and plain text (the sitemap protocol's
-        // text format). It is still a gate: a feed URL serving HTML is a page wearing a feed's
-        // name, and parsing it as a feed would read markup as entries.
-        const expected = document ? /(?:[+/]xml|text\/plain)(?:\s*;|$)/iu : /^text\/html(?:;|$)/iu;
-        if (!expected.test(contentType)) {
-          cancelBody(response);
-          throw new VerificationError('unsupported_content_type');
-        }
-        const body = await readBounded(response, maxBytes, signal);
-        return { response, body, notModified: false,
-          validators: { etag: response.headers.get('etag'), lastModified: response.headers.get('last-modified') } };
-      }
-      throw new VerificationError('redirect_limit');
-    },
-  };
-}
+// Compatibility facade: every verifier and installed-package consumer shares the same
+// HTTP policy and error identity. Keep the legacy export names stable.
+export { VerificationError, readBounded, PRODUCT_TOKEN, MAX_RETRY_AFTER_SECONDS,
+  retryAfterSeconds, publicFetcher } from '../page-acquisition/http.js';