@datalayer/personal-agent-protocol 0.2.0 → 0.3.1

package/lib/index.js

@@ -26,6 +26,12 @@ var DiscoveryError = class extends PersonalAgentProtocolError {
     this.name = "DiscoveryError";
   }
 };
+var IdentityError = class extends PersonalAgentProtocolError {
+  constructor(code, message2, options = {}) {
+    super(code, message2, options);
+    this.name = "IdentityError";
+  }
+};
 var AuthorizationError = class extends PersonalAgentProtocolError {
   constructor(code, message2, options = {}) {
     super(code, message2, options);
@@ -45,7 +51,7 @@ var ProofError = class extends PersonalAgentProtocolError {
   }
 };
 
-// ../../node_modules/jose/dist/webapi/lib/buffer_utils.js
+// node_modules/jose/dist/webapi/lib/buffer_utils.js
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 var strictDecoder = new TextDecoder("utf-8", { fatal: true });
@@ -95,12 +101,8 @@ function decodeBase64(encoded, url = false) {
     bytes[i] = binary.charCodeAt(i);
   return bytes;
 }
-async function digest(algorithm2, data) {
-  const subtleDigest = `SHA-${algorithm2.slice(-3)}`;
-  return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-}
 
-// ../../node_modules/jose/dist/webapi/util/errors.js
+// node_modules/jose/dist/webapi/util/errors.js
 var JOSEError = class extends Error {
   static code = "ERR_JOSE_GENERIC";
   code = "ERR_JOSE_GENERIC";
@@ -108,30 +110,6 @@ var JOSEError = class extends Error {
     super(message2, options), this.name = this.constructor.name, Error.captureStackTrace?.(this, this.constructor);
   }
 };
-var JWTClaimValidationFailed = class extends JOSEError {
-  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
-  }
-};
-var JWTExpired = class extends JOSEError {
-  static code = "ERR_JWT_EXPIRED";
-  code = "ERR_JWT_EXPIRED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } }), this.claim = claim, this.reason = reason, this.payload = payload;
-  }
-};
-var JOSEAlgNotAllowed = class extends JOSEError {
-  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
-  code = "ERR_JOSE_ALG_NOT_ALLOWED";
-};
 var JOSENotSupported = class extends JOSEError {
   static code = "ERR_JOSE_NOT_SUPPORTED";
   code = "ERR_JOSE_NOT_SUPPORTED";
@@ -144,19 +122,8 @@ var JWTInvalid = class extends JOSEError {
   static code = "ERR_JWT_INVALID";
   code = "ERR_JWT_INVALID";
 };
-var JWKInvalid = class extends JOSEError {
-  static code = "ERR_JWK_INVALID";
-  code = "ERR_JWK_INVALID";
-};
-var JWSSignatureVerificationFailed = class extends JOSEError {
-  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  constructor(message2 = "signature verification failed", options) {
-    super(message2, options);
-  }
-};
 
-// ../../node_modules/jose/dist/webapi/util/base64url.js
+// node_modules/jose/dist/webapi/util/base64url.js
 var invalid = "The input to be decoded is not correctly encoded.";
 function decode(input) {
   try {
@@ -169,7 +136,7 @@ function encode2(input) {
   return encodeBase64(typeof input == "string" ? encoder.encode(input) : input, true);
 }
 
-// ../../node_modules/jose/dist/webapi/lib/validate.js
+// node_modules/jose/dist/webapi/lib/validate.js
 function isObject(input) {
   if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]")
     return false;
@@ -191,37 +158,7 @@ function assertNotSet(value, name) {
   if (value !== void 0)
     throw new TypeError(`${name} can only be called once`);
 }
-function decodeBase64url(value, label, ErrorClass) {
-  try {
-    return decode(value);
-  } catch {
-    throw new ErrorClass(`Failed to base64url decode the ${label}`);
-  }
-}
-function encodeBase64url(value, label, ErrorClass) {
-  try {
-    return encode(value);
-  } catch {
-    throw new ErrorClass(`The ${label} is not a valid base64url string`);
-  }
-}
-function parseJoseHeader(b64, ErrorClass, message2) {
-  let parsed;
-  try {
-    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-  } catch {
-    throw new ErrorClass(message2);
-  }
-  if (!isObject(parsed))
-    throw new ErrorClass(message2);
-  return parsed;
-}
 var JWS_RECOGNIZED = { __proto__: null, b64: true };
-function validateAlgorithms(option, algorithms) {
-  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s) => typeof s != "string")))
-    throw new TypeError(`"${option}" option must be an array of strings`);
-  return algorithms === void 0 ? void 0 : new Set(algorithms);
-}
 function validateCritDuplicates(Err, protectedHeader) {
   const { crit } = protectedHeader ?? {};
   if (Array.isArray(crit) && new Set(crit).size !== crit.length)
@@ -266,7 +203,7 @@ function serializeJoseHeader(Err, header) {
   return [parsed, serialized];
 }
 
-// ../../node_modules/jose/dist/webapi/lib/key.js
+// node_modules/jose/dist/webapi/lib/key.js
 var tag = (key) => key[Symbol.toStringTag];
 var jwkMatchesOp = (entry, key, usage) => {
   const { alg } = entry;
@@ -346,7 +283,6 @@ function message(msg, actual, ...types) {
   } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
   return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
 }
-var invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types);
 function invalidKeyType(alg, actual, secret) {
   const types = ["CryptoKey", "KeyObject", "JSON Web Key"];
   return secret && types.push("Uint8Array"), new TypeError(message(`Key for the ${alg} algorithm must be `, actual, ...types));
@@ -388,11 +324,6 @@ function normalizeJwk(jwk) {
   }
   return normalized;
 }
