@adcp/sdk 15.9.0 → 16.0.0-beta.1

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

@@ -0,0 +1,267 @@
+"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.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. */
+  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();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    if (binding.operator !== trust.operator) throw new import_trust.IdentityAuthorizationError();
+    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,240 @@
+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, 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.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. */
+  async authorizeBound(originUrl, access) {
+    const origin = canonicalAgentOrigin(originUrl);
+    const binding = await this.options.store.getBinding(origin);
+    if (!binding) throw new IdentityAuthorizationError();
+    const trust = await this.options.trust.match(origin, "adcp:buying");
+    if (binding.operator !== trust.operator) throw new IdentityAuthorizationError();
+    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,50 @@
+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>;
+}
+export declare class InMemoryOriginRevocationStore implements MonotonicOriginRevocationStore {
+    private readonly limits;
+    readonly durability: "process-local";
+    private readonly revoked;
+    constructor(limits?: {
+        perOrigin: number;
+        total: number;
+    });
+    merge(origin: string, snapshot: OriginRevocationSnapshot): Promise<void>;
+    get(origin: string, keyid: string): Promise<RevocationDetail | undefined>;
+}
+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;
+    constructor(options: {
+        directory: import('../signing/web-bot-auth.mjs').SignatureDirectoryResolver;
+        store: MonotonicOriginRevocationStore;
+        pollingIntervalSeconds?: number;
+        now?: () => number;
+        fetchOptions?: Pick<SsrfFetchOptions, 'lookup' | 'trustedFetchFn'>;
+        maxOrigins?: number;
+    });
+    isRevoked(originUrl: string, keyid: string): Promise<boolean>;
+    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>;

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

@@ -0,0 +1,50 @@
+import { type JWK } from 'jose';
+import { type SsrfFetchOptions } from '../net';
+import type { RevocationDetail } from './types';
+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>;
+}
+export declare class InMemoryOriginRevocationStore implements MonotonicOriginRevocationStore {
+    private readonly limits;
+    readonly durability: "process-local";
+    private readonly revoked;
+    constructor(limits?: {
+        perOrigin: number;
+        total: number;
+    });
+    merge(origin: string, snapshot: OriginRevocationSnapshot): Promise<void>;
+    get(origin: string, keyid: string): Promise<RevocationDetail | undefined>;
+}
+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;
+    constructor(options: {
+        directory: import('../signing/web-bot-auth').SignatureDirectoryResolver;
+        store: MonotonicOriginRevocationStore;
+        pollingIntervalSeconds?: number;
+        now?: () => number;
+        fetchOptions?: Pick<SsrfFetchOptions, 'lookup' | 'trustedFetchFn'>;
+        maxOrigins?: number;
+    });
+    isRevoked(originUrl: string, keyid: string): Promise<boolean>;
+    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>;