@adcp/sdk 15.9.1 → 16.0.0-beta.2

package/dist/lib/core/webhook-registration.js

@@ -21,6 +21,7 @@ __export(webhook_registration_exports, {
   InMemoryWebhookRegistrationStore: () => InMemoryWebhookRegistrationStore,
   WebhookRegistrationIntegrityError: () => WebhookRegistrationIntegrityError,
   canonicalDelegatedOperatorAuthorization: () => canonicalDelegatedOperatorAuthorization,
+  deliveryWebhookRegistrationId: () => deliveryWebhookRegistrationId,
   freezeWebhookRegistration: () => freezeWebhookRegistration,
   parseWebhookRegistration: () => parseWebhookRegistration,
   sameWebhookRegistration: () => sameWebhookRegistration,
@@ -31,6 +32,7 @@ __export(webhook_registration_exports, {
   webhookRegistrationStorageDigest: () => webhookRegistrationStorageDigest
 });
 module.exports = __toCommonJS(webhook_registration_exports);
+var import_canonicalize = require('../signing/canonicalize.js');
 var import_node_crypto = require("node:crypto");
 var import_errors = require('../errors/index.js');
 var import_webhook_verifier = require('../signing/webhook-verifier.js');
@@ -68,7 +70,11 @@ class InMemoryWebhookRegistrationStore {
     const key = registrationKey(parsed.agentId, parsed.operationId);
     const existing = this.entries.get(key);
     if (existing) {
-      if (sameWebhookRegistration(existing, parsed)) return;
+      if (sameWebhookRegistration(existing, parsed)) {
+        if (parsed.deliveryKind && parsed.expiresAt > existing.expiresAt)
+          this.entries.set(key, freezeWebhookRegistration({ ...existing, expiresAt: parsed.expiresAt }));
+        return;
+      }
       throw new import_errors.ConfigurationError(
         "Webhook operation id is already registered with different trusted provenance.",
         "operationId"
@@ -170,6 +176,8 @@ function parseWebhookRegistration(value, expectedKey) {
   if (input.requiresDurableSettlement !== void 0 && typeof input.requiresDurableSettlement !== "boolean") {
     throw new TypeError("Webhook registration requiresDurableSettlement must be boolean.");
   }
+  if (input.signingProfile !== void 0 && (input.mode !== "rfc9421" || !["adcp/webhook-signing/v1", "web-bot-auth"].includes(input.signingProfile)))
+    throw new TypeError("Invalid registered webhook signing profile");
   const createdAt = requireEpochMs("createdAt", input.createdAt);
   const expiresAt = requireEpochMs("expiresAt", input.expiresAt);
   if (expiresAt <= createdAt) {
@@ -198,6 +206,8 @@ function parseWebhookRegistration(value, expectedKey) {
   if (agent.username || agent.password || agent.hash) {
     throw new TypeError("Webhook agentUrl cannot contain userinfo credentials or a fragment.");
   }
+  if (input.deliveryKind !== void 0 && (!["reporting", "artifact"].includes(input.deliveryKind) || input.mode !== "rfc9421"))
+    throw new TypeError("Invalid delivery registration kind");
   const parsed = {
     agentId,
     agentUrl,
@@ -207,6 +217,12 @@ function parseWebhookRegistration(value, expectedKey) {
     callbackUrl,
     method: "POST",
     mode: input.mode,
+    ...input.signingProfile !== void 0 && {
+      signingProfile: input.signingProfile
+    },
+    ...input.deliveryKind !== void 0 && {
+      deliveryKind: input.deliveryKind
+    },
     ...input.authorizationContextVersion === 1 && { authorizationContextVersion: 1 },
     ...delegatedOperatorAuthorization !== void 0 && {
       delegatedOperatorAuthorization: { ...delegatedOperatorAuthorization }
@@ -289,7 +305,9 @@ function webhookRegistrationFingerprint(registration) {
     parsed.mode,
     parsed.previewMode ?? null,
     parsed.authorizationContextVersion ?? null,
-    canonicalDelegatedOperatorAuthorization(parsed.delegatedOperatorAuthorization)
+    canonicalDelegatedOperatorAuthorization(parsed.delegatedOperatorAuthorization),
+    ...parsed.signingProfile === "web-bot-auth" ? [parsed.signingProfile] : [],
+    ...parsed.deliveryKind !== void 0 ? ["delivery", parsed.deliveryKind] : []
   ]);
 }
 function sameWebhookRegistration(a, b) {
@@ -299,11 +317,15 @@ function webhookRegistrationStorageDigest(agentId, operationId) {
   validateWebhookRegistrationKey(agentId, operationId);
   return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify([agentId, operationId])).digest("hex");
 }
+function deliveryWebhookRegistrationId(kind, url) {
+  return `delivery_route:${kind}:` + (0, import_node_crypto.createHash)("sha256").update((0, import_canonicalize.canonicalTargetUri)(url, "3.2")).digest("hex");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   InMemoryWebhookRegistrationStore,
   WebhookRegistrationIntegrityError,
   canonicalDelegatedOperatorAuthorization,
+  deliveryWebhookRegistrationId,
   freezeWebhookRegistration,
   parseWebhookRegistration,
   sameWebhookRegistration,

package/dist/lib/core/webhook-registration.mjs

@@ -1,3 +1,4 @@
+import { canonicalTargetUri } from "../signing/canonicalize.mjs";
 import { createHash } from "node:crypto";
 import { ConfigurationError } from "../errors/index.mjs";
 import { isWebhookLoopbackHost } from "../signing/webhook-verifier.mjs";
@@ -35,7 +36,11 @@ class InMemoryWebhookRegistrationStore {
     const key = registrationKey(parsed.agentId, parsed.operationId);
     const existing = this.entries.get(key);
     if (existing) {
-      if (sameWebhookRegistration(existing, parsed)) return;
+      if (sameWebhookRegistration(existing, parsed)) {
+        if (parsed.deliveryKind && parsed.expiresAt > existing.expiresAt)
+          this.entries.set(key, freezeWebhookRegistration({ ...existing, expiresAt: parsed.expiresAt }));
+        return;
+      }
       throw new ConfigurationError(
         "Webhook operation id is already registered with different trusted provenance.",
         "operationId"
@@ -137,6 +142,8 @@ function parseWebhookRegistration(value, expectedKey) {
   if (input.requiresDurableSettlement !== void 0 && typeof input.requiresDurableSettlement !== "boolean") {
     throw new TypeError("Webhook registration requiresDurableSettlement must be boolean.");
   }
+  if (input.signingProfile !== void 0 && (input.mode !== "rfc9421" || !["adcp/webhook-signing/v1", "web-bot-auth"].includes(input.signingProfile)))
+    throw new TypeError("Invalid registered webhook signing profile");
   const createdAt = requireEpochMs("createdAt", input.createdAt);
   const expiresAt = requireEpochMs("expiresAt", input.expiresAt);
   if (expiresAt <= createdAt) {
@@ -165,6 +172,8 @@ function parseWebhookRegistration(value, expectedKey) {
   if (agent.username || agent.password || agent.hash) {
     throw new TypeError("Webhook agentUrl cannot contain userinfo credentials or a fragment.");
   }
+  if (input.deliveryKind !== void 0 && (!["reporting", "artifact"].includes(input.deliveryKind) || input.mode !== "rfc9421"))
+    throw new TypeError("Invalid delivery registration kind");
   const parsed = {
     agentId,
     agentUrl,
@@ -174,6 +183,12 @@ function parseWebhookRegistration(value, expectedKey) {
     callbackUrl,
     method: "POST",
     mode: input.mode,
+    ...input.signingProfile !== void 0 && {
+      signingProfile: input.signingProfile
+    },
+    ...input.deliveryKind !== void 0 && {
+      deliveryKind: input.deliveryKind
+    },
     ...input.authorizationContextVersion === 1 && { authorizationContextVersion: 1 },
     ...delegatedOperatorAuthorization !== void 0 && {
       delegatedOperatorAuthorization: { ...delegatedOperatorAuthorization }
@@ -256,7 +271,9 @@ function webhookRegistrationFingerprint(registration) {
     parsed.mode,
     parsed.previewMode ?? null,
     parsed.authorizationContextVersion ?? null,
-    canonicalDelegatedOperatorAuthorization(parsed.delegatedOperatorAuthorization)
+    canonicalDelegatedOperatorAuthorization(parsed.delegatedOperatorAuthorization),
+    ...parsed.signingProfile === "web-bot-auth" ? [parsed.signingProfile] : [],
+    ...parsed.deliveryKind !== void 0 ? ["delivery", parsed.deliveryKind] : []
   ]);
 }
 function sameWebhookRegistration(a, b) {
@@ -266,10 +283,14 @@ function webhookRegistrationStorageDigest(agentId, operationId) {
   validateWebhookRegistrationKey(agentId, operationId);
   return createHash("sha256").update(JSON.stringify([agentId, operationId])).digest("hex");
 }
+function deliveryWebhookRegistrationId(kind, url) {
+  return `delivery_route:${kind}:` + createHash("sha256").update(canonicalTargetUri(url, "3.2")).digest("hex");
+}
 export {
   InMemoryWebhookRegistrationStore,
   WebhookRegistrationIntegrityError,
   canonicalDelegatedOperatorAuthorization,
+  deliveryWebhookRegistrationId,
   freezeWebhookRegistration,
   parseWebhookRegistration,
   sameWebhookRegistration,

package/dist/lib/identity-3.3/generated-compat.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Bridges the experimental AdCP 3.3 preview types to the generated wire types.
+ *
+ * The released SDK pins an AdCP schema version that predates the 3.3 identity
+ * drafts, so the preview types in `./types` start from hand-written drafts. Once
+ * the pinned schemas (or a candidate spec bundle built by the spec repo's
+ * "Generate TypeScript SDK" check) define a shape, the generated type wins: the
+ * preview type becomes an alias of it, so the two cannot drift apart and a
+ * server that accepts the preview shape always emits a generated-valid payload.
+ *
+ * Internal: not re-exported from `@adcp/sdk/identity-3.3`.
+ */
+import type { GetAdCPCapabilitiesResponse } from '../types/tools.generated.mjs';
+/**
+ * The value type of an optional property `K` on `T`, or `unknown` when `T`
+ * does not declare it. An object type without `K` is assignable to
+ * `{ K?: V }`, so the absent case infers `unknown` rather than failing.
+ * Non-distributive, so a union `T` resolves to the property's union rather
+ * than silently falling back when one member lacks it.
+ */
+export type OptionalPropertyOf<T, K extends PropertyKey> = [T] extends [{
+    [P in K]?: infer V;
+}] ? V : unknown;
+/** `Generated` when the pinned schemas define it, otherwise `Draft`. */
+export type PreferGenerated<Generated, Draft> = unknown extends Generated ? Draft : [NonNullable<Generated>] extends [never] ? Draft : NonNullable<Generated>;
+/**
+ * Resolves `account.agent_onboarding` from a `get_adcp_capabilities` account
+ * shape, falling back to the draft when that shape does not declare it.
+ * Parameterised so type tests can exercise it against fixtures of newer
+ * generated shapes without regenerating the SDK.
+ */
+export type ResolveAgentOnboarding<Account, Draft> = PreferGenerated<OptionalPropertyOf<NonNullable<Account>, 'agent_onboarding'>, Draft>;
+/** `account` in the pinned `get_adcp_capabilities` response. */
+export type GeneratedAccountCapabilities = NonNullable<GetAdCPCapabilitiesResponse['account']>;

package/dist/lib/identity-3.3/generated-compat.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bridges the experimental AdCP 3.3 preview types to the generated wire types.
+ *
+ * The released SDK pins an AdCP schema version that predates the 3.3 identity
+ * drafts, so the preview types in `./types` start from hand-written drafts. Once
+ * the pinned schemas (or a candidate spec bundle built by the spec repo's
+ * "Generate TypeScript SDK" check) define a shape, the generated type wins: the
+ * preview type becomes an alias of it, so the two cannot drift apart and a
+ * server that accepts the preview shape always emits a generated-valid payload.
+ *
+ * Internal: not re-exported from `@adcp/sdk/identity-3.3`.
+ */
+import type { GetAdCPCapabilitiesResponse } from '../types/tools.generated';
+/**
+ * The value type of an optional property `K` on `T`, or `unknown` when `T`
+ * does not declare it. An object type without `K` is assignable to
+ * `{ K?: V }`, so the absent case infers `unknown` rather than failing.
+ * Non-distributive, so a union `T` resolves to the property's union rather
+ * than silently falling back when one member lacks it.
+ */
+export type OptionalPropertyOf<T, K extends PropertyKey> = [T] extends [{
+    [P in K]?: infer V;
+}] ? V : unknown;
+/** `Generated` when the pinned schemas define it, otherwise `Draft`. */
+export type PreferGenerated<Generated, Draft> = unknown extends Generated ? Draft : [NonNullable<Generated>] extends [never] ? Draft : NonNullable<Generated>;
+/**
+ * Resolves `account.agent_onboarding` from a `get_adcp_capabilities` account
+ * shape, falling back to the draft when that shape does not declare it.
+ * Parameterised so type tests can exercise it against fixtures of newer
+ * generated shapes without regenerating the SDK.
+ */
+export type ResolveAgentOnboarding<Account, Draft> = PreferGenerated<OptionalPropertyOf<NonNullable<Account>, 'agent_onboarding'>, Draft>;
+/** `account` in the pinned `get_adcp_capabilities` response. */
+export type GeneratedAccountCapabilities = NonNullable<GetAdCPCapabilitiesResponse['account']>;

package/dist/lib/identity-3.3/generated-compat.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 generated_compat_exports = {};
+module.exports = __toCommonJS(generated_compat_exports);

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

@@ -0,0 +1,10 @@
+export * from './types.mjs';
+export * from './trust.mjs';
+export * from './lifecycle.mjs';
+export * from './revocation.mjs';
+export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, verifyKeyDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, WebBotAuthUnavailableError, } from '../signing/web-bot-auth.mjs';
+export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, VerifiedSignatureDirectory, SignatureDirectoryResolverOptions, } from '../signing/web-bot-auth.mjs';
+export { validateIdentity33Payload } from './validation.mjs';
+export { createIdentity33PrincipalResolver, createIdentity33PrincipalScopeResolver, createIdentity33Authorization, withIdentity33PrincipalHandlers, isIdentity33UnboundContext, } from './server.mjs';
+export { createIdentity33StateStores } from './store.mjs';
+export { deliveryWebhookRegistrationId } from '../core/webhook-registration.mjs';

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

@@ -0,0 +1,10 @@
+export * from './types';
+export * from './trust';
+export * from './lifecycle';
+export * from './revocation';
+export { WEB_BOT_AUTH_DRAFT_REVISION, verifyWebBotAuth, signWebBotAuth, createWebBotAuthFetch, createSignedSignatureDirectory, SignatureDirectoryResolver, verifySignatureDirectory, verifyKeyDirectory, selectSignatureProfile, jwkThumbprint, WebBotAuthError, WebBotAuthUnavailableError, } from '../signing/web-bot-auth';
+export type { WebBotSigningKey, WebBotSigningOptions, VerifiedWebBotSigner, VerifyWebBotAuthOptions, VerifiedSignatureDirectory, SignatureDirectoryResolverOptions, } from '../signing/web-bot-auth';
+export { validateIdentity33Payload } from './validation';
+export { createIdentity33PrincipalResolver, createIdentity33PrincipalScopeResolver, createIdentity33Authorization, withIdentity33PrincipalHandlers, isIdentity33UnboundContext, } from './server';
+export { createIdentity33StateStores } from './store';
+export { deliveryWebhookRegistrationId } from '../core/webhook-registration';

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

@@ -0,0 +1,79 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var identity_3_exports = {};
+__export(identity_3_exports, {
+  SignatureDirectoryResolver: () => import_web_bot_auth.SignatureDirectoryResolver,
+  WEB_BOT_AUTH_DRAFT_REVISION: () => import_web_bot_auth.WEB_BOT_AUTH_DRAFT_REVISION,
+  WebBotAuthError: () => import_web_bot_auth.WebBotAuthError,
+  WebBotAuthUnavailableError: () => import_web_bot_auth.WebBotAuthUnavailableError,
+  createIdentity33Authorization: () => import_server.createIdentity33Authorization,
+  createIdentity33PrincipalResolver: () => import_server.createIdentity33PrincipalResolver,
+  createIdentity33PrincipalScopeResolver: () => import_server.createIdentity33PrincipalScopeResolver,
+  createIdentity33StateStores: () => import_store.createIdentity33StateStores,
+  createSignedSignatureDirectory: () => import_web_bot_auth.createSignedSignatureDirectory,
+  createWebBotAuthFetch: () => import_web_bot_auth.createWebBotAuthFetch,
+  deliveryWebhookRegistrationId: () => import_webhook_registration.deliveryWebhookRegistrationId,
+  isIdentity33UnboundContext: () => import_server.isIdentity33UnboundContext,
+  jwkThumbprint: () => import_web_bot_auth.jwkThumbprint,
+  selectSignatureProfile: () => import_web_bot_auth.selectSignatureProfile,
+  signWebBotAuth: () => import_web_bot_auth.signWebBotAuth,
+  validateIdentity33Payload: () => import_validation.validateIdentity33Payload,
+  verifyKeyDirectory: () => import_web_bot_auth.verifyKeyDirectory,
+  verifySignatureDirectory: () => import_web_bot_auth.verifySignatureDirectory,
+  verifyWebBotAuth: () => import_web_bot_auth.verifyWebBotAuth,
+  withIdentity33PrincipalHandlers: () => import_server.withIdentity33PrincipalHandlers
+});
+module.exports = __toCommonJS(identity_3_exports);
+__reExport(identity_3_exports, require('./types.js'), module.exports);
+__reExport(identity_3_exports, require('./trust.js'), module.exports);
+__reExport(identity_3_exports, require('./lifecycle.js'), module.exports);
+__reExport(identity_3_exports, require('./revocation.js'), module.exports);
+var import_web_bot_auth = require('../signing/web-bot-auth.js');
+var import_validation = require('./validation.js');
+var import_server = require('./server.js');
+var import_store = require('./store.js');
+var import_webhook_registration = require('../core/webhook-registration.js');
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SignatureDirectoryResolver,
+  WEB_BOT_AUTH_DRAFT_REVISION,
+  WebBotAuthError,
+  WebBotAuthUnavailableError,
+  createIdentity33Authorization,
+  createIdentity33PrincipalResolver,
+  createIdentity33PrincipalScopeResolver,
+  createIdentity33StateStores,
+  createSignedSignatureDirectory,
+  createWebBotAuthFetch,
+  deliveryWebhookRegistrationId,
+  isIdentity33UnboundContext,
+  jwkThumbprint,
+  selectSignatureProfile,
+  signWebBotAuth,
+  validateIdentity33Payload,
+  verifyKeyDirectory,
+  verifySignatureDirectory,
+  verifyWebBotAuth,
+  withIdentity33PrincipalHandlers,
+  ...require('./types.js'),
+  ...require('./trust.js'),
+  ...require('./lifecycle.js'),
+  ...require('./revocation.js')
+});

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

@@ -0,0 +1,50 @@
+export * from "./types.mjs";
+export * from "./trust.mjs";
+export * from "./lifecycle.mjs";
+export * from "./revocation.mjs";
+import {
+  WEB_BOT_AUTH_DRAFT_REVISION,
+  verifyWebBotAuth,
+  signWebBotAuth,
+  createWebBotAuthFetch,
+  createSignedSignatureDirectory,
+  SignatureDirectoryResolver,
+  verifySignatureDirectory,
+  verifyKeyDirectory,
+  selectSignatureProfile,
+  jwkThumbprint,
+  WebBotAuthError,
+  WebBotAuthUnavailableError
+} from "../signing/web-bot-auth.mjs";
+import { validateIdentity33Payload } from "./validation.mjs";
+import {
+  createIdentity33PrincipalResolver,
+  createIdentity33PrincipalScopeResolver,
+  createIdentity33Authorization,
+  withIdentity33PrincipalHandlers,
+  isIdentity33UnboundContext
+} from "./server.mjs";
+import { createIdentity33StateStores } from "./store.mjs";
+import { deliveryWebhookRegistrationId } from "../core/webhook-registration.mjs";
+export {
+  SignatureDirectoryResolver,
+  WEB_BOT_AUTH_DRAFT_REVISION,
+  WebBotAuthError,
+  WebBotAuthUnavailableError,
+  createIdentity33Authorization,
+  createIdentity33PrincipalResolver,
+  createIdentity33PrincipalScopeResolver,
+  createIdentity33StateStores,
+  createSignedSignatureDirectory,
+  createWebBotAuthFetch,
+  deliveryWebhookRegistrationId,
+  isIdentity33UnboundContext,
+  jwkThumbprint,
+  selectSignatureProfile,
+  signWebBotAuth,
+  validateIdentity33Payload,
+  verifyKeyDirectory,
+  verifySignatureDirectory,
+  verifyWebBotAuth,
+  withIdentity33PrincipalHandlers
+};

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

@@ -0,0 +1,125 @@
+import type { PrincipalKind } from '../server/principal/types.mjs';
+import { TrustEvaluator } from './trust.mjs';
+import type { AgentOnboarding, AgentOnboardingRequirement, ObservedAgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types.mjs';
+export interface OriginBinding {
+    origin: string;
+    operator: string;
+    principalId: string;
+    principalKind?: PrincipalKind;
+    audit: {
+        approvedBy: string;
+        approvedAt: string;
+        reason: string;
+        migrationApproved?: boolean;
+    };
+    /** Restricts a newly auto-created principal to the specifically opened tiers. */
+    openAccess?: {
+        sandbox?: true;
+        billing?: BillingParty[];
+    };
+}
+export interface IdentityApplication {
+    relationship: PrincipalRelationship;
+    revision: number;
+    expiryNotified?: string;
+    pendingNotifications?: Array<{
+        id: string;
+        reason: IdentityPrincipalChangedReason;
+    }>;
+}
+/** Every write must be atomic. Namespace this store to one seller and tenant. */
+export interface OriginIdentityStore {
+    getBinding(origin: string): Promise<OriginBinding | undefined>;
+    /** Must enforce one principal per origin, including concurrent migrations. */
+    bind(binding: OriginBinding): Promise<void>;
+    /** Must atomically enforce operator-domain quota and allocate a NEW principal. */
+    bindOpen(binding: OriginBinding, maxPerOperator: number): Promise<OriginBinding>;
+    getApplication(origin: string): Promise<IdentityApplication | undefined>;
+    compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
+}
+export declare class InMemoryOriginIdentityStore implements OriginIdentityStore {
+    readonly durability: "process-local";
+    private readonly bindings;
+    private readonly applications;
+    getBinding(origin: string): Promise<OriginBinding | undefined>;
+    bind(binding: OriginBinding): Promise<void>;
+    bindOpen(binding: OriginBinding, maxPerOperator: number): Promise<OriginBinding>;
+    getApplication(origin: string): Promise<IdentityApplication | undefined>;
+    compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
+}
+/**
+ * Wrong-direction gates are ignored; unknown gates remain unsatisfied. Accepts
+ * requirements read off the wire, whose `kind` may be one this SDK does not know.
+ */
+export declare function evaluateOnboardingRequirements<R extends ObservedAgentOnboardingRequirement = AgentOnboardingRequirement>(requirements: readonly R[], direction: 'seller' | 'buyer', check: (requirement: R) => Promise<boolean>): Promise<{
+    satisfied: boolean;
+    unsatisfied: R[];
+}>;
+export declare function validateAgentOnboarding(posture: AgentOnboarding, account: {
+    sandbox?: boolean;
+    supported_billing?: readonly BillingParty[];
+}, experimentalFeatures: readonly string[]): void;
+export interface OriginIdentityLifecycleOptions {
+    store: OriginIdentityStore;
+    trust: TrustEvaluator;
+    now?: () => number;
+    /** Supply for open onboarding only. */
+    onboarding?: AgentOnboarding;
+    maxOpenPrincipalsPerOperator?: number;
+    checkRequirement?: (origin: string, requirement: AgentOnboardingRequirement) => Promise<boolean>;
+    hasBillingRelationship?: (billedPartyDomain: string, billing: BillingParty) => Promise<boolean>;
+    /** Publish only after the new application state is durable; duplicate notifications are allowed. */
+    notify?: (origin: string, reason: IdentityPrincipalChangedReason, notificationId: string) => Promise<void>;
+    /** Seller ledger lookup, required before automatic creation to prevent RFC principal splitting. */
+    lookupLegacyPrincipals?: (origin: string) => Promise<readonly string[]>;
+}
+export declare class OriginIdentityLifecycle {
+    private readonly options;
+    constructor(options: OriginIdentityLifecycleOptions);
+    /** Identity-established origins get no durable identifier. Reads never create. */
+    getPrincipal(originUrl: string): Promise<{
+        binding?: OriginBinding;
+        result: {
+            kind: 'unconfigured' | 'recognized';
+            principal_id?: string;
+            principal_kind?: PrincipalKind;
+            relationship?: PrincipalRelationship;
+        };
+    }>;
+    bindPrincipal(input: {
+        origin: string;
+        principalId: string;
+        approvedBy: string;
+        reason: string;
+        principalKind?: PrincipalKind;
+        existingRfcPrincipal?: boolean;
+        migrationApproved?: boolean;
+        sharedOrigin?: boolean;
+    }): Promise<OriginBinding>;
+    /**
+     * 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`.
+     */
+    authorizeBound(originUrl: string, access?: {
+        readOnly?: true;
+        identityConfiguration?: true;
+        sandbox?: boolean;
+        billing?: BillingParty;
+        brandDomain?: string;
+    }): Promise<OriginBinding | undefined>;
+    /** Called by explicit sync_principal only; allocates new identities, never migrates existing ones. */
+    syncOpen(originUrl: string, options?: {
+        dryRun?: boolean;
+    }): Promise<OriginBinding>;
+    setRelationship(originUrl: string, relationship: PrincipalRelationship): Promise<void>;
+    notifyRelationshipExpiring(originUrl: string, leadSeconds: number): Promise<boolean>;
+    flushRelationshipNotifications(originUrl: string): Promise<void>;
+    assertLegacyAllowed(agentUrl: string): Promise<void>;
+    private now;
+}

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

@@ -0,0 +1,125 @@
+import type { PrincipalKind } from '../server/principal/types';
+import { TrustEvaluator } from './trust';
+import type { AgentOnboarding, AgentOnboardingRequirement, ObservedAgentOnboardingRequirement, BillingParty, PrincipalRelationship, IdentityPrincipalChangedReason } from './types';
+export interface OriginBinding {
+    origin: string;
+    operator: string;
+    principalId: string;
+    principalKind?: PrincipalKind;
+    audit: {
+        approvedBy: string;
+        approvedAt: string;
+        reason: string;
+        migrationApproved?: boolean;
+    };
+    /** Restricts a newly auto-created principal to the specifically opened tiers. */
+    openAccess?: {
+        sandbox?: true;
+        billing?: BillingParty[];
+    };
+}
+export interface IdentityApplication {
+    relationship: PrincipalRelationship;
+    revision: number;
+    expiryNotified?: string;
+    pendingNotifications?: Array<{
+        id: string;
+        reason: IdentityPrincipalChangedReason;
+    }>;
+}
+/** Every write must be atomic. Namespace this store to one seller and tenant. */
+export interface OriginIdentityStore {
+    getBinding(origin: string): Promise<OriginBinding | undefined>;
+    /** Must enforce one principal per origin, including concurrent migrations. */
+    bind(binding: OriginBinding): Promise<void>;
+    /** Must atomically enforce operator-domain quota and allocate a NEW principal. */
+    bindOpen(binding: OriginBinding, maxPerOperator: number): Promise<OriginBinding>;
+    getApplication(origin: string): Promise<IdentityApplication | undefined>;
+    compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
+}
+export declare class InMemoryOriginIdentityStore implements OriginIdentityStore {
+    readonly durability: "process-local";
+    private readonly bindings;
+    private readonly applications;
+    getBinding(origin: string): Promise<OriginBinding | undefined>;
+    bind(binding: OriginBinding): Promise<void>;
+    bindOpen(binding: OriginBinding, maxPerOperator: number): Promise<OriginBinding>;
+    getApplication(origin: string): Promise<IdentityApplication | undefined>;
+    compareAndSetApplication(origin: string, expectedRevision: number | undefined, application: IdentityApplication): Promise<boolean>;
+}
+/**
+ * Wrong-direction gates are ignored; unknown gates remain unsatisfied. Accepts
+ * requirements read off the wire, whose `kind` may be one this SDK does not know.
+ */
+export declare function evaluateOnboardingRequirements<R extends ObservedAgentOnboardingRequirement = AgentOnboardingRequirement>(requirements: readonly R[], direction: 'seller' | 'buyer', check: (requirement: R) => Promise<boolean>): Promise<{
+    satisfied: boolean;
+    unsatisfied: R[];
+}>;
+export declare function validateAgentOnboarding(posture: AgentOnboarding, account: {
+    sandbox?: boolean;
+    supported_billing?: readonly BillingParty[];
+}, experimentalFeatures: readonly string[]): void;
+export interface OriginIdentityLifecycleOptions {
+    store: OriginIdentityStore;
+    trust: TrustEvaluator;
+    now?: () => number;
+    /** Supply for open onboarding only. */
+    onboarding?: AgentOnboarding;
+    maxOpenPrincipalsPerOperator?: number;
+    checkRequirement?: (origin: string, requirement: AgentOnboardingRequirement) => Promise<boolean>;
+    hasBillingRelationship?: (billedPartyDomain: string, billing: BillingParty) => Promise<boolean>;
+    /** Publish only after the new application state is durable; duplicate notifications are allowed. */
+    notify?: (origin: string, reason: IdentityPrincipalChangedReason, notificationId: string) => Promise<void>;
+    /** Seller ledger lookup, required before automatic creation to prevent RFC principal splitting. */
+    lookupLegacyPrincipals?: (origin: string) => Promise<readonly string[]>;
+}
+export declare class OriginIdentityLifecycle {
+    private readonly options;
+    constructor(options: OriginIdentityLifecycleOptions);
+    /** Identity-established origins get no durable identifier. Reads never create. */
+    getPrincipal(originUrl: string): Promise<{
+        binding?: OriginBinding;
+        result: {
+            kind: 'unconfigured' | 'recognized';
+            principal_id?: string;
+            principal_kind?: PrincipalKind;
+            relationship?: PrincipalRelationship;
+        };
+    }>;
+    bindPrincipal(input: {
+        origin: string;
+        principalId: string;
+        approvedBy: string;
+        reason: string;
+        principalKind?: PrincipalKind;
+        existingRfcPrincipal?: boolean;
+        migrationApproved?: boolean;
+        sharedOrigin?: boolean;
+    }): Promise<OriginBinding>;
+    /**
+     * 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`.
+     */
+    authorizeBound(originUrl: string, access?: {
+        readOnly?: true;
+        identityConfiguration?: true;
+        sandbox?: boolean;
+        billing?: BillingParty;
+        brandDomain?: string;
+    }): Promise<OriginBinding | undefined>;
+    /** Called by explicit sync_principal only; allocates new identities, never migrates existing ones. */
+    syncOpen(originUrl: string, options?: {
+        dryRun?: boolean;
+    }): Promise<OriginBinding>;
+    setRelationship(originUrl: string, relationship: PrincipalRelationship): Promise<void>;
+    notifyRelationshipExpiring(originUrl: string, leadSeconds: number): Promise<boolean>;
+    flushRelationshipNotifications(originUrl: string): Promise<void>;
+    assertLegacyAllowed(agentUrl: string): Promise<void>;
+    private now;
+}