-function validateExtractableOption(extractable) {
-  if (extractable !== void 0 && typeof extractable != "boolean")
-    throw new TypeError('"extractable" option must be a boolean');
-  return extractable;
-}
 async function jwkToKey(entry, jwk, extractable) {
   if (!entry.kty.includes(jwk.kty))
     throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
@@ -403,7 +334,7 @@ async function rawKey(key, expected, usage, extractable = false) {
   return key instanceof Uint8Array && (key = await crypto.subtle.importKey("raw", key, expected, extractable, [usage])), checkCryptoKey(key, expected, usage), key;
 }
 
-// ../../node_modules/jose/dist/webapi/lib/key_descriptor.js
+// node_modules/jose/dist/webapi/lib/key_descriptor.js
 function table(entries) {
   const out = { __proto__: null };
   for (const alg in entries)
@@ -411,108 +342,7 @@ function table(entries) {
   return out;
 }
 
-// ../../node_modules/jose/dist/webapi/lib/jwe_algorithms.js
-var wrap = [
-  ["encrypt", "wrapKey"],
-  ["decrypt", "unwrapKey"]
-];
-var derive = [[], ["deriveBits"]];
-var none = [[], []];
-function rsaes(bits) {
-  return {
-    kty: ["RSA"],
-    mode: "key-encryption",
-    subtle: { name: "RSA-OAEP", hash: `SHA-${bits}` },
-    usages: wrap,
-    ops: ["wrapKey", "unwrapKey"]
-  };
-}
-function ecdh(mode) {
-  return {
-    kty: ["EC", "OKP"],
-    mode,
-    subtle: { name: "ECDH" },
-    resolve: ({ kty, crv, asymmetricKeyType }) => {
-      if (crv === "X25519" || asymmetricKeyType === "x25519")
-        return { name: "X25519" };
-      if (kty === "OKP")
-        throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      return { name: "ECDH", namedCurve: crv };
-    },
-    usages: derive,
-    ops: [void 0, "deriveBits"]
-  };
-}
-function aeskw(bits, gcm = false) {
-  return {
-    kty: ["oct"],
-    mode: "key-wrapping",
-    secret: true,
-    subtle: { name: gcm ? "AES-GCM" : "AES-KW", length: bits },
-    usages: none,
-    ops: gcm ? ["encrypt", "decrypt"] : ["wrapKey", "unwrapKey"]
-  };
-}
-function pbes2() {
-  return {
-    kty: ["oct"],
-    mode: "key-wrapping",
-    secret: true,
-    subtle: { name: "PBKDF2" },
-    usages: none,
-    ops: ["deriveBits", "deriveBits"]
-  };
-}
-var JWE = table({
-  dir: {
-    kty: ["oct"],
-    mode: "direct-encryption",
-    secret: true,
-    subtle: { name: "AES-GCM" },
-    usages: none,
-    ops: ["encrypt", "decrypt"]
-  },
-  "RSA-OAEP": rsaes(1),
-  "RSA-OAEP-256": rsaes(256),
-  "RSA-OAEP-384": rsaes(384),
-  "RSA-OAEP-512": rsaes(512),
-  "ECDH-ES": ecdh("direct-key-agreement"),
-  "ECDH-ES+A128KW": ecdh("key-agreement-with-key-wrapping"),
-  "ECDH-ES+A192KW": ecdh("key-agreement-with-key-wrapping"),
-  "ECDH-ES+A256KW": ecdh("key-agreement-with-key-wrapping"),
-  A128KW: aeskw(128),
-  A192KW: aeskw(192),
-  A256KW: aeskw(256),
-  A128GCMKW: aeskw(128, true),
-  A192GCMKW: aeskw(192, true),
-  A256GCMKW: aeskw(256, true),
-  "PBES2-HS256+A128KW": pbes2(),
-  "PBES2-HS384+A192KW": pbes2(),
-  "PBES2-HS512+A256KW": pbes2()
-});
-var contentOps = ["encrypt", "decrypt"];
-function contentEncryption(bits, cbc = false) {
-  return {
-    kty: ["oct"],
-    secret: true,
-    subtle: { name: cbc ? "AES-CBC" : "AES-GCM", length: bits },
-    usages: none,
-    ops: contentOps,
-    cekBits: bits,
-    ivBits: cbc ? 128 : 96,
-    cbc
-  };
-}
-var ENC = table({
-  A128GCM: contentEncryption(128),
-  A192GCM: contentEncryption(192),
-  A256GCM: contentEncryption(256),
-  "A128CBC-HS256": contentEncryption(256, true),
-  "A192CBC-HS384": contentEncryption(384, true),
-  "A256CBC-HS512": contentEncryption(512, true)
-});
-
-// ../../node_modules/jose/dist/webapi/lib/jws_algorithms.js
+// node_modules/jose/dist/webapi/lib/jws_algorithms.js
 var sig = [["verify"], ["sign"]];
 function hmac(bits) {
   const subtle = { name: "HMAC", hash: `SHA-${bits}` };
@@ -582,59 +412,7 @@ function jwsAlgorithm(alg) {
   return entry;
 }
 
-// ../../node_modules/jose/dist/webapi/lib/jws_verify.js
-function prepareVerify(options) {
-  return [options && validateAlgorithms("algorithms", options.algorithms), options?.crit];
-}
-function parseProtectedHeader(encodedProtected) {
-  return encodedProtected === void 0 ? {} : parseJoseHeader(encodedProtected, JWSInvalid, "JWS Protected Header is invalid");
-}
-function encodeCompactUnencodedPayload(payload) {
-  try {
-    return encode(payload);
-  } catch {
-    throw new JWSInvalid("JWS Compact Serialization payload must use only ASCII characters");
-  }
-}
-async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedProtected) {
-  const { protected: encodedProtected, header, payload: inputPayload } = jws, parsedProt = parsedProtected ?? parseProtectedHeader(encodedProtected);
-  if (!isDisjoint(parsedProt, header))
-    throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
-  const joseHeader = { ...parsedProt, ...header }, b64 = validateB64(parsedProt, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader)), { alg } = joseHeader;
-  if (typeof alg != "string" || !alg)
-    throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
-  if (shared[0] && !shared[0].has(alg))
-    throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
-  if (b64) {
-    if (typeof inputPayload != "string")
-      throw new JWSInvalid("JWS Payload must be a string");
-  } else if (typeof inputPayload != "string" && !(inputPayload instanceof Uint8Array))
-    throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
-  const signingPayload = b64 || typeof inputPayload != "string" ? inputPayload : encodeUnencodedPayload(inputPayload);
-  let resolvedKey = false;
-  typeof key == "function" && (key = await key(parsedProt, jws), resolvedKey = true);
-  const entry = jwsAlgorithm(alg), data = concat(encodedProtected !== void 0 ? encode(encodedProtected) : new Uint8Array(), encode("."), typeof signingPayload == "string" ? shared[2] ??= encodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload), signature = decodeBase64url(jws.signature, "signature", JWSInvalid), k = await prepareKey(entry, key, "verify"), cryptoKey = await rawKey(k, entry.subtle, "verify");
-  entry.minRsaBits && checkModulusLength(entry.alg, cryptoKey);
-  let verified = false;
-  try {
-    verified = await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-  } catch {
-  }
-  if (!verified)
-    throw new JWSSignatureVerificationFailed();
-  const result = { payload: typeof signingPayload == "string" ? decodeBase64url(signingPayload, "payload", JWSInvalid) : signingPayload };
-  return encodedProtected !== void 0 && (result.protectedHeader = parsedProt), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? [{ ...result, key: k }, b64] : [result, b64];
-}
-async function verifyCompact(jws, shared, key) {
-  if (jws instanceof Uint8Array && (jws = decoder.decode(jws)), typeof jws != "string")
-    throw new JWSInvalid("Compact JWS must be a string or Uint8Array");
-  const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split(".");
-  if (length !== 3)
-    throw new JWSInvalid("Invalid Compact JWS");
-  return verifySignature({ payload, protected: protectedHeader, signature }, shared, key, encodeCompactUnencodedPayload);
-}
-
-// ../../node_modules/jose/dist/webapi/lib/jwt_claims_set.js
+// node_modules/jose/dist/webapi/lib/jwt_claims_set.js
 var epoch = (date) => Math.floor(date.getTime() / 1e3);
 var multipliers = {
   s: 1,
@@ -645,7 +423,6 @@ var multipliers = {
   y: 31557600
 };
 var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-var checkFailed = "check_failed";
 function invalidDuration() {
   throw new TypeError("Invalid time period format");
 }
@@ -672,64 +449,6 @@ function validateAudienceClaim(value) {
 function numericDate(value, label) {
   return typeof value == "number" ? validateInput(label, value) : value instanceof Date ? validateInput(label, epoch(value)) : epoch(/* @__PURE__ */ new Date()) + secs(value);
 }
-var normalizeTyp = (value) => {
-  const normalized = value.toLowerCase();
-  return value.includes("/") ? normalized : `application/${normalized}`;
-};
-var checkAudiencePresence = (audPayload, audOption) => typeof audPayload == "string" ? audOption.includes(audPayload) : Array.isArray(audPayload) ? audOption.some((aud) => audPayload.includes(aud)) : false;
-function validateNumericDate(payload, claim, required = false) {
-  const value = payload[claim];
-  if (!(value === void 0 && !required)) {
-    if (typeof value != "number")
-      throw new JWTClaimValidationFailed(`"${claim}" claim must be a number`, payload, claim, "invalid");
-    return value;
-  }
-}
-function unexpectedClaim(payload, claim) {
-  throw new JWTClaimValidationFailed(`unexpected "${claim}" claim value`, payload, claim, checkFailed);
-}
-function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
-  let payload;
-  try {
-    payload = JSON.parse(strictDecoder.decode(encodedPayload));
-  } catch {
-  }
-  if (!isObject(payload))
-    throw new JWTInvalid("JWT Claims Set must be a top-level JSON object");
-  const { typ } = options;
-  if (typ !== void 0 && (typeof protectedHeader.typ != "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ)))
-    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", checkFailed);
-  const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options, presenceCheck = [...requiredClaims];
-  maxTokenAge !== void 0 && presenceCheck.push("iat"), audience !== void 0 && presenceCheck.push("aud"), subject !== void 0 && presenceCheck.push("sub"), issuer !== void 0 && presenceCheck.push("iss");
-  for (const claim of new Set(presenceCheck.reverse()))
-    if (!Object.hasOwn(payload, claim))
-      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
-  issuer !== void 0 && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss) && unexpectedClaim(payload, "iss"), subject !== void 0 && payload.sub !== subject && unexpectedClaim(payload, "sub"), audience !== void 0 && !checkAudiencePresence(payload.aud, typeof audience == "string" ? [audience] : audience) && unexpectedClaim(payload, "aud");
-  const { clockTolerance } = options;
-  let tolerance = 0;
-  if (typeof clockTolerance == "string")
-    tolerance = secs(clockTolerance);
-  else if (clockTolerance !== void 0) {
-    if (typeof clockTolerance != "number")
-      throw new TypeError("Invalid clockTolerance option type");
-    tolerance = clockTolerance;
-  }
-  validateInput("clockTolerance option", tolerance);
-  const { currentDate } = options, now = validateInput("currentDate option", epoch(currentDate === void 0 ? /* @__PURE__ */ new Date() : currentDate)), iat = validateNumericDate(payload, "iat", maxTokenAge !== void 0), nbf = validateNumericDate(payload, "nbf");
-  if (nbf !== void 0 && nbf > now + tolerance)
-    throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", checkFailed);
-  const exp = validateNumericDate(payload, "exp");
-  if (exp !== void 0 && exp <= now - tolerance)
-    throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", checkFailed);
-  if (maxTokenAge !== void 0) {
-    const age = now - iat, max = validateInput("maxTokenAge option", typeof maxTokenAge == "number" ? maxTokenAge : secs(maxTokenAge));
-    if (age - tolerance > max)
-      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", checkFailed);
-    if (age < -tolerance)
-      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", checkFailed);
-  }
-  return payload;
-}
 var producerPayloads;
 function producerPayload(producer) {
   return producerPayloads.get(producer);
@@ -773,16 +492,7 @@ var JWTClaimsBuilder = class {
   }
 };
 
-// ../../node_modules/jose/dist/webapi/jwt/verify.js
-async function jwtVerify(jwt, key, options) {
-  const [verified, b64] = await verifyCompact(jwt, prepareVerify(options), key);
-  if (!b64)
-    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
-  const payload = validateClaimsSet(verified.protectedHeader, verified.payload, options);
-  return { ...verified, payload };
-}
-
-// ../../node_modules/jose/dist/webapi/lib/jws_sign.js
+// node_modules/jose/dist/webapi/lib/jws_sign.js
 async function createSignature(input, key, rejectUnencoded) {
   let [payload, protectedHeader, unprotectedHeader, crit] = input, protectedHeaderString = "";
   if (protectedHeader !== void 0) {
@@ -820,7 +530,7 @@ async function createCompactSignature(payload, protectedHeader, crit, key, rejec
   return `${jws.protected}.${jws.payload}.${jws.signature}`;
 }
 
-// ../../node_modules/jose/dist/webapi/jwt/sign.js
+// node_modules/jose/dist/webapi/jwt/sign.js
 var SignJWT_base = JWTClaimsBuilder;
 var SignJWT = class extends SignJWT_base {
   #protectedHeader;
@@ -834,123 +544,95 @@ var SignJWT = class extends SignJWT_base {
   }
 };
 
-// ../../node_modules/jose/dist/webapi/lib/key_algorithm.js
-function unsupportedAlg(source = 'JWK "alg" (Algorithm) Parameter') {
-  throw new JOSENotSupported(`Invalid or unsupported ${source} value`);
+// src/crypto.ts
+var privateJwkMembers = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth", "k"]);
+function algorithm(value) {
+  if (value !== "ES256" && value !== "RS256") {
+    throw new TypeError("PAP JOSE algorithms must be ES256 or RS256");
+  }
+  return value;
 }
-function keyAlgorithm(alg, source) {
-  return (typeof alg == "string" ? JWS[alg] ?? JWE[alg] : void 0) ?? unsupportedAlg(source);
+function publicJwk(value, alg) {
+  for (const member of privateJwkMembers) {
+    if (member in value) {
+      throw new TypeError("DPoP public JWK must not contain private key material");
+    }
+  }
+  const expected = alg === "ES256" ? "EC" : "RSA";
+  if (value.kty !== expected) throw new TypeError(`${alg} requires a ${expected} public JWK`);
+  if (alg === "ES256") {
+    if (value.crv !== "P-256" || !value.x || !value.y) {
+      throw new TypeError("ES256 requires a complete P-256 public JWK");
+    }
+  } else if (!value.n || !value.e) {
+    throw new TypeError("RS256 requires a complete RSA public JWK");
+  }
+  return { ...value };
 }
-
-// ../../node_modules/jose/dist/webapi/key/export.js
-async function exportJWK(key) {
-  if (isKeyObject(key))
-    if (key.type === "secret")
-      key = key.export();
-    else
-      return key.export({ format: "jwk" });
-  if (key instanceof Uint8Array)
-    return {
-      kty: "oct",
-      k: encode2(key)
-    };
-  if (!isCryptoKey(key))
-    throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "Uint8Array"));
-  if (!key.extractable)
-    throw new TypeError("non-extractable CryptoKey cannot be exported as a JWK");
-  const jwk = await crypto.subtle.exportKey("jwk", key);
-  delete jwk.ext, delete jwk.key_ops, delete jwk.use, jwk.kty !== "AKP" && delete jwk.alg;
-  for (const parameter of Object.keys(jwk))
-    jwk[parameter] === void 0 && delete jwk[parameter];
-  return jwk;
+function normalizedHtu(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch (cause) {
+    throw new ProofError("invalid_htu", "DPoP target must be an HTTPS URL", { cause });
+  }
+  if (url.protocol !== "https:" || url.username || url.password) {
+    throw new ProofError("invalid_htu", "DPoP target must be an HTTPS URL");
+  }
+  url.search = "";
+  url.hash = "";
+  return url.href;
 }
-
-// ../../node_modules/jose/dist/webapi/jwk/thumbprint.js
-var check = (value, description) => {
-  if (typeof value != "string" || !value)
-    throw new JWKInvalid(`${description} missing or invalid`);
-};
-async function calculateJwkThumbprint(key, digestAlgorithm) {
-  let jwk;
-  if (isObject(key)) {
-    if (jwk = snapshotJwk(key), typeof jwk.kty != "string")
-      throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
-  } else if (isKeyLike(key))
-    jwk = snapshotJwk(await exportJWK(key));
-  else
-    throw new TypeError(invalidKeyInput(key, "CryptoKey", "KeyObject", "JSON Web Key"));
-  if (digestAlgorithm ??= "sha256", digestAlgorithm !== "sha256" && digestAlgorithm !== "sha384" && digestAlgorithm !== "sha512")
-    throw new TypeError('digestAlgorithm must one of "sha256", "sha384", or "sha512"');
-  let components;
-  switch (jwk.kty) {
-    case "AKP":
-      check(jwk.alg, '"alg" (Algorithm) Parameter'), check(jwk.pub, '"pub" (Public key) Parameter'), components = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
-      break;
-    case "EC":
-      check(jwk.crv, '"crv" (Curve) Parameter'), check(jwk.x, '"x" (X Coordinate) Parameter'), check(jwk.y, '"y" (Y Coordinate) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y };
-      break;
-    case "OKP":
-      check(jwk.crv, '"crv" (Subtype of Key Pair) Parameter'), check(jwk.x, '"x" (Public Key) Parameter'), components = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
-      break;
-    case "RSA":
-      check(jwk.e, '"e" (Exponent) Parameter'), check(jwk.n, '"n" (Modulus) Parameter'), components = { e: jwk.e, kty: jwk.kty, n: jwk.n };
-      break;
-    case "oct":
-      if (typeof jwk.k != "string")
-        throw new JWKInvalid('"k" (Key Value) Parameter missing or invalid');
-      components = { k: jwk.k, kty: jwk.kty };
-      break;
-    default:
-      throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
-  }
-  const data = encode(JSON.stringify(components));
-  return encode2(await digest(digestAlgorithm, data));
+function base64Url(bytes) {
+  let binary = "";
+  for (const value of bytes) binary += String.fromCharCode(value);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
 }
-
-// ../../node_modules/jose/dist/webapi/key/import.js
-async function importJWK(jwk, alg, options) {
-  if (!isObject(jwk))
-    throw new TypeError("JWK must be an object");
-  const normalized = normalizeJwk(jwk), extractable = validateExtractableOption(options?.extractable), { alg: jwkAlg } = normalized;
-  if (alg ??= jwkAlg, normalized.kty !== "oct" && !alg)
-    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-  switch (normalized.kty) {
-    case "oct":
-      if (typeof normalized.k != "string")
-        throw new TypeError('missing "k" (Key Value) Parameter value');
-      return decode(normalized.k);
-    case "AKP": {
-      if (typeof jwkAlg != "string" || !jwkAlg)
-        throw new TypeError('missing "alg" (Algorithm) Parameter value');
-      if (alg !== jwkAlg)
-        throw new TypeError("JWK alg and alg option value mismatch");
-      return jwkToKey(keyAlgorithm(alg), normalized, extractable);
-    }
-    case "RSA":
-    case "EC":
-    case "OKP":
-      return jwkToKey(keyAlgorithm(alg), normalized, extractable);
-    default:
-      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
-  }
+function randomBytes(length) {
+  if (!globalThis.crypto) throw new ProofError("crypto_unavailable", "Web Crypto is required");
+  return globalThis.crypto.getRandomValues(new Uint8Array(length));
 }
-
-// ../../node_modules/jose/dist/webapi/util/decode_protected_header.js
-function decodeProtectedHeader(token) {
-  let protectedB64u;
-  if (typeof token == "string") {
-    const parts = token.split(".");
-    (parts.length === 3 || parts.length === 5) && ([protectedB64u] = parts);
-  } else if (typeof token == "object" && token)
-    if ("protected" in token)
-      protectedB64u = token.protected;
-    else
-      throw new TypeError("Token does not contain a Protected Header");
-  const invalid2 = "Invalid Token or Protected Header formatting";
-  if (typeof protectedB64u != "string" || !protectedB64u)
-    throw new TypeError(invalid2);
-  return parseJoseHeader(protectedB64u, TypeError, invalid2);
+async function accessTokenHash(token) {
+  if (!globalThis.crypto) throw new ProofError("crypto_unavailable", "Web Crypto is required");
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(token.reveal())
+  );
+  return base64Url(new Uint8Array(digest));
 }
+var JoseDpopProofProvider = class {
+  #resolveKey;
+  #now;
+  #randomBytes;
+  constructor(options) {
+    this.#resolveKey = options.resolveKey;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#randomBytes = options.randomBytes ?? randomBytes;
+  }
+  async create(request) {
+    const material = await this.#resolveKey(request);
+    const alg = algorithm(material.algorithm ?? "ES256");
+    const jwk = publicJwk(material.publicJwk, alg);
+    const entropy2 = this.#randomBytes(16);
+    if (entropy2.byteLength < 16) {
+      throw new ProofError("weak_randomness", "DPoP proof IDs require 128 random bits");
+    }
+    const claims = {
+      jti: base64Url(entropy2),
+      htm: request.method.toUpperCase(),
+      htu: normalizedHtu(request.url),
+      iat: Math.floor(this.#now().getTime() / 1e3),
+      ...request.nonce === void 0 ? {} : { nonce: request.nonce },
+      ...request.accessToken === void 0 ? {} : { ath: await accessTokenHash(request.accessToken) }
+    };
+    try {
+      const token = await new SignJWT(claims).setProtectedHeader({ typ: "dpop+jwt", alg, jwk }).sign(material.privateKey);
+      return new SecretValue(token);
+    } catch (cause) {
+      throw new ProofError("signing_failed", "Could not sign DPoP proof", { cause });
+    }
+  }
+};
 
 // src/json.ts
 function parseJsonStrict(source) {
@@ -1088,7 +770,27 @@ var StrictJsonParser = class {
   }
 };
 
-// ../../node_modules/@datalayer/reactor/lib/core/contributions.js
+// src/secret.ts
+var SecretValue = class {
+  #value;
+  constructor(value) {
+    if (!value) {
+      throw new ProtocolValidationError("invalid_secret", "Secret value must not be empty");
+    }
+    this.#value = value;
+  }
+  reveal() {
+    return this.#value;
+  }
+  toString() {
+    return "[REDACTED]";
+  }
+  toJSON() {
+    return "[REDACTED]";
+  }
+};
+
+// node_modules/@datalayer/reactor/lib/core/contributions.js
 function defineContributionPoint(id) {
   if (!id) {
     throw new Error("defineContributionPoint: a contribution point needs an id");
@@ -1188,7 +890,7 @@ var ContributionRegistry = class {
   }
 };
 
-// ../../node_modules/@datalayer/reactor/lib/core/commands.js
+// node_modules/@datalayer/reactor/lib/core/commands.js
 var CommandRegistry = class {
   byId = /* @__PURE__ */ new Map();
   byPlugin = /* @__PURE__ */ new Map();
@@ -1303,7 +1005,7 @@ var CommandRegistry = class {
   }
 };
 
-// ../../node_modules/@datalayer/reactor/lib/core/activation.js
+// node_modules/@datalayer/reactor/lib/core/activation.js
 var ON_STARTUP = "onStartup";
 var ON_ANY = "*";
 function onContributionPoint(point) {
@@ -1325,12 +1027,12 @@ function activatesAtStartup(declared) {
   return matchesActivation(declared, ON_STARTUP);
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/extension.js
+// node_modules/@datalayer/reactor/lib/core/extension.js
 function isExtension(ref) {
   return typeof ref === "object" && ref !== null && typeof ref.name === "string" && Array.isArray(ref.plugins);
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/gates.js
+// node_modules/@datalayer/reactor/lib/core/gates.js
 function isRefusal(answer) {
   return answer !== true;
 }
@@ -1356,7 +1058,7 @@ function resolveGate(answers, context) {
   };
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/reactor.js
+// node_modules/@datalayer/reactor/lib/core/reactor.js
 function placeholderFor(ref) {
   return {
     name: ref.name,
@@ -2110,7 +1812,7 @@ function buildReactorFromPlugins(pluginsInput, options = {}) {
   };
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/plugin.js
+// node_modules/@datalayer/reactor/lib/core/plugin.js
 function definePlugin(plugin) {
   return plugin;
 }
@@ -2131,7 +1833,7 @@ function mergeWithDefaults(plugin, override) {
   return shallowMergeConfig(defaults, override);
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/origins.js
+// node_modules/@datalayer/reactor/lib/core/origins.js
 var ANY_ORIGIN = "*";
 var OriginNotAllowedError = class extends Error {
   /** The URL that was refused, as it was written. */
@@ -2228,7 +1930,7 @@ function assertOriginAllowed(url, extra = [], what = "a remote") {
   throw new OriginNotAllowedError(url, origin, what);
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/federation.js
+// node_modules/@datalayer/reactor/lib/core/federation.js
 var runtimeOverride;
 var runtimeLoad;
 async function federationRuntime() {
@@ -2308,14 +2010,14 @@ function createFederationLoader() {
 }
 var federationLoader = createFederationLoader();
 
-// ../../node_modules/@datalayer/reactor/lib/core/remote.js
+// node_modules/@datalayer/reactor/lib/core/remote.js
 var SHARED_GLOBAL = "__DATALAYER_REACTOR__";
 function getReactorSharedModules() {
   const target = globalThis;
   return target[SHARED_GLOBAL]?.shared ?? {};
 }
 
-// ../../node_modules/@datalayer/reactor/lib/core/agentTools.js
+// node_modules/@datalayer/reactor/lib/core/agentTools.js
 var AgentTools = defineContributionPoint("reactor.agentTools");
 
 // src/reactor.ts
@@ -2336,6 +2038,12 @@ var RandomSources = defineContributionPoint("pap.randomSource");
 var Signers = defineContributionPoint("pap.signer");
 var KeyStores = defineContributionPoint("pap.keyStore");
 var TokenStores = defineContributionPoint("pap.tokenStore");
+var PairwiseUserIdStores = defineContributionPoint(
+  "pap.pairwiseUserIdStore"
+);
+var AuthorizationStateStores = defineContributionPoint(
+  "pap.authorizationStateStore"
+);
 var Caches = defineContributionPoint("pap.cache");
 var BrowserHandoffs = defineContributionPoint(
   "pap.browserHandoff"
@@ -2371,7 +2079,7 @@ function createPapCorePlugin(options = {}) {
   }
   return definePlugin({
     name: "@datalayer/personal-agent-protocol-core",
-    version: "0.2.0",
+    version: "0.3.1",
     contributionPoints: [
       DiscoveryTransports,
       UrlSafetyPolicies,
@@ -2382,6 +2090,8 @@ function createPapCorePlugin(options = {}) {
       Signers,
       KeyStores,
       TokenStores,
+      PairwiseUserIdStores,
+      AuthorizationStateStores,
       Caches,
       BrowserHandoffs,
       DpopProofProviders
@@ -2428,24 +2138,6 @@ function firstContribution(reactor, point, label) {
 // src/sessions.ts
 var JWT_BEARER_GRANT = "urn:ietf:params:oauth:grant-type:jwt-bearer";
 var JWT_CLIENT_ASSERTION = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
-var SecretValue = class {
-  #value;
-  constructor(value) {
-    if (!value) {
-      throw new ProtocolValidationError("invalid_secret", "Secret value must not be empty");
-    }
-    this.#value = value;
-  }
-  reveal() {
-    return this.#value;
-  }
-  toString() {
-    return "[REDACTED]";
-  }
-  toJSON() {
-    return "[REDACTED]";
-  }
-};
 function defaultRandomBytes(length) {
   const cryptoApi = globalThis.crypto;
   if (!cryptoApi) {
@@ -2453,7 +2145,7 @@ function defaultRandomBytes(length) {
   }
   return cryptoApi.getRandomValues(new Uint8Array(length));
 }
-function base64Url(bytes) {
+function base64Url2(bytes) {
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
   let output = "";
   for (let index = 0; index < bytes.length; index += 3) {
@@ -2476,11 +2168,19 @@ function opaqueId(prefix, randomBytes2) {
   if (bytes.byteLength < 16) {
     throw new Error("Opaque PAP identifiers require at least 128 random bits");
   }
-  return `${prefix}_${base64Url(bytes)}`;
+  return `${prefix}_${base64Url2(bytes)}`;
 }
 function generatePairwiseUserId(randomBytes2 = defaultRandomBytes) {
   return opaqueId("usr", randomBytes2);
 }
+async function resolvePairwiseUserId(reactor, options) {
+  const store = firstContribution(
+    reactor,
+    PairwiseUserIdStores,
+    "pairwise user ID store"
+  );
+  return store.getOrCreate(options);
+}
 function httpsUrl(value, label) {
   let parsed;
   try {
@@ -2758,209 +2458,37 @@ var SessionClient = class {
   }
 };
 
-// src/crypto.ts
-var privateJwkMembers = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth", "k"]);
-function algorithm(value) {
-  if (value !== "ES256" && value !== "RS256") {
-    throw new TypeError("PAP JOSE algorithms must be ES256 or RS256");
+// src/auth.ts
+function defaultRandomBytes2(length) {
+  if (!globalThis.crypto) {
+    throw new AuthorizationError("crypto_unavailable", "Web Crypto is required");
+  }
+  return globalThis.crypto.getRandomValues(new Uint8Array(length));
+}
+function entropy(length, randomBytes2) {
+  const value = randomBytes2(length);
+  if (value.byteLength < length) {
+    throw new AuthorizationError(
+      "weak_entropy",
+      `Authorization requires ${length * 8} random bits`
+    );
   }
   return value;
 }
-function publicJwk(value, alg) {
-  for (const member of privateJwkMembers) {
-    if (member in value) {
-      throw new TypeError("DPoP public JWK must not contain private key material");
+function base64Url3(bytes) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let output = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index] ?? 0;
+    const second = bytes[index + 1];
+    const third = bytes[index + 2];
+    output += alphabet[first >>> 2];
+    output += alphabet[(first & 3) << 4 | (second ?? 0) >>> 4];
+    if (second !== void 0) {
+      output += alphabet[(second & 15) << 2 | (third ?? 0) >>> 6];
     }
-  }
-  const expected = alg === "ES256" ? "EC" : "RSA";
-  if (value.kty !== expected) throw new TypeError(`${alg} requires a ${expected} public JWK`);
-  if (alg === "ES256") {
-    if (value.crv !== "P-256" || !value.x || !value.y) {
-      throw new TypeError("ES256 requires a complete P-256 public JWK");
-    }
-  } else if (!value.n || !value.e) {
-    throw new TypeError("RS256 requires a complete RSA public JWK");
-  }
-  return { ...value };
-}
-function normalizedHtu(value) {
-  let url;
-  try {
-    url = new URL(value);
-  } catch (cause) {
-    throw new ProofError("invalid_htu", "DPoP target must be an HTTPS URL", { cause });
-  }
-  if (url.protocol !== "https:" || url.username || url.password) {
-    throw new ProofError("invalid_htu", "DPoP target must be an HTTPS URL");
-  }
-  url.search = "";
-  url.hash = "";
-  return url.href;
-}
-function base64Url2(bytes) {
-  let binary = "";
-  for (const value of bytes) binary += String.fromCharCode(value);
-  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
-}
-function randomBytes(length) {
-  if (!globalThis.crypto) throw new ProofError("crypto_unavailable", "Web Crypto is required");
-  return globalThis.crypto.getRandomValues(new Uint8Array(length));
-}
-async function accessTokenHash(token) {
-  if (!globalThis.crypto) throw new ProofError("crypto_unavailable", "Web Crypto is required");
-  const digest2 = await globalThis.crypto.subtle.digest(
-    "SHA-256",
-    new TextEncoder().encode(token.reveal())
-  );
-  return base64Url2(new Uint8Array(digest2));
-}
-var JoseSigner = class {
-  #privateKey;
-  #algorithm;
-  #keyId;
-  constructor(options) {
-    this.#privateKey = options.privateKey;
-    this.#algorithm = algorithm(options.algorithm ?? "ES256");
-    this.#keyId = options.keyId;
-  }
-  async sign(claims, _options) {
-    try {
-      const token = await new SignJWT(claims).setProtectedHeader({
-        alg: this.#algorithm,
-        typ: "JWT",
-        ...this.#keyId === void 0 ? {} : { kid: this.#keyId }
-      }).sign(this.#privateKey);
-      return new SecretValue(token);
-    } catch (cause) {
-      throw new ProofError("signing_failed", "Could not sign PAP assertion", { cause });
-    }
-  }
-};
-var JoseDpopProofProvider = class {
-  #resolveKey;
-  #now;
-  #randomBytes;
-  constructor(options) {
-    this.#resolveKey = options.resolveKey;
-    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
-    this.#randomBytes = options.randomBytes ?? randomBytes;
-  }
-  async create(request) {
-    const material = await this.#resolveKey(request);
-    const alg = algorithm(material.algorithm ?? "ES256");
-    const jwk = publicJwk(material.publicJwk, alg);
-    const entropy2 = this.#randomBytes(16);
-    if (entropy2.byteLength < 16) {
-      throw new ProofError("weak_randomness", "DPoP proof IDs require 128 random bits");
-    }
-    const claims = {
-      jti: base64Url2(entropy2),
-      htm: request.method.toUpperCase(),
-      htu: normalizedHtu(request.url),
-      iat: Math.floor(this.#now().getTime() / 1e3),
-      ...request.nonce === void 0 ? {} : { nonce: request.nonce },
-      ...request.accessToken === void 0 ? {} : { ath: await accessTokenHash(request.accessToken) }
-    };
-    try {
-      const token = await new SignJWT(claims).setProtectedHeader({ typ: "dpop+jwt", alg, jwk }).sign(material.privateKey);
-      return new SecretValue(token);
-    } catch (cause) {
-      throw new ProofError("signing_failed", "Could not sign DPoP proof", { cause });
-    }
-  }
-};
-async function verifyDpopProof(proof, options) {
-  const compact = proof instanceof SecretValue ? proof.reveal() : proof;
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const windowSeconds = options.acceptanceWindowSeconds ?? 60;
-  if (!Number.isInteger(windowSeconds) || windowSeconds <= 0) {
-    throw new RangeError("acceptanceWindowSeconds must be a positive integer");
-  }
-  let jwk;
-  let payload;
-  try {
-    const header = decodeProtectedHeader(compact);
-    const alg = algorithm(header.alg ?? "");
-    if (header.typ !== "dpop+jwt" || typeof header.jwk !== "object") {
-      throw new ProofError("invalid_dpop_proof", "DPoP protected header is invalid");
-    }
-    jwk = publicJwk(header.jwk, alg);
-    const key = await importJWK(jwk, alg);
-    ({ payload } = await jwtVerify(compact, key, {
-      algorithms: [alg],
-      typ: "dpop+jwt",
-      requiredClaims: ["jti", "htm", "htu", "iat"]
-    }));
-  } catch (cause) {
-    if (cause instanceof ProofError) throw cause;
-    throw new ProofError("invalid_dpop_proof", "DPoP signature or claims are invalid", {
-      cause
-    });
-  }
-  if (typeof payload.jti !== "string" || !payload.jti || typeof payload.iat !== "number") {
-    throw new ProofError("invalid_dpop_proof", "DPoP proof identity is invalid");
-  }
-  const issuedAt = new Date(payload.iat * 1e3);
-  const difference = Math.abs(now.getTime() - issuedAt.getTime());
-  if (difference > windowSeconds * 1e3) {
-    throw new ProofError("invalid_dpop_proof", "DPoP proof is outside the acceptance window");
-  }
-  if (payload.htm !== options.method.toUpperCase() || payload.htu !== normalizedHtu(options.url)) {
-    throw new ProofError("invalid_dpop_proof", "DPoP proof does not match the request");
-  }
-  if (options.nonce !== void 0 && payload.nonce !== options.nonce) {
-    throw new ProofError("use_dpop_nonce", "DPoP proof nonce is missing or invalid");
-  }
-  if (options.accessToken !== void 0) {
-    if (payload.ath !== await accessTokenHash(options.accessToken)) {
-      throw new ProofError("invalid_dpop_proof", "DPoP access-token hash is invalid");
-    }
-  } else if (payload.ath !== void 0) {
-    throw new ProofError(
-      "invalid_dpop_proof",
-      "Token-endpoint DPoP proof must not contain ath"
-    );
-  }
-  const keyThumbprint = await calculateJwkThumbprint(jwk);
-  if (!await options.replayCache.markOnce(`${keyThumbprint}:${payload.jti}`, {
-    expiresAt: new Date(now.getTime() + windowSeconds * 1e3)
-  })) {
-    throw new ProofError("invalid_dpop_proof", "DPoP proof has already been used");
-  }
-  return { jti: payload.jti, issuedAt, publicJwk: jwk, keyThumbprint };
-}
-
-// src/auth.ts
-function defaultRandomBytes2(length) {
-  if (!globalThis.crypto) {
-    throw new AuthorizationError("crypto_unavailable", "Web Crypto is required");
-  }
-  return globalThis.crypto.getRandomValues(new Uint8Array(length));
-}
-function entropy(length, randomBytes2) {
-  const value = randomBytes2(length);
-  if (value.byteLength < length) {
-    throw new AuthorizationError(
-      "weak_entropy",
-      `Authorization requires ${length * 8} random bits`
-    );
-  }
-  return value;
-}
-function base64Url3(bytes) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-  let output = "";
-  for (let index = 0; index < bytes.length; index += 3) {
-    const first = bytes[index] ?? 0;
-    const second = bytes[index + 1];
-    const third = bytes[index + 2];
-    output += alphabet[first >>> 2];
-    output += alphabet[(first & 3) << 4 | (second ?? 0) >>> 4];
-    if (second !== void 0) {
-      output += alphabet[(second & 15) << 2 | (third ?? 0) >>> 6];
-    }
-    if (third !== void 0) {
-      output += alphabet[third & 63];
+    if (third !== void 0) {
+      output += alphabet[third & 63];
     }
   }
   return output;
@@ -2989,8 +2517,12 @@ async function buildDirectSignInRequest(options) {
   const randomBytes2 = options.randomBytes ?? defaultRandomBytes2;
   const state = base64Url3(entropy(16, randomBytes2));
   const verifier = base64Url3(entropy(32, randomBytes2));
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi) {
+    throw new AuthorizationError("crypto_unavailable", "Web Crypto is required");
+  }
   const challenge = base64Url3(
-    new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))
+    new Uint8Array(await cryptoApi.subtle.digest("SHA-256", new TextEncoder().encode(verifier)))
   );
   const endpoint = httpsUrl2(options.authorizationEndpoint, "authorizationEndpoint");
   const scopes2 = validScopes(options.scopes);
@@ -3106,6 +2638,276 @@ var AuthorizationCodeGrant = class {
     };
   }
 };
+async function stateReference(state) {
+  const bytes = new TextEncoder().encode(state);
+  if ([...bytes].some((byte) => byte > 127)) {
+    throw new AuthorizationError("invalid_callback", "Authorization state is invalid");
+  }
+  const cryptoApi = globalThis.crypto;
+  if (!cryptoApi) {
+    throw new AuthorizationError("crypto_unavailable", "Web Crypto is required");
+  }
+  const digest = await cryptoApi.subtle.digest("SHA-256", bytes);
+  return `direct:${Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("")}`;
+}
+function callbackState(callbackUrl) {
+  const callback = httpsUrl2(callbackUrl, "callbackUrl");
+  if (callback.hash) {
+    throw new AuthorizationError("invalid_callback", "Authorization callback has a fragment");
+  }
+  const states = callback.searchParams.getAll("state");
+  if (states.length !== 1 || !states[0]) {
+    throw new AuthorizationError(
+      "invalid_callback",
+      "Authorization callback must contain one state value"
+    );
+  }
+  return states[0];
+}
+function isPendingDirectSignIn(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const pending = value;
+  return pending.kind === "pap.direct-sign-in.v1" && typeof pending.tokenEndpoint === "string" && typeof pending.tenantId === "string" && typeof pending.pairwiseUserId === "string" && typeof pending.sessionId === "string" && pending.expiresAt instanceof Date && typeof pending.request === "object" && pending.request !== null;
+}
+var DirectSignInClient = class {
+  #reactor;
+  #fetch;
+  #maxResponseBytes;
+  constructor(options) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (!fetcher) {
+      throw new AuthorizationError("fetch_unavailable", "A fetch implementation is required");
+    }
+    const maxResponseBytes = options.maxResponseBytes ?? 100 * 1024;
+    if (!Number.isInteger(maxResponseBytes) || maxResponseBytes <= 0) {
+      throw new RangeError("maxResponseBytes must be a positive integer");
+    }
+    this.#reactor = options.reactor;
+    this.#fetch = fetcher;
+    this.#maxResponseBytes = maxResponseBytes;
+  }
+  async begin(options) {
+    const lifetimeSeconds = options.lifetimeSeconds ?? 600;
+    if (!Number.isInteger(lifetimeSeconds) || lifetimeSeconds < 1 || lifetimeSeconds > 900) {
+      throw new RangeError("Direct Sign-In state lifetime must be between 1 and 900 seconds");
+    }
+    if (!options.tenantId || options.tenantId.length > 256) {
+      throw new RangeError("tenantId must contain between 1 and 256 characters");
+    }
+    if (!/^[A-Za-z0-9_-]{1,256}$/.test(options.pairwiseUserId)) {
+      throw new AuthorizationError(
+        "invalid_user_id",
+        "Pairwise user ID must be an opaque URL-safe identifier"
+      );
+    }
+    if (!/^[A-Za-z0-9_-]{1,256}$/.test(options.sessionId)) {
+      throw new AuthorizationError("invalid_session_id", "Invalid PAP session ID");
+    }
+    const clock = firstContribution(this.#reactor, Clocks, "clock");
+    const random = firstContribution(this.#reactor, RandomSources, "random source");
+    const store = firstContribution(
+      this.#reactor,
+      AuthorizationStateStores,
+      "authorization state store"
+    );
+    const browser = firstContribution(this.#reactor, BrowserHandoffs, "browser handoff");
+    const request = await buildDirectSignInRequest({
+      authorizationEndpoint: options.authorizationEndpoint,
+      issuer: options.issuer,
+      clientId: options.clientId,
+      redirectUri: options.redirectUri,
+      scopes: options.scopes,
+      randomBytes: (length) => random.bytes(length)
+    });
+    const tokenEndpoint = httpsUrl2(options.tokenEndpoint, "tokenEndpoint").toString();
+    const expiresAt = new Date(clock.now().getTime() + lifetimeSeconds * 1e3);
+    const reference = await stateReference(request.state.reveal());
+    const pending = {
+      kind: "pap.direct-sign-in.v1",
+      request,
+      tokenEndpoint,
+      tenantId: options.tenantId,
+      pairwiseUserId: options.pairwiseUserId,
+      sessionId: options.sessionId,
+      expiresAt
+    };
+    await store.put(reference, pending, { expiresAt });
+    try {
+      await browser.open(request.authorizationUrl);
+    } catch (cause) {
+      await store.take(reference);
+      throw new AuthorizationError("browser_handoff_failed", "Browser handoff failed", { cause });
+    }
+    return { expiresAt, requestedScopes: request.scopes };
+  }
+  async complete(options) {
+    const state = callbackState(options.callbackUrl);
+    const store = firstContribution(
+      this.#reactor,
+      AuthorizationStateStores,
+      "authorization state store"
+    );
+    const pending = await store.take(await stateReference(state));
+    if (!isPendingDirectSignIn(pending)) {
+      throw new AuthorizationError(
+        "invalid_or_expired_state",
+        "Authorization state is unknown, expired, or already used"
+      );
+    }
+    const clock = firstContribution(this.#reactor, Clocks, "clock");
+    if (clock.now().getTime() > pending.expiresAt.getTime()) {
+      throw new AuthorizationError("invalid_or_expired_state", "Authorization state has expired");
+    }
+    const callback = validateDirectSignInCallback(pending.request, options.callbackUrl);
+    return this.#exchange(pending, callback, options.signal);
+  }
+  async #exchange(pending, callback, signal) {
+    const clock = firstContribution(this.#reactor, Clocks, "clock");
+    const random = firstContribution(this.#reactor, RandomSources, "random source");
+    const signer = firstContribution(this.#reactor, Signers, "signer");
+    const dpop = firstContribution(
+      this.#reactor,
+      DpopProofProviders,
+      "DPoP proof provider"
+    );
+    let nonce;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const iat = Math.floor(clock.now().getTime() / 1e3);
+      const clientAssertion = await signer.sign(
+        {
+          iss: pending.request.clientId,
+          sub: pending.request.clientId,
+          aud: pending.tokenEndpoint,
+          iat,
+          exp: iat + 60,
+          jti: `jti_${base64Url3(entropy(16, (length) => random.bytes(length)))}`
+        },
+        { purpose: "client_assertion" }
+      );
+      const proof = await dpop.create({
+        method: "POST",
+        url: pending.tokenEndpoint,
+        tenantId: pending.tenantId,
+        subject: pending.pairwiseUserId,
+        issuer: pending.request.issuer,
+        ...nonce === void 0 ? {} : { nonce }
+      });
+      const grant = new AuthorizationCodeGrant({
+        code: callback.code.reveal(),
+        redirectUri: pending.request.redirectUri,
+        codeVerifier: pending.request.codeVerifier.reveal(),
+        sessionId: pending.sessionId,
+        clientId: pending.request.clientId,
+        clientAssertion: clientAssertion.reveal()
+      });
+      let response;
+      try {
+        response = await this.#fetch(pending.tokenEndpoint, {
+          method: "POST",
+          headers: { Accept: "application/json", DPoP: proof.reveal() },
+          body: grant.toForm(),
+          credentials: "omit",
+          redirect: "error",
+          ...signal === void 0 ? {} : { signal }
+        });
+      } catch (cause) {
+        throw new AuthorizationError(
+          "request_failed",
+          "Direct Sign-In token exchange failed",
+          { cause }
+        );
+      }
+      const payload = await this.#decode(response);
+      if (response.ok) return this.#result(response, payload, pending);
+      const source = typeof payload === "object" && payload !== null ? payload : {};
+      const remoteCode = "error" in source ? source.error : void 0;
+      const code = typeof remoteCode === "string" ? remoteCode : "http_error";
+      if (code === "use_dpop_nonce" && attempt === 0) {
+        nonce = response.headers.get("dpop-nonce") ?? void 0;
+        if (!nonce) {
+          throw new AuthorizationError(
+            "missing_dpop_nonce",
+            "Company requested a DPoP nonce but did not send one",
+            { statusCode: response.status }
+          );
+        }
+        continue;
+      }
+      throw new AuthorizationError(code, "Company refused the Direct Sign-In token exchange", {
+        statusCode: response.status
+      });
+    }
+    throw new AuthorizationError("use_dpop_nonce", "Company rejected the refreshed DPoP proof");
+  }
+  async #decode(response) {
+    const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim();
+    if (contentType !== "application/json") {
+      throw new AuthorizationError(
+        "invalid_content_type",
+        "Direct Sign-In token endpoint must return JSON",
+        { statusCode: response.status }
+      );
+    }
+    const body = await response.text();
+    if (new TextEncoder().encode(body).byteLength > this.#maxResponseBytes) {
+      throw new AuthorizationError(
+        "response_too_large",
+        "Direct Sign-In response exceeds size limit",
+        { statusCode: response.status }
+      );
+    }
+    try {
+      return parseJsonStrict(body);
+    } catch (cause) {
+      throw new AuthorizationError(
+        "invalid_json",
+        "Direct Sign-In token endpoint returned invalid JSON",
+        { statusCode: response.status, cause }
+      );
+    }
+  }
+  #result(response, payload, pending) {
+    let token;
+    try {
+      token = parseSessionToken(payload);
+    } catch (cause) {
+      throw new AuthorizationError(
+        "invalid_token_response",
+        "Direct Sign-In token response is malformed",
+        { statusCode: response.status, cause }
+      );
+    }
+    if (token.tokenType !== "DPoP" || !token.signedIn) {
+      throw new AuthorizationError(
+        "invalid_token_response",
+        "Direct Sign-In must return a signed-in DPoP Session Token",
+        { statusCode: response.status }
+      );
+    }
+    if (token.sessionId !== pending.sessionId) {
+      throw new AuthorizationError(
+        "session_mismatch",
+        "Direct Sign-In response changed the existing Session",
+        { statusCode: response.status }
+      );
+    }
+    if (token.scopes.some((scope) => !pending.request.scopes.includes(scope))) {
+      throw new AuthorizationError(
+        "scope_escalation",
+        "Company returned a scope that was not requested",
+        { statusCode: response.status }
+      );
+    }
+    return {
+      token,
+      grantedScopes: token.scopes,
+      missingScopes: pending.request.scopes.filter((scope) => !token.scopes.includes(scope))
+    };
+  }
+};
 
 // src/models.ts
 function record(value, label) {
@@ -3421,6 +3223,66 @@ function parseClientMetadata(value) {
     extensions: extensions(source.extensions, "extensions")
   };
 }
+var privateJwkMembers2 = /* @__PURE__ */ new Set(["d", "p", "q", "dp", "dq", "qi", "oth", "k"]);
+function parseJsonWebKey(value) {
+  const source = record(value, "JWKS key");
+  if (Object.keys(source).some((key) => privateJwkMembers2.has(key))) {
+    throw new ProtocolValidationError(
+      "private_jwk",
+      "JWKS keys must not contain private or symmetric key material"
+    );
+  }
+  const kty = oneOf(source.kty, ["EC", "RSA"], "JWKS key kty");
+  const kid = source.kid === void 0 ? void 0 : string(source.kid, "JWKS key kid");
+  const use = source.use === void 0 ? void 0 : oneOf(source.use, ["sig"], "use");
+  const alg = source.alg === void 0 ? void 0 : oneOf(source.alg, ["ES256", "RS256"], "alg");
+  if (kty === "EC") {
+    const crv = oneOf(source.crv, ["P-256"], "EC key crv");
+    const x = string(source.x, "EC key x");
+    const y = string(source.y, "EC key y");
+    if (alg !== void 0 && alg !== "ES256") {
+      throw new ProtocolValidationError(
+        "invalid_jwk_algorithm",
+        "P-256 signing keys may advertise only ES256"
+      );
+    }
+    return {
+      ...source,
+      kty,
+      ...kid === void 0 ? {} : { kid },
+      ...use === void 0 ? {} : { use },
+      ...alg === void 0 ? {} : { alg },
+      crv,
+      x,
+      y
+    };
+  }
+  const n = string(source.n, "RSA key n");
+  const e = string(source.e, "RSA key e");
+  if (alg !== void 0 && alg !== "RS256") {
+    throw new ProtocolValidationError(
+      "invalid_jwk_algorithm",
+      "RSA signing keys may advertise only RS256"
+    );
+  }
+  return {
+    ...source,
+    kty,
+    ...kid === void 0 ? {} : { kid },
+    ...use === void 0 ? {} : { use },
+    ...alg === void 0 ? {} : { alg },
+    n,
+    e
+  };
+}
+function parseJsonWebKeySet(value) {
+  const source = record(value, "JWKS");
+  const keys = array(source.keys, "JWKS keys").map(parseJsonWebKey);
+  if (keys.length === 0) {
+    throw new ProtocolValidationError("invalid_jwks", "JWKS keys must not be empty");
+  }
+  return { ...source, keys };
+}
 function parseOperation(value) {
   const source = record(value, "operation");
   const state = oneOf(
@@ -3623,7 +3485,7 @@ function metadataUrl(issuer) {
   parsed.hash = "";
   return parsed;
 }
-async function readJson(initialUrl, transport, urlPolicy, maxRedirects, maxResponseBytes) {
+async function readJson(initialUrl, transport, urlPolicy, maxRedirects, maxResponseBytes, signal) {
   let current = initialUrl;
   for (let redirects = 0; redirects <= maxRedirects; redirects += 1) {
     await urlPolicy.assertSafe(current);
@@ -3632,7 +3494,8 @@ async function readJson(initialUrl, transport, urlPolicy, maxRedirects, maxRespo
       response = await transport.fetch(current, {
         headers: { Accept: "application/json" },
         redirect: "manual",
-        credentials: "omit"
+        credentials: "omit",
+        ...signal === void 0 ? {} : { signal }
       });
     } catch (cause) {
       throw new DiscoveryError("request_failed", "Discovery request failed", { cause });
@@ -3694,7 +3557,8 @@ async function discoverCompany(domain2, options = {}) {
     transport,
     urlPolicy,
     maxRedirects,
-    maxBytes
+    maxBytes,
+    options.signal
   );
   const document = parseDiscoveryDocument(discovery.value);
   if (document.organization.domain.replace(/^www\./, "") !== requestedDomain.replace(/^www\./, "")) {
@@ -3711,7 +3575,8 @@ async function discoverCompany(domain2, options = {}) {
     transport,
     urlPolicy,
     maxRedirects,
-    maxBytes
+    maxBytes,
+    options.signal
   );
   const oauthMetadata = parseOAuthServerMetadata(metadataResponse.value);
   if (oauthMetadata.issuer !== document.auth.issuer) {
@@ -3729,21 +3594,166 @@ async function discoverCompany(domain2, options = {}) {
     oauthMetadata
   };
 }
+
+// src/identity.ts
+var AgentIdentityClient = class {
+  #reactor;
+  #maxJwksRedirects;
+  #maxResponseBytes;
+  constructor(options = {}) {
+    const maxRedirects = options.maxJwksRedirects ?? 3;
+    const maxBytes = options.maxResponseBytes ?? 100 * 1024;
+    if (!Number.isInteger(maxRedirects) || maxRedirects < 0) {
+      throw new RangeError("maxJwksRedirects must be a non-negative integer");
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes <= 0) {
+      throw new RangeError("maxResponseBytes must be a positive integer");
+    }
+    this.#reactor = options.reactor ?? buildPapReactor(options);
+    this.#maxJwksRedirects = maxRedirects;
+    this.#maxResponseBytes = maxBytes;
+  }
+  async fetchMetadata(clientId, options = {}) {
+    const requested = this.#clientIdUrl(clientId);
+    const value = await this.#readJson(requested, 0, void 0, options.signal);
+    let metadata;
+    try {
+      metadata = parseClientMetadata(value);
+    } catch (cause) {
+      throw new ProtocolValidationError(
+        "invalid_client_metadata",
+        "Client metadata failed protocol validation",
+        { cause }
+      );
+    }
+    if (metadata.client_id !== requested.toString()) {
+      throw new IdentityError(
+        "client_id_mismatch",
+        "Client metadata client_id does not match the URL that was fetched"
+      );
+    }
+    return metadata;
+  }
+  async fetchJwks(clientId, options = {}) {
+    const metadata = await this.fetchMetadata(clientId, options);
+    const jwksUrl = new URL(metadata.jwks_uri);
+    const value = await this.#readJson(
+      jwksUrl,
+      this.#maxJwksRedirects,
+      new URL(metadata.client_id).hostname,
+      options.signal
+    );
+    try {
+      return parseJsonWebKeySet(value);
+    } catch (cause) {
+      throw new ProtocolValidationError(
+        "invalid_jwks",
+        "Personal-agent JWKS failed protocol validation",
+        { cause }
+      );
+    }
+  }
+  #clientIdUrl(clientId) {
+    let requested;
+    try {
+      requested = new URL(clientId);
+    } catch (cause) {
+      throw new IdentityError(
+        "invalid_client_id",
+        "client_id must be a valid HTTPS URL",
+        { cause }
+      );
+    }
+    if (requested.hash) {
+      throw new IdentityError("invalid_client_id", "client_id must not contain a fragment");
+    }
+    return requested;
+  }
+  async #readJson(initialUrl, maxRedirects, requiredHost, signal) {
+    const transport = firstContribution(
+      this.#reactor,
+      DiscoveryTransports,
+      "metadata transport"
+    );
+    const policy2 = firstContribution(
+      this.#reactor,
+      UrlSafetyPolicies,
+      "URL safety policy"
+    );
+    let current = initialUrl;
+    for (let redirects = 0; redirects <= maxRedirects; redirects += 1) {
+      if (requiredHost !== void 0 && current.hostname !== requiredHost) {
+        throw new IdentityError("jwks_domain_mismatch", "JWKS redirect changed agent domain");
+      }
+      await policy2.assertSafe(current);
+      let response;
+      try {
+        response = await transport.fetch(current, {
+          headers: { Accept: "application/json" },
+          redirect: "manual",
+          credentials: "omit",
+          ...signal === void 0 ? {} : { signal }
+        });
+      } catch (cause) {
+        throw new IdentityError("request_failed", "Agent identity request failed", { cause });
+      }
+      if (response.status >= 300 && response.status < 400) {
+        if (redirects === maxRedirects) {
+          const code = maxRedirects === 0 ? "metadata_redirect" : "too_many_redirects";
+          throw new IdentityError(code, "Agent identity endpoint exceeded redirect policy");
+        }
+        const location2 = response.headers.get("location");
+        if (!location2) {
+          throw new IdentityError(
+            "invalid_redirect",
+            "Agent identity redirect has no location"
+          );
+        }
+        current = new URL(location2, current);
+        continue;
+      }
+      if (!response.ok) {
+        throw new IdentityError(
+          "http_error",
+          "Agent identity endpoint returned an unsuccessful status",
+          { statusCode: response.status }
+        );
+      }
+      const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim();
+      if (contentType !== "application/json" && contentType !== "application/jwk-set+json") {
+        throw new IdentityError("invalid_content_type", "Agent identity response must be JSON");
+      }
+      const body = await response.text();
+      if (new TextEncoder().encode(body).byteLength > this.#maxResponseBytes) {
+        throw new IdentityError(
+          "response_too_large",
+          "Agent identity response exceeds size limit"
+        );
+      }
+      return parseJsonStrict(body);
+    }
+    throw new IdentityError("too_many_redirects", "Agent identity endpoint exceeded redirect policy");
+  }
+};
 export {
+  AgentIdentityClient,
   AuthorizationCodeGrant,
   AuthorizationError,
+  AuthorizationStateStores,
   BrowserHandoffs,
   Caches,
   Clocks,
+  DirectSignInClient,
   DiscoveryError,
   DiscoveryTransports,
   DpopProofProviders,
   ExtensionHandlers,
+  IdentityError,
   JWT_BEARER_GRANT,
   JWT_CLIENT_ASSERTION,
   JoseDpopProofProvider,
-  JoseSigner,
   KeyStores,
+  PairwiseUserIdStores,
   PersonalAgentProtocolError,
   ProofError,
   ProtocolProfiles,
@@ -3768,11 +3778,12 @@ export {
   parseConversationEventPage,
   parseDiscoveryDocument,
   parseJsonStrict,
+  parseJsonWebKeySet,
   parseMessage,
   parseOAuthServerMetadata,
   parseOperation,
   parseSessionToken,
-  validateDirectSignInCallback,
-  verifyDpopProof
+  resolvePairwiseUserId,
+  validateDirectSignInCallback
 };
 //# sourceMappingURL=index.js.map