@astrasyncai/verification-gateway 3.12.0 → 4.1.0

package/dist/edge-core/index.mjs

@@ -0,0 +1,1437 @@
+// src/edge-config.ts
+var DEFAULT_EDGE_CONFIG = Object.freeze({
+  version: 1,
+  mode: "observe",
+  depth: "classify",
+  pathRules: [],
+  sampling: Object.freeze({ anonymousBeaconRate: 0.1 }),
+  failurePosture: "open"
+});
+var DEFAULT_TTL_MS = 60 * 1e3;
+var DEFAULT_MAX_STALE_MS = 24 * 60 * 60 * 1e3;
+function matchEdgePathRule(rules, path) {
+  for (const rule of rules) {
+    if (globToRegExp(rule.pattern).test(path)) return rule;
+  }
+  return void 0;
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+
+// src/metadata-capture.ts
+var CAPTURE_SCHEMA_VERSION = 1;
+var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "cookie",
+  "set-cookie",
+  "x-csrf-token",
+  "proxy-authorization",
+  "x-astrasync-signature",
+  "x-astrasync-secret",
+  "x-hub-signature",
+  "x-hub-signature-256"
+]);
+var SECRET_HEADER_PREFIXES = ["x-astrasync-", "kya-", "kya_"];
+var CREDENTIAL_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-api-key",
+  "x-goog-api-key",
+  "api-key"
+]);
+function isSignatureHeader(name) {
+  return name === "signature" || name.endsWith("-signature") || name.endsWith("-signature-256");
+}
+var PLATFORM_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "openai-organization",
+  "openai-project",
+  "openai-version",
+  "openai-processing-ms",
+  "anthropic-version",
+  "anthropic-beta",
+  "x-goog-user-project",
+  "x-goog-api-client",
+  "user-agent",
+  "x-agent-card-url",
+  "x-agent-provider"
+]);
+var PLATFORM_HEADER_PREFIXES = ["x-goog-", "x-stainless-", "x-anthropic-", "x-openai-"];
+var KEY_FORMAT_PREFIXES = [
+  "sk-ant-api03",
+  "sk-ant-api",
+  "sk-ant",
+  "sk-proj",
+  "sk-svcacct",
+  "sk-or-v1",
+  "sk-or",
+  "sk-lf",
+  "sk-",
+  "gsk_",
+  "aiza",
+  "ya29",
+  "ghp_",
+  "gho_",
+  "github_pat_",
+  "xai-",
+  "pplx-",
+  "r8_",
+  "hf_",
+  "astra-",
+  "astrae-"
+];
+var MAX_HEADERS = 64;
+var MAX_HEADER_VALUE_BYTES = 1024;
+var MAX_TOTAL_BYTES = 16 * 1024;
+function byteLength(s) {
+  let bytes = 0;
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319) {
+      bytes += 4;
+      i++;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function extractApiKeyFormat(rawValue) {
+  if (!rawValue) return void 0;
+  let value = rawValue.trim();
+  const spaceIdx = value.indexOf(" ");
+  if (spaceIdx > 0) {
+    const scheme = value.slice(0, spaceIdx).toLowerCase();
+    if (scheme === "bearer" || scheme === "basic" || scheme === "token") {
+      value = value.slice(spaceIdx + 1).trim();
+    }
+  }
+  const lower = value.toLowerCase();
+  for (const prefix of KEY_FORMAT_PREFIXES) {
+    if (lower.startsWith(prefix)) {
+      return prefix;
+    }
+  }
+  return void 0;
+}
+function isSecretHeader(name) {
+  if (SECRET_HEADER_NAMES.has(name)) return true;
+  if (SECRET_HEADER_PREFIXES.some((p) => name.startsWith(p))) return true;
+  if (isSignatureHeader(name)) return true;
+  return false;
+}
+function isPlatformHeader(name) {
+  if (PLATFORM_HEADER_NAMES.has(name)) return true;
+  return PLATFORM_HEADER_PREFIXES.some((p) => name.startsWith(p));
+}
+function sanitizeHeaders(raw) {
+  const headers = {};
+  const platformHeaders = {};
+  let apiKeyFormat;
+  let totalBytes = 0;
+  let count = 0;
+  if (!raw) return { headers };
+  for (const rawName of Object.keys(raw)) {
+    if (count >= MAX_HEADERS) break;
+    const name = rawName.toLowerCase();
+    const rawValue = raw[rawName];
+    if (rawValue === void 0) continue;
+    const joined = Array.isArray(rawValue) ? rawValue.join(", ") : String(rawValue);
+    if (CREDENTIAL_HEADER_NAMES.has(name)) {
+      const fmt = extractApiKeyFormat(joined);
+      if (fmt && !apiKeyFormat) apiKeyFormat = fmt;
+      continue;
+    }
+    if (isSecretHeader(name)) continue;
+    let value = joined;
+    if (byteLength(value) > MAX_HEADER_VALUE_BYTES) {
+      value = value.slice(0, MAX_HEADER_VALUE_BYTES);
+    }
+    const entryBytes = byteLength(name) + byteLength(value);
+    if (totalBytes + entryBytes > MAX_TOTAL_BYTES) continue;
+    totalBytes += entryBytes;
+    count++;
+    headers[name] = value;
+    if (isPlatformHeader(name)) platformHeaders[name] = value;
+  }
+  const result = { headers };
+  if (apiKeyFormat) result.apiKeyFormat = apiKeyFormat;
+  if (Object.keys(platformHeaders).length > 0) result.platformHeaders = platformHeaders;
+  return result;
+}
+
+// src/platform-signatures.ts
+var PLATFORM_AGENT_SIGNATURES = [
+  {
+    vendor: "claude",
+    displayName: "Anthropic Claude",
+    uaPatterns: [/claude/i, /anthropic/i],
+    agentCardPatterns: [/anthropic\.com/i, /claude\.ai/i],
+    apiKeyFormatPatterns: [/^sk-ant/i],
+    headerPatterns: [/^anthropic-version/i, /^anthropic-beta/i, /^x-anthropic-/i]
+  },
+  {
+    vendor: "chatgpt",
+    displayName: "OpenAI ChatGPT",
+    uaPatterns: [/chatgpt/i, /openai/i, /gpt-?\d/i],
+    agentCardPatterns: [/openai\.com/i, /chatgpt\.com/i],
+    apiKeyFormatPatterns: [/^sk-proj/i, /^sk-svcacct/i],
+    headerPatterns: [/^openai-organization/i, /^openai-project/i, /^openai-version/i]
+  },
+  {
+    vendor: "gemini",
+    displayName: "Google Gemini",
+    uaPatterns: [/gemini/i, /google-gemini/i, /bard/i],
+    agentCardPatterns: [/gemini\.google\.com/i, /ai\.google\.dev/i],
+    apiKeyFormatPatterns: [/^aiza/i],
+    headerPatterns: [/^x-goog-user-project/i, /^x-goog-api-client/i]
+  },
+  {
+    vendor: "cursor",
+    displayName: "Cursor",
+    uaPatterns: [/cursor/i],
+    agentCardPatterns: [/cursor\.sh/i, /cursor\.com/i]
+  },
+  {
+    vendor: "goose",
+    displayName: "Block Goose",
+    uaPatterns: [/goose/i, /block-goose/i],
+    agentCardPatterns: [/block\.xyz\/goose/i, /goose\.tools/i]
+  },
+  {
+    vendor: "perplexity",
+    displayName: "Perplexity",
+    uaPatterns: [/perplexity/i],
+    agentCardPatterns: [/perplexity\.ai/i],
+    apiKeyFormatPatterns: [/^pplx-/i]
+  }
+];
+function matchPlatformSignature(signatures, input) {
+  const ua = input.userAgent ?? "";
+  const cardUrl = input.agentCardUrl ?? "";
+  const apiKeyFormat = input.apiKeyFormat ?? "";
+  const headerLines = [];
+  if (input.platformHeaders) {
+    for (const [name, value] of Object.entries(input.platformHeaders)) {
+      headerLines.push(name, `${name}: ${value}`);
+    }
+  }
+  for (const sig of signatures) {
+    const uaMatch = sig.uaPatterns?.some((p) => p.test(ua));
+    const cardMatch = sig.agentCardPatterns?.some((p) => p.test(cardUrl));
+    const keyMatch = apiKeyFormat.length > 0 && sig.apiKeyFormatPatterns?.some((p) => p.test(apiKeyFormat));
+    const headerMatch = headerLines.length > 0 && sig.headerPatterns?.some((p) => headerLines.some((line) => p.test(line)));
+    if (uaMatch || cardMatch || keyMatch || headerMatch) {
+      const uaBase = ua.split(/[\s/]/)[0]?.toLowerCase() ?? "";
+      const cardHost = (() => {
+        try {
+          return cardUrl ? new URL(cardUrl).host : "";
+        } catch {
+          return "";
+        }
+      })();
+      const keyBasis = uaBase || cardHost || apiKeyFormat || "unknown";
+      return {
+        vendor: sig.vendor,
+        fingerprintKey: `${sig.vendor}:${keyBasis}`,
+        displayName: sig.displayName
+      };
+    }
+  }
+  return void 0;
+}
+function detectPlatformFingerprint(input) {
+  return matchPlatformSignature(PLATFORM_AGENT_SIGNATURES, input);
+}
+
+// src/access-levels.ts
+function getTrustLevel(score) {
+  if (score >= 80) return "PLATINUM";
+  if (score >= 60) return "GOLD";
+  if (score >= 40) return "SILVER";
+  return "BRONZE";
+}
+
+// src/version.ts
+var SDK_VERSION = "4.1.0";
+
+// src/well-known.ts
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function getCachedWellKnownUrls(apiBaseUrl) {
+  return cache.get(apiBaseUrl)?.data;
+}
+
+// src/verify.ts
+var DEFAULT_CONFIG = {
+  apiBaseUrl: "https://astrasync.ai/api",
+  // v2.3.9 (defect #30): default for unconfigured callers is `'none'` (no
+  // access). Pre-rename this defaulted to `'guidance'`, which combined with
+  // a route gated at `'guidance'` to silently let unverified traffic
+  // through (`hasMinimumAccess('guidance', 'guidance') === true`).
+  defaultAccessLevel: "none",
+  // minTrustScore + minTrustScoreForFull deprecated in v2.3.0 — server decides.
+  // cacheTtl deliberately unset. When undefined, cacheResult applies the 60s
+  // default; the caller's explicit value is honoured for cacheable results.
+  // Denials and step-up escalations are NEVER cached (3.6.0) regardless of
+  // cacheTtl. Set cacheTtl: 0 to disable caching entirely.
+  debug: false
+};
+var initCheckPerformed = false;
+var deprecationWarningShown = false;
+async function performInitCheck(apiBaseUrl, debug, strictInit, apiKey) {
+  initCheckPerformed = true;
+  try {
+    const probeUrl = `${apiBaseUrl}/agents/verify-access`;
+    const response = await fetch(probeUrl, { method: "HEAD" });
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.startsWith("text/html")) {
+      const message = `[VerificationGateway] apiBaseUrl '${apiBaseUrl}' returned HTML (content-type: ${contentType}). This usually means apiBaseUrl is pointing at a marketing site instead of the API. Expected: 'https://astrasync.ai/api' (prod) or 'https://staging.astrasync.ai/api' (staging).`;
+      if (strictInit) {
+        throw new Error(`${message} (strictInit=true)`);
+      }
+      console.warn(`${message} Set disableInitChecks: true on GatewayConfig to silence.`);
+    } else if (debug) {
+      console.log(
+        `[VerificationGateway] init check passed for ${apiBaseUrl} (content-type: ${contentType})`
+      );
+    }
+    if (apiKey) {
+      const selfCheck = await fetch(`${apiBaseUrl}/agents/verify-access/self-check`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (selfCheck.status === 401) {
+        const body = await selfCheck.json().catch(() => ({}));
+        const message = `[VerificationGateway] the configured AstraSync API key was REJECTED at startup (${body.code ?? "api_key_invalid"}: ${body.message ?? "invalid key"}). Every inbound agent will be turned away until the key is rotated` + (body.remediation?.manageUrl ? ` at ${body.remediation.manageUrl}` : "") + `.`;
+        if (strictInit) {
+          throw new Error(`${message} (strictInit=true)`);
+        }
+        console.error(message);
+      } else if (selfCheck.ok) {
+        const body = await selfCheck.json().catch(() => ({}));
+        if (typeof body.daysToExpiry === "number" && body.daysToExpiry <= 7) {
+          console.warn(
+            `[VerificationGateway] the configured AstraSync API key expires in ${body.daysToExpiry} day(s) \u2014 rotate it at Settings \u2192 Developer Tools before integrations start failing.`
+          );
+        } else if (debug) {
+          console.log("[VerificationGateway] API key self-check passed");
+        }
+      }
+    }
+  } catch (err) {
+    if (strictInit) {
+      throw err;
+    }
+    if (debug) {
+      console.log(`[VerificationGateway] init check failed (non-blocking): ${String(err)}`);
+    }
+  }
+}
+var verificationCache = /* @__PURE__ */ new Map();
+function getCacheKey(request, counterpartyId) {
+  const c = request.credentials;
+  return [
+    c.astraId || "",
+    c.apiKey || "",
+    c.jwt || "",
+    request.purpose || "",
+    request.action || "",
+    request.resourceType || "",
+    request.resource || "",
+    request.jurisdiction || "",
+    request.transactionValue ?? "",
+    request.currency || "",
+    // SECURITY (cross-merchant cache leak): the merchant identity is sent via
+    // `config.counterpartyId`, NOT on the request, so it was previously absent
+    // from the key — two verifies for the SAME agent/purpose/action/value but
+    // DIFFERENT merchants collided, and a grant at a permissive merchant (low
+    // trust floor) was served for a stricter one. Same bug class as the
+    // duration omission (F-A1-07). counterpartyId affects the backend verdict
+    // (trust floor / per-route policy), so it MUST key the cache.
+    counterpartyId || "",
+    request.counterpartyUrl || "",
+    request.counterpartyType || "",
+    request.isSubAgentRequest ? "1" : "0",
+    request.parentAgentId || "",
+    request.subAgentDepth ?? "",
+    // Audit F-A1-07: previously-missing dimensions that DO affect the
+    // backend verdict. Without these, two requests with different
+    // durations (e.g. 60s vs 86400s) collided on the same cache key and
+    // the shorter-duration allow served the longer-duration request.
+    request.durationRequired ?? "",
+    request.invocationProtocol || "",
+    request.enableRuntimeChallenge ? "1" : "0",
+    // callerMetadata fields contribute to risk model; include the ones
+    // backend reads. sourceIp/userAgent/forwardedFor change per-request
+    // so their inclusion effectively forces a re-check for any varying
+    // client (the right behavior — IP-driven anomaly scoring shouldn't
+    // be cached across IPs).
+    request.callerMetadata?.sourceIp || "",
+    request.callerMetadata?.userAgent || "",
+    request.callerMetadata?.forwardedFor || "",
+    request.callerMetadata?.agentCardUrl || ""
+  ].join("|");
+}
+function getCachedResult(request, counterpartyId) {
+  const key = getCacheKey(request, counterpartyId);
+  const cached = verificationCache.get(key);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.result;
+  }
+  if (cached) {
+    verificationCache.delete(key);
+  }
+  return null;
+}
+var DEFAULT_CACHE_TTL_SECONDS = 60;
+function cacheResult(request, result, configuredTtl, counterpartyId) {
+  const ttlSeconds = configuredTtl && configuredTtl > 0 ? configuredTtl : DEFAULT_CACHE_TTL_SECONDS;
+  const key = getCacheKey(request, counterpartyId);
+  verificationCache.set(key, {
+    result,
+    expiresAt: Date.now() + ttlSeconds * 1e3
+  });
+}
+function extractCredentials(headers, query) {
+  const credentials = {};
+  const ASTRA_ID_PATTERN = /^ASTRAE?-[A-Za-z0-9_-]{1,64}$/;
+  const astraIdHeader = headers["x-astra-id"] || headers["X-Astra-Id"] || headers["X-ASTRA-ID"] || headers["x-astra-agentid"] || headers["X-Astra-AgentId"] || headers["x-astra-agent-id"] || headers["X-Astra-Agent-Id"] || headers["X-ASTRA-AGENT-ID"];
+  if (astraIdHeader) {
+    const raw = Array.isArray(astraIdHeader) ? astraIdHeader[0] : typeof astraIdHeader === "string" ? astraIdHeader : void 0;
+    if (typeof raw === "string" && ASTRA_ID_PATTERN.test(raw)) {
+      credentials.astraId = raw;
+    }
+  }
+  const apiKeyHeader = headers["x-api-key"] || headers["X-Api-Key"] || headers["X-API-KEY"];
+  if (apiKeyHeader) {
+    credentials.apiKey = Array.isArray(apiKeyHeader) ? apiKeyHeader[0] : apiKeyHeader;
+  }
+  const authHeader = headers["authorization"] || headers["Authorization"];
+  if (authHeader) {
+    const authValue = Array.isArray(authHeader) ? authHeader[0] : authHeader;
+    if (typeof authValue === "string") {
+      credentials.authorizationHeader = authValue;
+      if (authValue.startsWith("Bearer ")) {
+        credentials.jwt = authValue.slice(7);
+      }
+    }
+  }
+  if (query) {
+    if (query.astraId && !credentials.astraId) {
+      credentials.astraId = query.astraId;
+    }
+    if (query.apiKey && !credentials.apiKey) {
+      credentials.apiKey = query.apiKey;
+    }
+  }
+  return credentials;
+}
+function createGuidanceResponse(_config, reason, options = {}) {
+  const source = options.source ?? "no_credentials";
+  const isApiError = source === "api_error";
+  const isMisconfig = source === "merchant_misconfig";
+  const urls = options.urls;
+  const guidance = isMisconfig ? {
+    message: "This site's AstraSync integration is misconfigured (its API key was revoked, expired, or rotated). Your identity and the AstraSync platform are fine \u2014 contact the site operator. Retrying will not help.",
+    registrationUrl: urls?.registrationUrl ?? "",
+    documentationUrl: options.remediation?.docsUrl ?? urls?.documentationUrl ?? "",
+    steps: [
+      "Report the failure to the site operator \u2014 their AstraSync API key needs rotating",
+      "Do not retry: the failure is deterministic until the operator updates their key"
+    ]
+  } : isApiError ? {
+    message: "Verification is temporarily unavailable. Retry with exponential backoff; if the issue persists, contact support with the correlationId.",
+    registrationUrl: urls?.registrationUrl ?? "",
+    documentationUrl: urls?.documentationUrl ?? "",
+    steps: [
+      "Retry the request with exponential backoff",
+      "If failures persist, share the correlationId with support"
+    ]
+  } : {
+    message: "This service verifies AI agents before granting access. Please register your agent with AstraSync.",
+    registrationUrl: urls?.registrationUrl ?? "",
+    documentationUrl: urls?.documentationUrl ?? "",
+    steps: [
+      "Register for an AstraSync account",
+      "Create and register your agent",
+      "Add your ASTRA-ID to request headers",
+      "Retry your request"
+    ]
+  };
+  return {
+    // Round-18 G4: createGuidanceResponse fires for unverified-agent path or
+    // API-error fallback. Identity is not verified (no agent resolved);
+    // policy is not evaluated (we never reached the gate).
+    identityVerified: false,
+    policyAllowed: false,
+    // v2.3.9 (defect #30): denials grant `'none'`, NEVER a positive band.
+    // Adapters additionally short-circuit on `!identityVerified ||
+    // !policyAllowed` before the gate check, but the access level still has
+    // to be honest at the data layer so downstream consumers (SDK adapters
+    // in other languages, custom integrations) inherit the correct
+    // semantics.
+    accessLevel: "none",
+    guidance,
+    denialReasons: reason ? [reason] : ["No valid agent credentials provided"],
+    // Round-10 (#47, O5): on API-error fallback, surface a typed failure so
+    // partners (and their custom onDenied handlers) can branch on
+    // dimension. Without this, the synthesised stub was indistinguishable
+    // from a real policy deny.
+    failures: isMisconfig ? [
+      {
+        dimension: "verify_access.merchant_misconfigured",
+        message: reason ?? "The integration API key was rejected by AstraSync",
+        guidance: guidance.message
+      }
+    ] : isApiError ? [
+      {
+        dimension: "verify_access.api_error",
+        message: reason ?? "Verification temporarily unavailable",
+        guidance: guidance.message
+      }
+    ] : void 0,
+    // 4.0.0: typed marker so adapters render the misconfig envelope (503 +
+    // MERCHANT_VERIFICATION_MISCONFIGURED) without string-matching.
+    ...isMisconfig && { misconfigured: true },
+    correlationId: options.correlationId,
+    attemptId: options.attemptId,
+    verifiedAt: /* @__PURE__ */ new Date()
+  };
+}
+async function callVerifyAccessAPI(config, request) {
+  const { credentials, ...requestData } = request;
+  const body = {
+    ...credentials.astraId && { agentId: credentials.astraId },
+    ...requestData.purpose && { purpose: requestData.purpose }
+  };
+  if (requestData.action) body.action = requestData.action;
+  if (requestData.resourceType) body.resourceType = requestData.resourceType;
+  if (requestData.resource) body.resource = requestData.resource;
+  if (requestData.jurisdiction) body.jurisdiction = requestData.jurisdiction;
+  if (requestData.transactionValue) body.transactionValue = requestData.transactionValue;
+  if (requestData.currency) body.currency = requestData.currency;
+  if (requestData.isSubAgentRequest) body.isSubAgentRequest = requestData.isSubAgentRequest;
+  if (requestData.parentAgentId) body.parentAgentId = requestData.parentAgentId;
+  if (requestData.subAgentDepth !== void 0) body.subAgentDepth = requestData.subAgentDepth;
+  if (requestData.enableRuntimeChallenge)
+    body.enableRuntimeChallenge = requestData.enableRuntimeChallenge;
+  if (requestData.createSession) body.createSession = requestData.createSession;
+  if (requestData.durationRequired) body.durationRequired = requestData.durationRequired;
+  if (requestData.counterpartyType) body.counterpartyType = requestData.counterpartyType;
+  if (requestData.counterpartyUrl) body.counterpartyUrl = requestData.counterpartyUrl;
+  if (config.counterpartyId) body.counterpartyId = config.counterpartyId;
+  if (requestData.runtimeChallengeOptions)
+    body.runtimeChallengeOptions = requestData.runtimeChallengeOptions;
+  if (requestData.invocationProtocol) body.invocationProtocol = requestData.invocationProtocol;
+  if (requestData.commerceArtifacts) body.commerceArtifacts = requestData.commerceArtifacts;
+  if (requestData.attemptId) body.attemptId = requestData.attemptId;
+  if (requestData.considerationSet) body.considerationSet = requestData.considerationSet;
+  body.sdkVersion = SDK_VERSION;
+  if (requestData.callerMetadata || requestData.clientIp || requestData.userAgent) {
+    const meta = {
+      ...requestData.clientIp && { sourceIp: requestData.clientIp },
+      ...requestData.userAgent && { userAgent: requestData.userAgent },
+      ...requestData.callerMetadata
+    };
+    if (Object.keys(meta).length > 0) body.callerMetadata = meta;
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.customHeaders
+  };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+    headers["X-API-Key"] = config.apiKey;
+  }
+  try {
+    const response = await fetch(`${config.apiBaseUrl}/agents/verify-access`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(config.verifyTimeoutMs ?? 1e4)
+    });
+    const data = await response.json();
+    if (response.status === 410) {
+      return {
+        success: true,
+        // 3.12.0 (Trust Record): keep the server-echoed attempt handle even on
+        // the synthesised 410 deny shape (echoed on every branch).
+        attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0,
+        access: {
+          allowed: false,
+          accessLevel: "none",
+          reason: "endpoint_deactivated",
+          failures: [
+            {
+              dimension: "endpoint.deactivated",
+              message: typeof data?.message === "string" ? data.message : "Endpoint has been deactivated",
+              guidance: typeof data?.guidance === "string" ? data.guidance : "Reactivate via POST /api/endpoints/{id}/reactivate, or update the URL on the calling agent."
+            }
+          ]
+        }
+      };
+    }
+    if (!response.ok) {
+      if (response.status === 401) {
+        return {
+          success: false,
+          error: data.message || data.error || "Integration API key rejected",
+          misconfig: true,
+          misconfigCode: typeof data?.code === "string" ? data.code : void 0,
+          remediation: data?.remediation && typeof data.remediation === "object" ? data.remediation : void 0,
+          correlationId: typeof data?.correlationId === "string" ? data.correlationId : void 0,
+          attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0
+        };
+      }
+      return {
+        success: false,
+        error: data.message || data.error || `API returned ${response.status}`,
+        correlationId: typeof data?.correlationId === "string" ? data.correlationId : void 0,
+        attemptId: typeof data?.attemptId === "string" ? data.attemptId : void 0
+      };
+    }
+    return data;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      error: `Failed to call verify-access API: ${message}`
+    };
+  }
+}
+async function verify(config, request, options) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const urls = mergedConfig.apiBaseUrl ? getCachedWellKnownUrls(mergedConfig.apiBaseUrl) : void 0;
+  if (!initCheckPerformed && !mergedConfig.disableInitChecks && mergedConfig.apiBaseUrl) {
+    if (mergedConfig.strictInit) {
+      await performInitCheck(
+        mergedConfig.apiBaseUrl,
+        mergedConfig.debug,
+        true,
+        mergedConfig.apiKey
+      );
+    } else {
+      void performInitCheck(
+        mergedConfig.apiBaseUrl,
+        mergedConfig.debug,
+        false,
+        mergedConfig.apiKey
+      );
+    }
+  }
+  if (!deprecationWarningShown && (config.minTrustScore !== void 0 || config.minTrustScoreForFull !== void 0)) {
+    deprecationWarningShown = true;
+    console.warn(
+      "[VerificationGateway] minTrustScore / minTrustScoreForFull are deprecated in v2.3.0 and have no effect. Server is now the single source of truth for access-level decisions (the SDK reads access.accessLevel from the verify-access response). To gate access to an endpoint, configure the endpoint's trust_score_requirement server-side."
+    );
+  }
+  if (mergedConfig.cacheTtl !== 0 && !options?.bypassCache) {
+    const cached = getCachedResult(request, mergedConfig.counterpartyId);
+    if (cached) {
+      if (mergedConfig.debug) {
+        console.log("[VerificationGateway] Returning cached result");
+      }
+      const hit = { ...cached };
+      if (request.attemptId) {
+        hit.attemptId = request.attemptId;
+      } else {
+        delete hit.attemptId;
+      }
+      return hit;
+    }
+  }
+  const enrichedRequest = { ...request };
+  if (!enrichedRequest.counterpartyUrl && mergedConfig.counterpartyUrl) {
+    enrichedRequest.counterpartyUrl = mergedConfig.counterpartyUrl;
+  }
+  if (!enrichedRequest.counterpartyType && mergedConfig.counterpartyType) {
+    enrichedRequest.counterpartyType = mergedConfig.counterpartyType;
+  }
+  if (mergedConfig.debug) {
+    console.log("[VerificationGateway] Calling verify-access API");
+  }
+  const apiResponse = await callVerifyAccessAPI(mergedConfig, enrichedRequest);
+  const rawServerDenialReasons = apiResponse.denialReasons;
+  const serverDenialReasons = Array.isArray(rawServerDenialReasons) && rawServerDenialReasons.length > 0 ? rawServerDenialReasons : void 0;
+  if (!apiResponse.success) {
+    return createGuidanceResponse(mergedConfig, apiResponse.error, {
+      source: apiResponse.misconfig ? "merchant_misconfig" : "api_error",
+      correlationId: apiResponse.correlationId,
+      attemptId: apiResponse.attemptId,
+      remediation: apiResponse.remediation,
+      urls
+    });
+  }
+  if (!apiResponse.access?.allowed) {
+    const aggregatedFailures = apiResponse.access?.failures;
+    const idVerifiedFromBackend = apiResponse.verificationContext?.idVerified === true;
+    const result2 = {
+      identityVerified: idVerifiedFromBackend,
+      policyAllowed: false,
+      // v2.3.9 (defect #30): denials grant `'none'`, NEVER a positive band.
+      // Pre-rename this hardcoded `'guidance'`, which conflated with the
+      // colocated `guidance: {...}` help-payload object below and let
+      // denied requests pass any route gated at `'guidance'` because
+      // `hasMinimumAccess('guidance', 'guidance') === true`. Adapters now
+      // ALSO short-circuit on `!identityVerified || !policyAllowed` before
+      // the gate check — belt-and-braces.
+      accessLevel: "none",
+      // 3.6.0: the server now emits top-level denialReasons on every deny
+      // path — prefer it verbatim; the failure-message reconstruction remains
+      // as the fallback for older backends.
+      denialReasons: serverDenialReasons ?? (aggregatedFailures && aggregatedFailures.length > 0 ? aggregatedFailures.map((f) => f.message) : apiResponse.access?.reason ? [apiResponse.access.reason] : ["Access denied"]),
+      failures: aggregatedFailures,
+      requiresStepUp: apiResponse.access?.requiresStepUp,
+      requiresApproval: apiResponse.access?.requiresApproval,
+      guidance: {
+        message: apiResponse.access?.reason || "Access denied by PDLSS policy",
+        registrationUrl: urls?.registrationUrl ?? "",
+        documentationUrl: urls?.documentationUrl ?? ""
+      },
+      verifiedAt: /* @__PURE__ */ new Date(),
+      // Extract sessionId so decisions can be recorded for denials too
+      sessionId: apiResponse.sessionId,
+      // Anonymous traffic has no session → correlationId is the per-attempt
+      // linking key (the sessionId-equivalent for anonymous callers).
+      correlationId: apiResponse.correlationId,
+      // 3.12.0 (Trust Record): server echoes the attempt-chain handle on
+      // every branch — denials included (the funnel outlives one deny).
+      attemptId: apiResponse.attemptId,
+      recommendation: apiResponse.recommendation,
+      recommendationReasons: apiResponse.recommendationReasons,
+      stepUpApproval: apiResponse.stepUpApproval,
+      settlement: apiResponse.settlement
+    };
+    return result2;
+  }
+  const agent = apiResponse.agent ? {
+    astraId: apiResponse.agent.astraId,
+    name: apiResponse.agent.name,
+    trustScore: apiResponse.agent.trustScore,
+    trustLevel: getTrustLevel(apiResponse.agent.trustScore),
+    blockchainVerified: apiResponse.agent.blockchainStatus === "verified",
+    status: apiResponse.agent.agentStatus
+  } : void 0;
+  const developer = apiResponse.developer ? {
+    astradId: apiResponse.developer.kyaOwnerId,
+    name: apiResponse.developer.fullName,
+    trustScore: apiResponse.developer.trustScore || 0,
+    verified: apiResponse.developer.identityVerified
+  } : void 0;
+  const organization = apiResponse.organization ? {
+    name: apiResponse.organization.name,
+    verified: apiResponse.organization.verified,
+    trustScore: apiResponse.organization.trustScore
+  } : void 0;
+  const verificationContext = apiResponse.verificationContext;
+  const accessLevel = apiResponse.access?.accessLevel ?? "standard";
+  const result = {
+    // Round-18 G4: backend allowed access. Identity is verified (we resolved
+    // the caller to an agent) and policy passed all gates. Read idVerified
+    // from verificationContext for symmetry with the deny branch; default true
+    // on success path since `access.allowed === true` implies identity was
+    // resolvable (anonymous-allow paths flow through createGuidanceResponse).
+    identityVerified: apiResponse.verificationContext?.idVerified !== false,
+    policyAllowed: true,
+    accessLevel,
+    agent,
+    developer,
+    organization,
+    appliedPolicy: apiResponse.access?.appliedPolicy,
+    verificationContext,
+    requiresStepUp: apiResponse.access?.requiresStepUp,
+    requiresApproval: apiResponse.access?.requiresApproval,
+    verifiedAt: /* @__PURE__ */ new Date(),
+    cacheTtl: mergedConfig.cacheTtl,
+    // Handshake Protocol v10 enhanced fields (present when backend returns them)
+    sessionId: apiResponse.sessionId,
+    // v2.3.10 (defect #34, round-4): anonymous responses surface correlationId
+    // (no session row exists for unverified callers).
+    correlationId: apiResponse.correlationId,
+    // 3.12.0 (Trust Record): server-echoed attempt-chain handle.
+    attemptId: apiResponse.attemptId,
+    runtimeChallenge: apiResponse.runtimeChallenge,
+    tokenGuidance: apiResponse.tokenGuidance,
+    recommendation: apiResponse.recommendation,
+    recommendationReasons: apiResponse.recommendationReasons,
+    warningHeader: apiResponse.warningHeader,
+    stepUpApproval: apiResponse.stepUpApproval,
+    settlement: apiResponse.settlement
+  };
+  if (result.recommendation === "deny") {
+    result.policyAllowed = false;
+    result.accessLevel = "none";
+    result.denialReasons = serverDenialReasons ?? result.recommendationReasons ?? ["Access denied by AstraSync recommendation"];
+    result.guidance = result.runtimeChallenge ? {
+      message: `Verification failed: ${result.runtimeChallenge.reason || "runtime challenge failed"}`,
+      registrationUrl: urls?.registrationUrl ?? "",
+      documentationUrl: urls?.documentationUrl ?? ""
+    } : {
+      message: result.recommendationReasons?.[0] || "Access denied by AstraSync recommendation",
+      registrationUrl: urls?.registrationUrl ?? "",
+      documentationUrl: urls?.documentationUrl ?? ""
+    };
+  } else if (result.recommendation === "step_up_required") {
+    result.requiresStepUp = true;
+    result.denialReasons = serverDenialReasons ?? result.recommendationReasons ?? ["Step-up verification required"];
+  }
+  const escalates = result.requiresStepUp === true || result.requiresApproval === true || result.recommendation === "step_up_required";
+  if (mergedConfig.cacheTtl !== 0 && result.recommendation !== "deny" && !escalates) {
+    cacheResult(request, result, mergedConfig.cacheTtl, mergedConfig.counterpartyId);
+  }
+  return result;
+}
+async function reportUnregisteredAttempt(config, data) {
+  const apiBaseUrl = config.apiBaseUrl || DEFAULT_CONFIG.apiBaseUrl;
+  const { counterpartyUrl, ...rest } = data;
+  const body = {
+    ...rest,
+    ...counterpartyUrl && { counterpartyUrl },
+    ...config.counterpartyId && { counterpartyId: config.counterpartyId }
+  };
+  await fetch(`${apiBaseUrl}/verification-activity/unregistered-attempt`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  }).catch(() => {
+  });
+}
+
+// src/edge-core/request.ts
+function headerValue(req, name) {
+  return req.headers[name.toLowerCase()];
+}
+function requestUrl(req, host) {
+  const qs = req.querystring ? `?${req.querystring}` : "";
+  return `https://${host}${req.uri}${qs}`;
+}
+function buildObservedMetadata(req) {
+  const { headers, apiKeyFormat, platformHeaders } = sanitizeHeaders(req.headers);
+  const connection = req.connection ?? {};
+  return {
+    headers,
+    ...apiKeyFormat && { apiKeyFormat },
+    ...platformHeaders && { platformHeaders },
+    ...Object.keys(connection).length > 0 && { connection },
+    schemaVersion: CAPTURE_SCHEMA_VERSION
+  };
+}
+
+// src/edge-core/detect.ts
+var SD_JWT_PATTERN = /^eyJ[\w-]+\.[\w-]*\.[\w-]+~/;
+function decodeBase64Url(seg) {
+  const b64 = seg.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+function sniffJwtHeader(compact) {
+  try {
+    const seg = compact.split(".")[0];
+    return JSON.parse(decodeBase64Url(seg));
+  } catch {
+    return void 0;
+  }
+}
+function parseJsonBody(bodyText) {
+  if (!bodyText) return void 0;
+  try {
+    const parsed = JSON.parse(bodyText);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectCommerce(req, host) {
+  const url = requestUrl(req, host);
+  const method = req.method;
+  const headers = req.headers;
+  const jsonBody = parseJsonBody(req.bodyText);
+  const truncated = req.bodyTruncated ? { bodyTruncated: true } : {};
+  const authHeader = headerValue(req, "authorization");
+  const bearer = authHeader?.replace(/^Bearer\s+/i, "");
+  const mandateHeader = headerValue(req, "x-payment-mandate") ?? headerValue(req, "payment-mandate");
+  const sdJwtCandidate = [mandateHeader, bearer].find((v) => v && SD_JWT_PATTERN.test(v));
+  if (sdJwtCandidate) {
+    const typ = sniffJwtHeader(sdJwtCandidate)?.typ;
+    return {
+      protocol: "vi-sd-jwt",
+      artifacts: { viSdJwt: sdJwtCandidate },
+      evidence: { typ, ...truncated }
+    };
+  }
+  const signature = headerValue(req, "signature");
+  const signatureInput = headerValue(req, "signature-input");
+  if (signature && signatureInput) {
+    const signatureAgent = headerValue(req, "signature-agent");
+    const registryHint = headerValue(req, "x-agent-registry");
+    const lowerInput = signatureInput.toLowerCase();
+    const protocol = signatureAgent ? "rfc9421-web-bot-auth" : registryHint?.toLowerCase().includes("visa") || lowerInput.includes("visa") ? "rfc9421-tap" : registryHint?.toLowerCase().includes("mastercard") || lowerInput.includes("mastercard") ? "rfc9421-agent-pay" : "rfc9421";
+    return {
+      protocol,
+      artifacts: {
+        rfc9421: { headers, method, url, ...req.bodyText && { body: req.bodyText } }
+      },
+      evidence: {
+        ...signatureAgent && { signatureAgent },
+        ...registryHint && { registryHint },
+        keyid: signatureInput.match(/keyid="([^"]+)"/)?.[1],
+        ...truncated
+      }
+    };
+  }
+  const acpTimestamp = headerValue(req, "timestamp");
+  if (signature && !signatureInput && (acpTimestamp || headerValue(req, "idempotency-key"))) {
+    return {
+      protocol: "acp",
+      artifacts: {
+        acpRequest: {
+          method,
+          url,
+          headers,
+          ...req.bodyText && { rawBody: req.bodyText },
+          ...jsonBody && { body: jsonBody }
+        }
+      },
+      evidence: { hasTimestamp: Boolean(acpTimestamp), ...truncated }
+    };
+  }
+  if (/\/checkout[-_]sessions(\/|$)/.test(req.uri)) {
+    return {
+      protocol: "ucp",
+      artifacts: { ucpRequest: { method, url, ...jsonBody && { body: jsonBody } } },
+      evidence: { path: req.uri, ...truncated }
+    };
+  }
+  if (jsonBody) {
+    const intent = jsonBody.intent_mandate ?? jsonBody.intentMandate;
+    const cart = jsonBody.cart_mandate ?? jsonBody.cartMandate;
+    const payment = jsonBody.payment_mandate ?? jsonBody.paymentMandate;
+    if (typeof intent === "string" || typeof cart === "string" || typeof payment === "string") {
+      return {
+        protocol: "ap2",
+        artifacts: {
+          ap2Mandates: {
+            ...typeof intent === "string" && { intent },
+            ...typeof cart === "string" && { cart },
+            ...typeof payment === "string" && { payment }
+          }
+        },
+        evidence: {
+          mandatesPresent: [
+            typeof intent === "string" && "intent",
+            typeof cart === "string" && "cart",
+            typeof payment === "string" && "payment"
+          ].filter(Boolean),
+          ...truncated
+        }
+      };
+    }
+  }
+  if (authHeader && /^Payment\s+/i.test(authHeader)) {
+    return {
+      protocol: "mpp",
+      artifacts: {
+        mppRequest: {
+          method,
+          url,
+          headers,
+          ...req.bodyText && { rawBody: req.bodyText },
+          ...jsonBody && { body: jsonBody }
+        }
+      },
+      evidence: truncated
+    };
+  }
+  if (headerValue(req, "x-payment")) {
+    return {
+      protocol: "x402",
+      artifacts: {
+        x402Request: { method, url, headers, ...jsonBody && { body: jsonBody } }
+      },
+      evidence: truncated
+    };
+  }
+  return void 0;
+}
+
+// src/edge-core/classify.ts
+var STATIC_EXTENSIONS = /\.(css|js|mjs|map|png|jpe?g|gif|webp|avif|svg|ico|woff2?|ttf|otf|eot|mp4|webm|pdf|txt|xml)$/i;
+var BOT_UA_PATTERN = /curl|wget|python-requests|python-urllib|node-fetch|axios|got|okhttp|go-http-client|libwww|httpie|java\/|ruby|php|scrapy|headless|phantomjs|selenium|playwright|puppeteer|bot|crawler|spider|slurp/i;
+var BROWSER_UA_PATTERN = /mozilla\/\d/i;
+function resolvePolicy(config, path) {
+  if (STATIC_EXTENSIONS.test(path)) {
+    return { mode: config.mode, depth: config.depth, skip: true };
+  }
+  const rule = matchEdgePathRule(config.pathRules, path);
+  if (!rule) return { mode: config.mode, depth: config.depth, skip: false };
+  return {
+    mode: rule.mode ?? config.mode,
+    depth: rule.depth ?? config.depth,
+    skip: rule.skip === true
+  };
+}
+function classify(req, host, depth) {
+  const userAgent = headerValue(req, "user-agent") ?? "";
+  const credentials = extractCredentials(req.headers, {});
+  if (credentials.astraId || credentials.apiKey || credentials.jwt) {
+    return { tier: "verified", protocol: "x-astra" };
+  }
+  const { apiKeyFormat, platformHeaders } = sanitizeHeaders(req.headers);
+  const detectionInput = { userAgent, apiKeyFormat, platformHeaders };
+  if (depth !== "classify") {
+    const commerce = detectCommerce(req, host);
+    if (commerce) {
+      return {
+        tier: "identified",
+        protocol: commerce.protocol,
+        artifacts: commerce.artifacts,
+        evidence: commerce.evidence,
+        fingerprint: detectPlatformFingerprint(detectionInput)
+      };
+    }
+  }
+  const fingerprint = detectPlatformFingerprint(detectionInput);
+  if (fingerprint) {
+    return { tier: "identified", protocol: "platform-ua", fingerprint };
+  }
+  if (!userAgent || BOT_UA_PATTERN.test(userAgent) || !BROWSER_UA_PATTERN.test(userAgent)) {
+    return { tier: "anonymous-bot", evidence: { userAgent: userAgent || "(none)" } };
+  }
+  if (!headerValue(req, "sec-fetch-mode") && !headerValue(req, "accept-language")) {
+    return { tier: "anonymous-bot", evidence: { userAgent, spoofedBrowser: true } };
+  }
+  return { tier: "human" };
+}
+var _patterns = { STATIC_EXTENSIONS, BOT_UA_PATTERN, BROWSER_UA_PATTERN };
+
+// src/edge-core/messaging.ts
+var PROTOCOL_MESSAGES = {
+  "vi-sd-jwt": "This request presented Visa Intelligent Commerce credentials, but the agent is not verified with AstraSync. Register the agent to pair your VI credentials with a verified identity and mandate.",
+  "rfc9421-agent-pay": "This request carried a Mastercard Agent Pay signature, but the agent is not verified with AstraSync. Register the agent to pair Agent Pay credentials with a verified identity and mandate.",
+  "rfc9421-tap": "This request carried a Visa TAP signature, but the agent is not verified with AstraSync. Register the agent to pair TAP credentials with a verified identity and mandate.",
+  "rfc9421-web-bot-auth": "This request carried a Web Bot Auth signature, but the agent is not verified with AstraSync. Register the agent to link your signed-agent identity to a verified principal.",
+  rfc9421: "This request carried an RFC 9421 HTTP message signature, but the agent is not verified with AstraSync. Register the agent to link the signing identity to a verified principal.",
+  acp: "This request used the Agentic Commerce Protocol, but the agent is not verified with AstraSync. Register the agent to transact on this property.",
+  ucp: "This request used a UCP checkout session, but the agent is not verified with AstraSync. Register the agent to transact on this property.",
+  ap2: "This request presented AP2 mandates, but the agent is not verified with AstraSync. Register the agent to pair your mandates with a verified identity.",
+  mpp: "This request presented MPP payment credentials, but the agent is not verified with AstraSync. Register the agent to transact on this property.",
+  x402: "This request used x402 payment headers, but the agent is not verified with AstraSync. Register the agent to transact on this property.",
+  "platform-ua": "This traffic was identified as a platform AI agent without AstraSync credentials. Register the agent to access this property with a verified identity.",
+  "x-astra": "The presented AstraSync credentials failed verification or were denied by this property\u2019s access policy."
+};
+function buildDenyBody(outcome, apiBaseUrl) {
+  const origin = apiBaseUrl.replace(/\/api\/?$/, "");
+  const protocolMessage = (outcome.protocol && PROTOCOL_MESSAGES[outcome.protocol]) ?? "This request could not be verified by AstraSync.";
+  return {
+    success: false,
+    error: {
+      // UNAUTHORIZED = identity failed (register/re-authenticate helps);
+      // INSUFFICIENT_ACCESS = identity fine, policy denied (fix the mandate).
+      code: outcome.tier === "verified" ? "INSUFFICIENT_ACCESS" : "UNAUTHORIZED",
+      message: protocolMessage,
+      ...outcome.protocol && { protocol: outcome.protocol },
+      failures: outcome.reasons,
+      ...outcome.correlationId && { correlationId: outcome.correlationId },
+      guidance: {
+        // `||` not `??`: verify() fills these with EMPTY STRINGS when the
+        // well-known cache is cold — empty means "use the fallback".
+        message: outcome.guidance?.message || "Register this agent with AstraSync to receive verifiable credentials.",
+        registrationUrl: outcome.guidance?.registrationUrl || `${origin}/register`,
+        documentationUrl: outcome.guidance?.documentationUrl || `${origin}/docs/edge-adapter`
+      }
+    }
+  };
+}
+function buildManualReviewBody(outcome) {
+  return {
+    success: false,
+    status: "manual_review",
+    message: "This action requires human approval. Poll the step-up approval endpoint and retry once approved.",
+    ...outcome.stepUp && { stepUpApproval: outcome.stepUp },
+    ...outcome.correlationId && { correlationId: outcome.correlationId }
+  };
+}
+
+// src/edge-core/enforce.ts
+var ASAT_HEADERS = {
+  trustScore: "X-AstraSync-Trust-Score",
+  agentId: "X-AstraSync-Agent-Id",
+  developerId: "X-AstraSync-Developer-Id",
+  permissions: "X-AstraSync-Permissions",
+  observedDecision: "X-AstraSync-Observed-Decision"
+};
+function passUntouched() {
+  return { action: "pass", injectHeaders: {}, stripHeaderPrefixes: [] };
+}
+function applyOutcome(options, outcome, policy) {
+  const injectHeaders = {};
+  if (outcome.misconfig) {
+    injectHeaders[ASAT_HEADERS.observedDecision] = "misconfig";
+  }
+  if (policy.mode !== "enforce") {
+    if (outcome.decision !== "allow") {
+      injectHeaders[ASAT_HEADERS.observedDecision] = outcome.decision;
+    }
+    Object.assign(injectHeaders, asatHeaders(outcome));
+    return { action: "pass", injectHeaders, stripHeaderPrefixes: ["x-astrasync-"] };
+  }
+  switch (outcome.decision) {
+    case "deny":
+      return {
+        action: "respond",
+        status: 403,
+        headers: {},
+        bodyJson: buildDenyBody(outcome, options.apiBaseUrl)
+      };
+    case "manual_review":
+      return {
+        action: "respond",
+        status: 202,
+        headers: { "Retry-After": "30" },
+        bodyJson: buildManualReviewBody(outcome)
+      };
+    default:
+      Object.assign(injectHeaders, asatHeaders(outcome));
+      return { action: "pass", injectHeaders, stripHeaderPrefixes: ["x-astrasync-"] };
+  }
+}
+function asatHeaders(outcome) {
+  if (!outcome.asat) return {};
+  const { trustScore, agentId, developerId, accessLevel } = outcome.asat;
+  return {
+    ...trustScore !== void 0 && { [ASAT_HEADERS.trustScore]: String(trustScore) },
+    ...agentId && { [ASAT_HEADERS.agentId]: agentId },
+    ...developerId && { [ASAT_HEADERS.developerId]: developerId },
+    ...accessLevel && { [ASAT_HEADERS.permissions]: accessLevel }
+  };
+}
+
+// src/adapters/http-pdlss.ts
+var HTTP_METHOD_ACTION_TABLE = {
+  GET: "data.read",
+  HEAD: "data.read",
+  OPTIONS: "data.read",
+  POST: "data.write",
+  PUT: "data.write",
+  PATCH: "data.write",
+  DELETE: "data.delete"
+};
+var DEFAULT_HTTP_ACTION = "data.write";
+var DEFAULT_HTTP_PURPOSE = "data";
+function actionForHttpMethod(method) {
+  return HTTP_METHOD_ACTION_TABLE[method.toUpperCase()] ?? DEFAULT_HTTP_ACTION;
+}
+function normalizePurposeHeader(value) {
+  const colon = value.indexOf(":");
+  if (colon >= 0) {
+    return { purpose: value.slice(0, colon) };
+  }
+  const dot = value.indexOf(".");
+  if (dot > 0 && dot < value.length - 1) {
+    return { purpose: value.slice(0, dot), actionCandidate: value };
+  }
+  return { purpose: value };
+}
+function resolveHttpPdlss(input) {
+  const fromHeader = input.astraPurpose ? normalizePurposeHeader(input.astraPurpose) : void 0;
+  let action;
+  let actionSource;
+  if (input.routeAction) {
+    action = input.routeAction;
+    actionSource = "route_config";
+  } else if (input.hasCustomActionExtractor && input.customAction) {
+    action = input.customAction;
+    actionSource = "custom_extractor";
+  } else if (!input.hasCustomActionExtractor && input.astraAction) {
+    action = input.astraAction;
+    actionSource = "header";
+  } else if (!input.hasCustomActionExtractor && fromHeader?.actionCandidate) {
+    action = fromHeader.actionCandidate;
+    actionSource = "purpose_header_derived";
+  } else {
+    action = actionForHttpMethod(input.method);
+    actionSource = "method_table";
+  }
+  let purpose;
+  let purposeSource;
+  if (input.routePurpose) {
+    purpose = input.routePurpose;
+    purposeSource = "route_config";
+  } else if (input.hasCustomPurposeExtractor) {
+    if (input.customPurpose) {
+      purpose = input.customPurpose;
+      purposeSource = "custom_extractor";
+    }
+  } else if (fromHeader) {
+    purpose = fromHeader.purpose;
+    purposeSource = "header";
+  } else if (input.legacyPurpose) {
+    purpose = input.legacyPurpose;
+    purposeSource = "legacy_header";
+  } else if (input.queryPurpose) {
+    purpose = input.queryPurpose;
+    purposeSource = "query";
+  }
+  if (!purpose) {
+    const dot = action.indexOf(".");
+    if (dot > 0) {
+      purpose = action.slice(0, dot);
+      purposeSource = "action_derived";
+    } else {
+      purpose = DEFAULT_HTTP_PURPOSE;
+      purposeSource = "transport_default";
+    }
+  }
+  return { purpose, action, purposeSource, actionSource };
+}
+
+// src/edge-core/events.ts
+async function withBudget(promise, ms) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(void 0), ms);
+      })
+    ]);
+  } catch {
+    return void 0;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function emitBeacon(options, req, classification, budgetMs) {
+  const budgeted = withBudget(
+    reportUnregisteredAttempt(
+      { apiBaseUrl: options.apiBaseUrl, counterpartyId: options.counterpartyId },
+      {
+        counterpartyUrl: options.counterpartyUrl,
+        counterpartyType: "website",
+        sourceIp: req.clientIp,
+        userAgent: headerValue(req, "user-agent"),
+        requestPath: req.uri,
+        requestMethod: req.method,
+        // Evidence fields the backend persists into the event record.
+        protocol: classification.protocol,
+        evidence: classification.evidence,
+        // The full sanitized header + connection capture for the
+        // unregistered caller (fire-and-forget, so free).
+        observedMetadata: buildObservedMetadata(req)
+      }
+    ),
+    budgetMs
+  );
+  if (options.waitUntil) {
+    options.waitUntil(budgeted);
+    return;
+  }
+  await budgeted;
+}
+function sampled(rate, random = Math.random) {
+  if (rate <= 0) return false;
+  if (rate >= 1) return true;
+  return random() < rate;
+}
+
+// src/edge-core/pipeline.ts
+function baseOutcome(classification) {
+  return {
+    tier: classification.tier,
+    decision: "allow",
+    reasons: [],
+    protocol: classification.protocol
+  };
+}
+function buildVerificationRequest(options, req, classification, includeArtifacts) {
+  const pdlss = resolveHttpPdlss({
+    method: req.method,
+    astraPurpose: headerValue(req, "x-astra-purpose"),
+    astraAction: headerValue(req, "x-astra-action")
+  });
+  const attemptId = headerValue(req, "x-astra-attempt-id");
+  return {
+    ...attemptId && /^att_[0-9a-f]{32}$/.test(attemptId) && { attemptId },
+    credentials: extractCredentials(req.headers, {}),
+    purpose: pdlss.purpose,
+    action: pdlss.action,
+    resource: req.uri,
+    createSession: true,
+    counterpartyType: "website",
+    counterpartyUrl: options.counterpartyUrl,
+    callerMetadata: {
+      sourceIp: req.clientIp,
+      userAgent: headerValue(req, "user-agent"),
+      referer: headerValue(req, "referer"),
+      host: headerValue(req, "host"),
+      // The full sanitized header + connection capture. The backend stores
+      // it fire-and-forget (zero decision latency) and uses the key-format
+      // / platform headers for attribution.
+      observedMetadata: buildObservedMetadata(req)
+    },
+    ...includeArtifacts && classification.artifacts && { commerceArtifacts: classification.artifacts }
+  };
+}
+function outcomeFromVerifyResult(classification, result) {
+  const outcome = baseOutcome(classification);
+  outcome.sessionId = result.sessionId;
+  outcome.correlationId = result.correlationId;
+  outcome.guidance = result.guidance;
+  if (result.misconfigured) {
+    outcome.reasons = ["verification key misconfigured \u2014 fail-open (merchant_misconfig)"];
+    outcome.misconfig = true;
+    return outcome;
+  }
+  if (result.requiresStepUp || result.stepUpApproval) {
+    outcome.decision = "manual_review";
+    outcome.reasons = ["step-up approval required"];
+    outcome.stepUp = {
+      pollUrl: result.stepUpApproval?.pollUrl,
+      expiresAt: result.stepUpApproval?.expiresAt
+    };
+    return outcome;
+  }
+  if (!result.identityVerified || !result.policyAllowed) {
+    outcome.decision = "deny";
+    outcome.reasons = result.denialReasons?.length ? result.denialReasons : [!result.identityVerified ? "identity not verified" : "denied by access policy"];
+    return outcome;
+  }
+  outcome.asat = {
+    trustScore: result.agent?.trustScore,
+    agentId: result.agent?.astraId,
+    developerId: result.developer?.astradId,
+    accessLevel: result.accessLevel
+  };
+  return outcome;
+}
+async function runTier(options, req, classification, policy, apiKey, sampling) {
+  const budgets = options.budgets ?? {};
+  const beaconMs = budgets.beaconMs ?? 300;
+  const verifyMs = policy.mode === "enforce" ? budgets.verifyEnforceMs ?? 3e3 : budgets.verifyObserveMs ?? 1500;
+  const gatewayConfig = {
+    apiBaseUrl: options.apiBaseUrl,
+    ...apiKey && { apiKey },
+    counterpartyId: options.counterpartyId,
+    // The gateway handles its own error semantics; init self-probes don't
+    // belong in a per-request edge function.
+    disableInitChecks: true
+  };
+  try {
+    switch (classification.tier) {
+      case "verified": {
+        if (policy.depth === "classify") {
+          return baseOutcome(classification);
+        }
+        const result = await withBudget(
+          verify(
+            gatewayConfig,
+            buildVerificationRequest(options, req, classification, policy.depth === "authorize")
+          ),
+          verifyMs
+        );
+        if (!result) {
+          const outcome = baseOutcome(classification);
+          outcome.reasons = ["verify-access unreachable within budget \u2014 fail-open"];
+          return outcome;
+        }
+        return outcomeFromVerifyResult(classification, result);
+      }
+      case "identified": {
+        if (policy.depth === "authorize" && classification.artifacts) {
+          const result = await withBudget(
+            verify(gatewayConfig, buildVerificationRequest(options, req, classification, true)),
+            verifyMs
+          );
+          if (!result) {
+            const outcome2 = baseOutcome(classification);
+            outcome2.reasons = ["verify-access unreachable within budget \u2014 fail-open"];
+            return outcome2;
+          }
+          return outcomeFromVerifyResult(classification, result);
+        }
+        await emitBeacon(options, req, classification, beaconMs);
+        const outcome = baseOutcome(classification);
+        if (policy.mode === "enforce" && policy.depth !== "classify") {
+          outcome.decision = "deny";
+          outcome.reasons = ["agent is not registered with AstraSync"];
+        }
+        return outcome;
+      }
+      case "anonymous-bot": {
+        if (sampled(sampling.anonymousBeaconRate, options.random)) {
+          await emitBeacon(
+            options,
+            req,
+            { ...classification, protocol: classification.protocol ?? "ua-heuristic" },
+            beaconMs
+          );
+        }
+        return baseOutcome(classification);
+      }
+      default:
+        return baseOutcome(classification);
+    }
+  } catch (err) {
+    const outcome = baseOutcome(classification);
+    outcome.reasons = [
+      `edge pipeline error \u2014 fail-open: ${err instanceof Error ? err.message : String(err)}`
+    ];
+    return outcome;
+  }
+}
+
+// src/edge-core/evaluate.ts
+async function evaluateEdgeRequest(options, req, config, apiKey) {
+  const policy = resolvePolicy(config, req.uri);
+  try {
+    if (policy.skip) return { policy, application: passUntouched() };
+    const host = headerValue(req, "x-forwarded-host") ?? headerValue(req, "host") ?? new URL(options.counterpartyUrl).host;
+    const classification = classify(req, host, policy.depth);
+    if (classification.tier === "human") {
+      return { policy, classification, application: passUntouched() };
+    }
+    const outcome = await runTier(options, req, classification, policy, apiKey, config.sampling);
+    if (outcome.decision !== "allow") {
+      options.log?.(
+        "info",
+        policy.mode === "enforce" ? `${outcome.decision.toUpperCase()}: ${req.method} ${req.uri}` : `[OBSERVE] would have been ${outcome.decision.toUpperCase()}: ${req.method} ${req.uri}`,
+        { tier: outcome.tier, protocol: outcome.protocol, reasons: outcome.reasons }
+      );
+    }
+    return {
+      policy,
+      classification,
+      outcome,
+      application: applyOutcome(options, outcome, policy)
+    };
+  } catch (err) {
+    options.log?.("error", "edge evaluation error \u2014 passing request through", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { policy, application: passUntouched() };
+  }
+}
+export {
+  ASAT_HEADERS,
+  _patterns,
+  applyOutcome,
+  buildDenyBody,
+  buildManualReviewBody,
+  buildObservedMetadata,
+  buildVerificationRequest,
+  classify,
+  detectCommerce,
+  emitBeacon,
+  evaluateEdgeRequest,
+  headerValue,
+  outcomeFromVerifyResult,
+  passUntouched,
+  requestUrl,
+  resolvePolicy,
+  runTier,
+  sampled,
+  withBudget
+};
+//# sourceMappingURL=index.mjs.map