@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/identity-3.3/lifecycle.js

@@ -0,0 +1,294 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lifecycle_exports = {};
+__export(lifecycle_exports, {
+  InMemoryOriginIdentityStore: () => InMemoryOriginIdentityStore,
+  OriginIdentityLifecycle: () => OriginIdentityLifecycle,
+  evaluateOnboardingRequirements: () => evaluateOnboardingRequirements,
+  validateAgentOnboarding: () => validateAgentOnboarding
+});
+module.exports = __toCommonJS(lifecycle_exports);
+var import_crypto = require("crypto");
+var import_tldts = require("tldts");
+var import_canonicalize = require('../signing/agent-resolver/canonicalize.js');
+var import_etld = require('../signing/agent-resolver/etld.js');
+var import_trust = require('./trust.js');
+class InMemoryOriginIdentityStore {
+  durability = "process-local";
+  bindings = /* @__PURE__ */ new Map();
+  applications = /* @__PURE__ */ new Map();
+  async getBinding(origin) {
+    const value = this.bindings.get((0, import_canonicalize.canonicalAgentOrigin)(origin));
+    return value && structuredClone(value);
+  }
+  async bind(binding) {
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(binding.origin);
+    if (origin !== binding.origin || !binding.principalId || !binding.audit.approvedBy || !binding.audit.reason || !Number.isFinite(Date.parse(binding.audit.approvedAt)))
+      throw new TypeError("Explicit bindings require canonical origin and audit evidence");
+    const existing = this.bindings.get(origin);
+    if (existing && JSON.stringify(existing) !== JSON.stringify(binding)) throw new import_trust.IdentityAuthorizationError();
+    this.bindings.set(origin, structuredClone(binding));
+  }
+  async bindOpen(binding, maxPerOperator) {
+    const existing = this.bindings.get(binding.origin);
+    if (existing) throw new import_trust.IdentityAuthorizationError();
+    if (!binding.openAccess || !Number.isInteger(maxPerOperator) || maxPerOperator < 1 || [...this.bindings.values()].filter((b) => b.operator === binding.operator && b.openAccess).length >= maxPerOperator)
+      throw new import_trust.IdentityAuthorizationError();
+    await this.bind(binding);
+    return structuredClone(binding);
+  }
+  async getApplication(origin) {
+    const value = this.applications.get((0, import_canonicalize.canonicalAgentOrigin)(origin));
+    return value && structuredClone(value);
+  }
+  async compareAndSetApplication(origin, expectedRevision, application) {
+    origin = (0, import_canonicalize.canonicalAgentOrigin)(origin);
+    if (this.applications.get(origin)?.revision !== expectedRevision || application.revision !== (expectedRevision ?? 0) + 1)
+      return false;
+    this.applications.set(origin, structuredClone(application));
+    return true;
+  }
+}
+const BUYER_GATES = /* @__PURE__ */ new Set(["aao_verified", "storyboard", "sandbox", "experimental_feature"]);
+const SELLER_GATES = /* @__PURE__ */ new Set([
+  "agent_identity",
+  "grant",
+  "billing_entity",
+  "contract",
+  "credit_application"
+]);
+async function evaluateOnboardingRequirements(requirements, direction, check) {
+  const relevant = direction === "seller" ? SELLER_GATES : BUYER_GATES;
+  const wrong = direction === "seller" ? BUYER_GATES : SELLER_GATES;
+  const unsatisfied = [];
+  for (const requirement of requirements) {
+    if (wrong.has(requirement.kind)) continue;
+    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!(requirement.verified_specialisms ?? requirement.specialisms)?.length && !!requirement.adcp_version;
+    const hasId = !["storyboard", "experimental_feature"].includes(requirement.kind) || !!requirement.id;
+    if (!relevant.has(requirement.kind) || !wellFormed || !hasId || !await check(requirement))
+      unsatisfied.push(requirement);
+  }
+  return { satisfied: !unsatisfied.length, unsatisfied };
+}
+function validateAgentOnboarding(posture, account, experimentalFeatures) {
+  if (!(0, import_trust.validateIdentity33Schema)("core/agent-onboarding", posture) || !experimentalFeatures.includes("account.agent_onboarding") || posture.sandbox && account.sandbox !== true || Object.keys(posture.billing ?? {}).some((k) => !account.supported_billing?.includes(k)))
+    throw new TypeError("Invalid experimental agent onboarding posture");
+}
+class OriginIdentityLifecycle {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /** Identity-established origins get no durable identifier. Reads never create. */
+  async getPrincipal(originUrl) {
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    const binding = await this.options.store.getBinding(origin);
+    const application = await this.options.store.getApplication(origin);
+    return {
+      ...binding ? { binding } : {},
+      result: {
+        kind: binding ? "recognized" : "unconfigured",
+        ...binding ? { principal_id: binding.principalId, principal_kind: binding.principalKind ?? "buyer_agent" } : {},
+        ...application ? { relationship: application.relationship } : {}
+      }
+    };
+  }
+  async bindPrincipal(input) {
+    if (input.principalKind !== void 0 && !["buyer_agent", "operator"].includes(input.principalKind) || input.sharedOrigin || input.existingRfcPrincipal && input.migrationApproved !== true)
+      throw new import_trust.IdentityAuthorizationError();
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(input.origin);
+    const legacy = await this.options.lookupLegacyPrincipals?.(origin);
+    if (legacy && (legacy.length > 1 || legacy.length === 1 && (legacy[0] !== input.principalId || !input.migrationApproved)))
+      throw new import_trust.IdentityAuthorizationError();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    const binding = {
+      origin,
+      operator: trust.operator,
+      principalId: input.principalId,
+      ...input.principalKind && { principalKind: input.principalKind },
+      audit: {
+        approvedBy: input.approvedBy,
+        reason: input.reason,
+        approvedAt: new Date(this.now() * 1e3).toISOString(),
+        ...input.migrationApproved ? { migrationApproved: true } : {}
+      }
+    };
+    await this.options.store.bind(binding);
+    return binding;
+  }
+  /**
+   * Cryptographic verification does not call this. Authorization revalidates
+   * delisting: the last record read does not list the origin (an empty
+   * `agents[]` retires it; a known delisting stays delisted through a failed
+   * refresh) and throws {@link TrustMembershipError}. An unreadable record
+   * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+   * read-only and identity-configuration calls continue under the binding only
+   * while the last record read listed the origin and is within the evaluator's
+   * `maxOutageContinuationSeconds`.
+   */
+  async authorizeBound(originUrl, access) {
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    const binding = await this.options.store.getBinding(origin);
+    if (!binding) throw new import_trust.IdentityAuthorizationError();
+    try {
+      let trust;
+      try {
+        trust = await this.options.trust.match(origin, "adcp:buying");
+      } catch (error) {
+        if (error instanceof import_trust.TrustMembershipError && error.membership === "absent")
+          throw Object.assign(new import_trust.TrustRecordUnavailableError(), { cause: error });
+        throw error;
+      }
+      if (binding.operator !== trust.operator) throw new import_trust.TrustMembershipError();
+    } catch (error) {
+      if (!(error instanceof import_trust.TrustRecordUnavailableError) || !error.lastKnownListed || !(access?.readOnly || access?.identityConfiguration))
+        throw error;
+    }
+    const relationship = (await this.options.store.getApplication(origin))?.relationship;
+    if (!access?.readOnly && relationship && (relationship.status !== "active" || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
+      throw new import_trust.IdentityAuthorizationError();
+    if (binding.openAccess && !access) throw new import_trust.IdentityAuthorizationError();
+    if (binding.openAccess && access && !access.readOnly && !access.identityConfiguration) {
+      if (access.sandbox) {
+        if (!binding.openAccess.sandbox) throw new import_trust.IdentityAuthorizationError();
+      } else {
+        if (!access.billing || access.billing === "agent" || !binding.openAccess.billing?.includes(access.billing))
+          throw new import_trust.IdentityAuthorizationError();
+        const billedParty = access.billing === "operator" ? binding.operator : access.brandDomain && (0, import_etld.eTldPlusOne)(access.brandDomain);
+        if (!billedParty || !await this.options.hasBillingRelationship?.(billedParty, access.billing))
+          throw new import_trust.IdentityAuthorizationError();
+      }
+    }
+    return binding;
+  }
+  /** Called by explicit sync_principal only; allocates new identities, never migrates existing ones. */
+  async syncOpen(originUrl, options) {
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    if (![this.options.onboarding?.sandbox, ...Object.values(this.options.onboarding?.billing ?? {})].some(
+      (tier) => tier?.mode === "open"
+    ))
+      throw new import_trust.IdentityAuthorizationError();
+    if (await this.options.store.getBinding(origin)) throw new import_trust.IdentityAuthorizationError();
+    if (!this.options.lookupLegacyPrincipals || (await this.options.lookupLegacyPrincipals(origin)).length)
+      throw new import_trust.IdentityAuthorizationError();
+    const relationship = (await this.options.store.getApplication(origin))?.relationship;
+    if (relationship && (["blocked", "suspended"].includes(relationship.status) || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
+      throw new import_trust.IdentityAuthorizationError();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    const privateSuffix = (0, import_tldts.parse)(new URL(origin).hostname, { allowPrivateDomains: true }).isPrivate;
+    const access = {};
+    const eligible = async (tier) => tier?.mode === "open" && (await evaluateOnboardingRequirements(
+      tier.requirements ?? [],
+      "seller",
+      (req) => this.options.checkRequirement?.(origin, req) ?? Promise.resolve(false)
+    )).satisfied;
+    if (await eligible(this.options.onboarding?.sandbox)) access.sandbox = true;
+    if (!privateSuffix) {
+      for (const billing of ["operator", "advertiser"])
+        if (await eligible(this.options.onboarding?.billing?.[billing])) (access.billing ??= []).push(billing);
+    }
+    if (!access.sandbox && !access.billing?.length) throw new import_trust.IdentityAuthorizationError();
+    const binding = {
+      origin,
+      operator: trust.operator,
+      principalId: (0, import_crypto.randomUUID)(),
+      openAccess: access,
+      audit: {
+        approvedBy: "open-onboarding-policy",
+        reason: "new principal for declared open tiers",
+        approvedAt: new Date(this.now() * 1e3).toISOString()
+      }
+    };
+    if (options?.dryRun) return binding;
+    return this.options.store.bindOpen(binding, this.options.maxOpenPrincipalsPerOperator ?? 10);
+  }
+  async setRelationship(originUrl, relationship) {
+    if (!(0, import_trust.validateIdentity33Schema)("core/principal-relationship", relationship))
+      throw new TypeError("Invalid relationship");
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      const prior = await this.options.store.getApplication(origin);
+      if (prior && JSON.stringify(prior.relationship) === JSON.stringify(relationship)) {
+        await this.flushRelationshipNotifications(origin);
+        return;
+      }
+      if (await this.options.store.compareAndSetApplication(origin, prior?.revision, {
+        relationship: structuredClone(relationship),
+        revision: (prior?.revision ?? 0) + 1,
+        ...prior?.relationship.expires_at === relationship.expires_at && prior?.expiryNotified ? { expiryNotified: prior.expiryNotified } : {},
+        pendingNotifications: [
+          ...prior?.pendingNotifications ?? [],
+          { id: (0, import_crypto.randomUUID)(), reason: "relationship_changed" }
+        ]
+      })) {
+        await this.flushRelationshipNotifications(origin);
+        return;
+      }
+    }
+    throw new import_trust.IdentityAuthorizationError();
+  }
+  async notifyRelationshipExpiring(originUrl, leadSeconds) {
+    if (!Number.isFinite(leadSeconds) || leadSeconds < 0) throw new TypeError("Invalid expiry lead time");
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    await this.flushRelationshipNotifications(origin);
+    const prior = await this.options.store.getApplication(origin);
+    const expires = prior?.relationship.expires_at;
+    if (!prior || !expires || prior.expiryNotified === expires || Date.parse(expires) / 1e3 - this.now() > leadSeconds || Date.parse(expires) / 1e3 <= this.now())
+      return false;
+    if (!await this.options.store.compareAndSetApplication(origin, prior.revision, {
+      ...prior,
+      revision: prior.revision + 1,
+      expiryNotified: expires,
+      pendingNotifications: [
+        ...prior.pendingNotifications ?? [],
+        { id: (0, import_crypto.randomUUID)(), reason: "relationship_expiring" }
+      ]
+    }))
+      return false;
+    await this.flushRelationshipNotifications(origin);
+    return true;
+  }
+  async flushRelationshipNotifications(originUrl) {
+    if (!this.options.notify) return;
+    const origin = (0, import_canonicalize.canonicalAgentOrigin)(originUrl);
+    for (let attempt = 0; attempt < 100; attempt++) {
+      const prior = await this.options.store.getApplication(origin), notification = prior?.pendingNotifications?.[0];
+      if (!prior || !notification) return;
+      await this.options.notify(origin, notification.reason, notification.id);
+      await this.options.store.compareAndSetApplication(origin, prior.revision, {
+        ...prior,
+        revision: prior.revision + 1,
+        pendingNotifications: prior.pendingNotifications.slice(1)
+      });
+    }
+  }
+  async assertLegacyAllowed(agentUrl) {
+    if (await this.options.store.getBinding((0, import_canonicalize.canonicalAgentOrigin)(agentUrl))) throw new import_trust.IdentityAuthorizationError();
+  }
+  now() {
+    return (this.options.now ?? (() => Date.now() / 1e3))();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InMemoryOriginIdentityStore,
+  OriginIdentityLifecycle,
+  evaluateOnboardingRequirements,
+  validateAgentOnboarding
+});

package/dist/lib/identity-3.3/lifecycle.mjs

@@ -0,0 +1,272 @@
+import { randomUUID } from "crypto";
+import { parse as parseTld } from "tldts";
+import { canonicalAgentOrigin } from "../signing/agent-resolver/canonicalize.mjs";
+import { eTldPlusOne } from "../signing/agent-resolver/etld.mjs";
+import {
+  IdentityAuthorizationError,
+  TrustMembershipError,
+  TrustRecordUnavailableError,
+  validateIdentity33Schema
+} from "./trust.mjs";
+class InMemoryOriginIdentityStore {
+  durability = "process-local";
+  bindings = /* @__PURE__ */ new Map();
+  applications = /* @__PURE__ */ new Map();
+  async getBinding(origin) {
+    const value = this.bindings.get(canonicalAgentOrigin(origin));
+    return value && structuredClone(value);
+  }
+  async bind(binding) {
+    const origin = canonicalAgentOrigin(binding.origin);
+    if (origin !== binding.origin || !binding.principalId || !binding.audit.approvedBy || !binding.audit.reason || !Number.isFinite(Date.parse(binding.audit.approvedAt)))
+      throw new TypeError("Explicit bindings require canonical origin and audit evidence");
+    const existing = this.bindings.get(origin);
+    if (existing && JSON.stringify(existing) !== JSON.stringify(binding)) throw new IdentityAuthorizationError();
+    this.bindings.set(origin, structuredClone(binding));
+  }
+  async bindOpen(binding, maxPerOperator) {
+    const existing = this.bindings.get(binding.origin);
+    if (existing) throw new IdentityAuthorizationError();
+    if (!binding.openAccess || !Number.isInteger(maxPerOperator) || maxPerOperator < 1 || [...this.bindings.values()].filter((b) => b.operator === binding.operator && b.openAccess).length >= maxPerOperator)
+      throw new IdentityAuthorizationError();
+    await this.bind(binding);
+    return structuredClone(binding);
+  }
+  async getApplication(origin) {
+    const value = this.applications.get(canonicalAgentOrigin(origin));
+    return value && structuredClone(value);
+  }
+  async compareAndSetApplication(origin, expectedRevision, application) {
+    origin = canonicalAgentOrigin(origin);
+    if (this.applications.get(origin)?.revision !== expectedRevision || application.revision !== (expectedRevision ?? 0) + 1)
+      return false;
+    this.applications.set(origin, structuredClone(application));
+    return true;
+  }
+}
+const BUYER_GATES = /* @__PURE__ */ new Set(["aao_verified", "storyboard", "sandbox", "experimental_feature"]);
+const SELLER_GATES = /* @__PURE__ */ new Set([
+  "agent_identity",
+  "grant",
+  "billing_entity",
+  "contract",
+  "credit_application"
+]);
+async function evaluateOnboardingRequirements(requirements, direction, check) {
+  const relevant = direction === "seller" ? SELLER_GATES : BUYER_GATES;
+  const wrong = direction === "seller" ? BUYER_GATES : SELLER_GATES;
+  const unsatisfied = [];
+  for (const requirement of requirements) {
+    if (wrong.has(requirement.kind)) continue;
+    const wellFormed = requirement.kind !== "aao_verified" || !!requirement.role && !!requirement.verification_modes?.length && !!(requirement.verified_specialisms ?? requirement.specialisms)?.length && !!requirement.adcp_version;
+    const hasId = !["storyboard", "experimental_feature"].includes(requirement.kind) || !!requirement.id;
+    if (!relevant.has(requirement.kind) || !wellFormed || !hasId || !await check(requirement))
+      unsatisfied.push(requirement);
+  }
+  return { satisfied: !unsatisfied.length, unsatisfied };
+}
+function validateAgentOnboarding(posture, account, experimentalFeatures) {
+  if (!validateIdentity33Schema("core/agent-onboarding", posture) || !experimentalFeatures.includes("account.agent_onboarding") || posture.sandbox && account.sandbox !== true || Object.keys(posture.billing ?? {}).some((k) => !account.supported_billing?.includes(k)))
+    throw new TypeError("Invalid experimental agent onboarding posture");
+}
+class OriginIdentityLifecycle {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /** Identity-established origins get no durable identifier. Reads never create. */
+  async getPrincipal(originUrl) {
+    const origin = canonicalAgentOrigin(originUrl);
+    const binding = await this.options.store.getBinding(origin);
+    const application = await this.options.store.getApplication(origin);
+    return {
+      ...binding ? { binding } : {},
+      result: {
+        kind: binding ? "recognized" : "unconfigured",
+        ...binding ? { principal_id: binding.principalId, principal_kind: binding.principalKind ?? "buyer_agent" } : {},
+        ...application ? { relationship: application.relationship } : {}
+      }
+    };
+  }
+  async bindPrincipal(input) {
+    if (input.principalKind !== void 0 && !["buyer_agent", "operator"].includes(input.principalKind) || input.sharedOrigin || input.existingRfcPrincipal && input.migrationApproved !== true)
+      throw new IdentityAuthorizationError();
+    const origin = canonicalAgentOrigin(input.origin);
+    const legacy = await this.options.lookupLegacyPrincipals?.(origin);
+    if (legacy && (legacy.length > 1 || legacy.length === 1 && (legacy[0] !== input.principalId || !input.migrationApproved)))
+      throw new IdentityAuthorizationError();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    const binding = {
+      origin,
+      operator: trust.operator,
+      principalId: input.principalId,
+      ...input.principalKind && { principalKind: input.principalKind },
+      audit: {
+        approvedBy: input.approvedBy,
+        reason: input.reason,
+        approvedAt: new Date(this.now() * 1e3).toISOString(),
+        ...input.migrationApproved ? { migrationApproved: true } : {}
+      }
+    };
+    await this.options.store.bind(binding);
+    return binding;
+  }
+  /**
+   * Cryptographic verification does not call this. Authorization revalidates
+   * delisting: the last record read does not list the origin (an empty
+   * `agents[]` retires it; a known delisting stays delisted through a failed
+   * refresh) and throws {@link TrustMembershipError}. An unreadable record
+   * (404/410 included) throws {@link TrustRecordUnavailableError} for spend;
+   * read-only and identity-configuration calls continue under the binding only
+   * while the last record read listed the origin and is within the evaluator's
+   * `maxOutageContinuationSeconds`.
+   */
+  async authorizeBound(originUrl, access) {
+    const origin = canonicalAgentOrigin(originUrl);
+    const binding = await this.options.store.getBinding(origin);
+    if (!binding) throw new IdentityAuthorizationError();
+    try {
+      let trust;
+      try {
+        trust = await this.options.trust.match(origin, "adcp:buying");
+      } catch (error) {
+        if (error instanceof TrustMembershipError && error.membership === "absent")
+          throw Object.assign(new TrustRecordUnavailableError(), { cause: error });
+        throw error;
+      }
+      if (binding.operator !== trust.operator) throw new TrustMembershipError();
+    } catch (error) {
+      if (!(error instanceof TrustRecordUnavailableError) || !error.lastKnownListed || !(access?.readOnly || access?.identityConfiguration))
+        throw error;
+    }
+    const relationship = (await this.options.store.getApplication(origin))?.relationship;
+    if (!access?.readOnly && relationship && (relationship.status !== "active" || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
+      throw new IdentityAuthorizationError();
+    if (binding.openAccess && !access) throw new IdentityAuthorizationError();
+    if (binding.openAccess && access && !access.readOnly && !access.identityConfiguration) {
+      if (access.sandbox) {
+        if (!binding.openAccess.sandbox) throw new IdentityAuthorizationError();
+      } else {
+        if (!access.billing || access.billing === "agent" || !binding.openAccess.billing?.includes(access.billing))
+          throw new IdentityAuthorizationError();
+        const billedParty = access.billing === "operator" ? binding.operator : access.brandDomain && eTldPlusOne(access.brandDomain);
+        if (!billedParty || !await this.options.hasBillingRelationship?.(billedParty, access.billing))
+          throw new IdentityAuthorizationError();
+      }
+    }
+    return binding;
+  }
+  /** Called by explicit sync_principal only; allocates new identities, never migrates existing ones. */
+  async syncOpen(originUrl, options) {
+    const origin = canonicalAgentOrigin(originUrl);
+    if (![this.options.onboarding?.sandbox, ...Object.values(this.options.onboarding?.billing ?? {})].some(
+      (tier) => tier?.mode === "open"
+    ))
+      throw new IdentityAuthorizationError();
+    if (await this.options.store.getBinding(origin)) throw new IdentityAuthorizationError();
+    if (!this.options.lookupLegacyPrincipals || (await this.options.lookupLegacyPrincipals(origin)).length)
+      throw new IdentityAuthorizationError();
+    const relationship = (await this.options.store.getApplication(origin))?.relationship;
+    if (relationship && (["blocked", "suspended"].includes(relationship.status) || relationship.expires_at && Date.parse(relationship.expires_at) <= this.now() * 1e3))
+      throw new IdentityAuthorizationError();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    const privateSuffix = parseTld(new URL(origin).hostname, { allowPrivateDomains: true }).isPrivate;
+    const access = {};
+    const eligible = async (tier) => tier?.mode === "open" && (await evaluateOnboardingRequirements(
+      tier.requirements ?? [],
+      "seller",
+      (req) => this.options.checkRequirement?.(origin, req) ?? Promise.resolve(false)
+    )).satisfied;
+    if (await eligible(this.options.onboarding?.sandbox)) access.sandbox = true;
+    if (!privateSuffix) {
+      for (const billing of ["operator", "advertiser"])
+        if (await eligible(this.options.onboarding?.billing?.[billing])) (access.billing ??= []).push(billing);
+    }
+    if (!access.sandbox && !access.billing?.length) throw new IdentityAuthorizationError();
+    const binding = {
+      origin,
+      operator: trust.operator,
+      principalId: randomUUID(),
+      openAccess: access,
+      audit: {
+        approvedBy: "open-onboarding-policy",
+        reason: "new principal for declared open tiers",
+        approvedAt: new Date(this.now() * 1e3).toISOString()
+      }
+    };
+    if (options?.dryRun) return binding;
+    return this.options.store.bindOpen(binding, this.options.maxOpenPrincipalsPerOperator ?? 10);
+  }
+  async setRelationship(originUrl, relationship) {
+    if (!validateIdentity33Schema("core/principal-relationship", relationship))
+      throw new TypeError("Invalid relationship");
+    const origin = canonicalAgentOrigin(originUrl);
+    for (let attempt = 0; attempt < 5; attempt++) {
+      const prior = await this.options.store.getApplication(origin);
+      if (prior && JSON.stringify(prior.relationship) === JSON.stringify(relationship)) {
+        await this.flushRelationshipNotifications(origin);
+        return;
+      }
+      if (await this.options.store.compareAndSetApplication(origin, prior?.revision, {
+        relationship: structuredClone(relationship),
+        revision: (prior?.revision ?? 0) + 1,
+        ...prior?.relationship.expires_at === relationship.expires_at && prior?.expiryNotified ? { expiryNotified: prior.expiryNotified } : {},
+        pendingNotifications: [
+          ...prior?.pendingNotifications ?? [],
+          { id: randomUUID(), reason: "relationship_changed" }
+        ]
+      })) {
+        await this.flushRelationshipNotifications(origin);
+        return;
+      }
+    }
+    throw new IdentityAuthorizationError();
+  }
+  async notifyRelationshipExpiring(originUrl, leadSeconds) {
+    if (!Number.isFinite(leadSeconds) || leadSeconds < 0) throw new TypeError("Invalid expiry lead time");
+    const origin = canonicalAgentOrigin(originUrl);
+    await this.flushRelationshipNotifications(origin);
+    const prior = await this.options.store.getApplication(origin);
+    const expires = prior?.relationship.expires_at;
+    if (!prior || !expires || prior.expiryNotified === expires || Date.parse(expires) / 1e3 - this.now() > leadSeconds || Date.parse(expires) / 1e3 <= this.now())
+      return false;
+    if (!await this.options.store.compareAndSetApplication(origin, prior.revision, {
+      ...prior,
+      revision: prior.revision + 1,
+      expiryNotified: expires,
+      pendingNotifications: [
+        ...prior.pendingNotifications ?? [],
+        { id: randomUUID(), reason: "relationship_expiring" }
+      ]
+    }))
+      return false;
+    await this.flushRelationshipNotifications(origin);
+    return true;
+  }
+  async flushRelationshipNotifications(originUrl) {
+    if (!this.options.notify) return;
+    const origin = canonicalAgentOrigin(originUrl);
+    for (let attempt = 0; attempt < 100; attempt++) {
+      const prior = await this.options.store.getApplication(origin), notification = prior?.pendingNotifications?.[0];
+      if (!prior || !notification) return;
+      await this.options.notify(origin, notification.reason, notification.id);
+      await this.options.store.compareAndSetApplication(origin, prior.revision, {
+        ...prior,
+        revision: prior.revision + 1,
+        pendingNotifications: prior.pendingNotifications.slice(1)
+      });
+    }
+  }
+  async assertLegacyAllowed(agentUrl) {
+    if (await this.options.store.getBinding(canonicalAgentOrigin(agentUrl))) throw new IdentityAuthorizationError();
+  }
+  now() {
+    return (this.options.now ?? (() => Date.now() / 1e3))();
+  }
+}
+export {
+  InMemoryOriginIdentityStore,
+  OriginIdentityLifecycle,
+  evaluateOnboardingRequirements,
+  validateAgentOnboarding
+};

package/dist/lib/identity-3.3/revocation.d.mts

@@ -0,0 +1,86 @@
+import { type JWK } from 'jose';
+import { type SsrfFetchOptions } from '../net/index.mjs';
+import type { RevocationDetail } from './types.mjs';
+export interface OriginRevocationSnapshot {
+    issuer: string;
+    updated: string;
+    next_update: string;
+    revoked_kids: string[];
+    revoked_jtis?: string[];
+    revocation_details?: Record<string, RevocationDetail>;
+}
+export interface MonotonicOriginRevocationStore {
+    /** Merge atomically and persist forever. Never replace with a new snapshot. */
+    merge(origin: string, snapshot: OriginRevocationSnapshot): Promise<void>;
+    get(origin: string, keyid: string): Promise<RevocationDetail | undefined>;
+}
+/**
+ * Process-local revocation history for development and tests. Public
+ * deployments need durable history (`createIdentity33StateStores`) so a
+ * restart never forgets a revocation.
+ *
+ * Capacity is bounded per origin, per operator (registrable domain) and in
+ * total. The operator budget stops one registrable domain's wildcard
+ * subdomains from filling the store alone; it does not reserve capacity for
+ * anyone else, so several operators together can still exhaust the total.
+ * Facts are never evicted to regain capacity; a refused merge fails closed.
+ */
+export declare class InMemoryOriginRevocationStore implements MonotonicOriginRevocationStore {
+    readonly durability: "process-local";
+    private readonly revoked;
+    private readonly originKeys;
+    private readonly operatorKeys;
+    private readonly limits;
+    constructor(limits?: {
+        perOrigin?: number;
+        perOperator?: number;
+        total?: number;
+    });
+    merge(origin: string, snapshot: OriginRevocationSnapshot): Promise<void>;
+    get(origin: string, keyid: string): Promise<RevocationDetail | undefined>;
+}
+/** See {@link OriginRevocationResolver.status}. */
+export type OriginRevocationStatus = 'revoked' | 'current' | 'absent' | 'unknown';
+export declare class OriginRevocationResolver {
+    private readonly options;
+    private readonly freshness;
+    private readonly updated;
+    private readonly graceUntil;
+    private readonly pending;
+    private readonly failures;
+    private readonly persistenceFailures;
+    private readonly absentUntil;
+    constructor(options: {
+        directory: import('../signing/web-bot-auth.mjs').SignatureDirectoryResolver;
+        store: MonotonicOriginRevocationStore;
+        pollingIntervalSeconds?: number;
+        now?: () => number;
+        fetchOptions?: Pick<SsrfFetchOptions, 'lookup' | 'trustedFetchFn'>;
+        maxOrigins?: number;
+    });
+    /**
+     * Compatibility wrapper over {@link status}: `true` when revoked, `false`
+     * when the list is current, and `revocation_unavailable` when the identity
+     * publishes no list (`absent`) or its status is not known (`unknown`).
+     */
+    isRevoked(originUrl: string, keyid: string): Promise<boolean>;
+    /**
+     * Revocation status of `keyid` at `origin`:
+     * - `revoked`: a stored (permanent) revocation covers the key.
+     * - `current`: a signed list is current, or within `next_update` + grace.
+     * - `absent`: the origin serves no list (404/410). The identity is still
+     *   established but cannot be bound for spend.
+     * - `unknown`: no list could be verified and grace has passed (or there was
+     *   never a list). The identity is not established.
+     * Throws {@link WebBotAuthUnavailableError} (`revocation_persistence_failed`)
+     * when the history store fails: an infrastructure outage, never a
+     * revocation outcome.
+     */
+    status(originUrl: string, keyid: string): Promise<OriginRevocationStatus>;
+    private currentStatus;
+    private readStored;
+    private refresh;
+    private now;
+}
+/** Publish a signed list even when there are no revoked keys; refresh before next_update. */
+export declare function createSignedOriginRevocationList(snapshot: OriginRevocationSnapshot, privateKey: JWK): Promise<string>;