@agentproto/secrets 0.2.6 → 1.0.0

package/dist/pairing/index.mjs

@@ -1,486 +1,54 @@
-import { signTranscript, identityFingerprint, verifyTranscript } from '../chunk-2DL6W33G.mjs';
-import { seal, unseal, SealError } from '../chunk-MVHOJPML.mjs';
-import { generateKeyPairSync, diffieHellman, hkdfSync, createPublicKey, createHash, createPrivateKey, createHmac, timingSafeEqual } from 'crypto';
+import { startClientHandshake, respondToHandshake, respondToLegacyHandshake, parseOfferUrl, derivePairRoot, deriveEpochRoutingToken, deriveEpochAuthToken, deriveEpochTokens, deriveOfferTokens, epochRoutingTokens, startTunnelHandshake, respondToTunnelHandshake } from '../chunk-JNTDSOZQ.mjs';
+export { DEFAULT_PAIR_PAGE, HOSTED_RENDEZVOUS_URL, LEGACY_PAIR_VERSION, OFFER_URL_HOST, OFFER_URL_SCHEME, OFFER_VERSION, PAIRING_PROTOCOL_OUTDATED_MESSAGE, PAIR_PAGE_FP_PLACEHOLDER, PAIR_VERSION, PAIR_WEB_URL, PAIR_WEB_URL_TEMPLATE_CLOUD, PairingError, TUNNEL_E2E_VERSION, TunnelHandshakeError, currentEpoch, decodePairingHello, decodePairingReply, decodeTunnelAccept, decodeTunnelOffer, encodeOfferUrl, encodeOfferWebUrl, encodePairingMessage, encodeTunnelMessage, expectedPairHost, importPairRootKey, resolvePairPageUrl } from '../chunk-JNTDSOZQ.mjs';
+import '../chunk-NQX3KBPW.mjs';
+import { nodeCryptoProvider } from '../chunk-5HUHYBPR.mjs';
+export { nodeCryptoProvider } from '../chunk-5HUHYBPR.mjs';
+import '../chunk-432SC3XS.mjs';
+export { webCryptoProvider } from '../chunk-3YRYO6LK.mjs';
 
 /**
  * @agentproto/secrets v0.1.0-alpha
  * AIP-19 SECRETS.md `defineSecrets` reference implementation.
  */
-var PAIR_VERSION = 1;
-var HKDF_INFO = "agentproto/pair/v1";
-var KEY_LEN = 32;
-var PairingError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "PairingError";
-    this.code = code;
-  }
-};
-function x25519PublicKey(b64Der, what) {
-  try {
-    return createPublicKey({
-      key: Buffer.from(b64Der, "base64"),
-      format: "der",
-      type: "spki"
-    });
-  } catch {
-    throw new PairingError("invalid_key", `invalid ${what} X25519 public key`);
-  }
-}
-function x25519PrivateKey(b64Der, what) {
-  try {
-    return createPrivateKey({
-      key: Buffer.from(b64Der, "base64"),
-      format: "der",
-      type: "pkcs8"
-    });
-  } catch {
-    throw new PairingError("invalid_key", `invalid ${what} X25519 private key`);
-  }
-}
-function transcriptHash(ePubB64, ct0, dePubB64) {
-  return createHash("sha256").update(Buffer.from(ePubB64, "base64")).update(Buffer.from(ct0, "utf8")).update(Buffer.from(dePubB64, "base64")).digest();
-}
-function deriveDirectionKeys(ecdhEphemeral, ecdhStatic, transcript) {
-  const ikm = Buffer.concat([ecdhEphemeral, ecdhStatic]);
-  const okm = Buffer.from(hkdfSync("sha256", ikm, transcript, HKDF_INFO, KEY_LEN * 2));
-  return {
-    kc2d: okm.subarray(0, KEY_LEN),
-    kd2c: okm.subarray(KEY_LEN, KEY_LEN * 2)
-  };
-}
-function startClientHandshake(params) {
-  const daemonStatic = x25519PublicKey(params.daemonX25519Pub, "daemon");
-  const ephemeral = generateKeyPairSync("x25519");
-  const ePubB64 = ephemeral.publicKey.export({ type: "spki", format: "der" }).toString("base64");
-  const payload = {
-    clientPub: ePubB64,
-    clientName: params.clientName,
-    offerToken: params.offerToken
-  };
-  const ct0 = seal(JSON.stringify(payload), params.daemonX25519Pub);
-  const hello = { v: PAIR_VERSION, ePub: ePubB64, ct0 };
-  const complete = (reply) => {
-    if (reply.v !== PAIR_VERSION) {
-      throw new PairingError("malformed_reply", `unsupported reply version ${reply.v}`);
-    }
-    const dePub = x25519PublicKey(reply.dePub, "daemon ephemeral");
-    const transcript = transcriptHash(ePubB64, ct0, reply.dePub);
-    if (!verifyTranscript(params.daemonEd25519Pub, transcript, reply.sig)) {
-      throw new PairingError(
-        "bad_signature",
-        "daemon transcript signature did not verify against the offered key"
-      );
-    }
-    const ecdhEphemeral = diffieHellman({ privateKey: ephemeral.privateKey, publicKey: dePub });
-    const ecdhStatic = diffieHellman({ privateKey: ephemeral.privateKey, publicKey: daemonStatic });
-    const { kc2d, kd2c } = deriveDirectionKeys(ecdhEphemeral, ecdhStatic, transcript);
-    return {
-      sendKey: kc2d,
-      recvKey: kd2c,
-      peerFingerprint: identityFingerprint(params.daemonX25519Pub),
-      transcriptHash: transcript,
-      clientName: params.clientName
-    };
-  };
-  return { hello, complete };
-}
-function respondToHandshake(hello, params) {
-  if (hello.v !== PAIR_VERSION) {
-    throw new PairingError("malformed_hello", `unsupported hello version ${hello.v}`);
-  }
-  const clientEphemeral = x25519PublicKey(hello.ePub, "client ephemeral");
-  let payloadJson;
-  try {
-    payloadJson = unseal(hello.ct0, params.identity.x25519.priv);
-  } catch (err) {
-    if (err instanceof SealError) {
-      throw new PairingError(
-        "unseal_failed",
-        "could not open sealed hello \u2014 wrong daemon key or tampered ct\u2080"
-      );
-    }
-    throw err;
-  }
-  const payload = parseHelloPayload(payloadJson);
-  if (payload.clientPub !== hello.ePub) {
-    throw new PairingError(
-      "ephemeral_mismatch",
-      "sealed clientPub does not match the hello ephemeral key"
-    );
-  }
-  if (!params.verifyOfferToken(payload.offerToken)) {
-    throw new PairingError("offer_rejected", "offer token was rejected (unknown, expired, or spent)");
-  }
-  const daemonEphemeral = generateKeyPairSync("x25519");
-  const dePubB64 = daemonEphemeral.publicKey.export({ type: "spki", format: "der" }).toString("base64");
-  const transcript = transcriptHash(hello.ePub, hello.ct0, dePubB64);
-  const sig = signTranscript(params.identity.ed25519.priv, transcript);
-  const daemonStaticPriv = x25519PrivateKey(params.identity.x25519.priv, "daemon static");
-  const ecdhEphemeral = diffieHellman({ privateKey: daemonEphemeral.privateKey, publicKey: clientEphemeral });
-  const ecdhStatic = diffieHellman({ privateKey: daemonStaticPriv, publicKey: clientEphemeral });
-  const { kc2d, kd2c } = deriveDirectionKeys(ecdhEphemeral, ecdhStatic, transcript);
-  return {
-    reply: { v: PAIR_VERSION, dePub: dePubB64, sig },
-    session: {
-      // Daemon sends on c2d's counterpart: it RECEIVES client→daemon (kc2d)
-      // and SENDS daemon→client (kd2c).
-      sendKey: kd2c,
-      recvKey: kc2d,
-      peerFingerprint: identityFingerprint(payload.clientPub),
-      transcriptHash: transcript,
-      clientName: payload.clientName
-    }
-  };
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null;
-}
-function parseHelloPayload(json) {
-  let parsed;
-  try {
-    parsed = JSON.parse(json);
-  } catch {
-    throw new PairingError("malformed_hello", "sealed hello payload was not valid JSON");
-  }
-  if (!isRecord(parsed) || typeof parsed["clientPub"] !== "string" || typeof parsed["clientName"] !== "string" || typeof parsed["offerToken"] !== "string") {
-    throw new PairingError("malformed_hello", "sealed hello payload is missing required fields");
-  }
-  return {
-    clientPub: parsed["clientPub"],
-    clientName: parsed["clientName"],
-    offerToken: parsed["offerToken"]
-  };
-}
-function encodePairingMessage(message) {
-  return Buffer.from(JSON.stringify(message), "utf8");
-}
-function decodePairingHello(bytes) {
-  const parsed = parseJson(bytes, "malformed_hello");
-  if (!isRecord(parsed) || parsed["v"] !== PAIR_VERSION || typeof parsed["ePub"] !== "string" || typeof parsed["ct0"] !== "string") {
-    throw new PairingError("malformed_hello", "hello message is malformed");
-  }
-  return { v: PAIR_VERSION, ePub: parsed["ePub"], ct0: parsed["ct0"] };
-}
-function decodePairingReply(bytes) {
-  const parsed = parseJson(bytes, "malformed_reply");
-  if (!isRecord(parsed) || parsed["v"] !== PAIR_VERSION || typeof parsed["dePub"] !== "string" || typeof parsed["sig"] !== "string") {
-    throw new PairingError("malformed_reply", "reply message is malformed");
-  }
-  return { v: PAIR_VERSION, dePub: parsed["dePub"], sig: parsed["sig"] };
-}
-function parseJson(bytes, code) {
-  try {
-    return JSON.parse(Buffer.from(bytes).toString("utf8"));
-  } catch {
-    throw new PairingError(code, "message was not valid JSON (truncated or corrupt)");
-  }
-}
-
-// src/pairing/offer-url.ts
-var OFFER_URL_SCHEME = "agentproto:";
-var OFFER_URL_HOST = "pair";
-var OFFER_VERSION = 1;
-function b64ToB64url(b64) {
-  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function b64urlToB64(b64url2) {
-  const replaced = b64url2.replace(/-/g, "+").replace(/_/g, "/");
-  const pad = replaced.length % 4;
-  return pad === 0 ? replaced : replaced + "=".repeat(4 - pad);
-}
-function isB64url(s) {
-  return s.length > 0 && /^[A-Za-z0-9_-]+$/.test(s);
-}
-function encodeOfferUrl(offer) {
-  const params = new URLSearchParams();
-  params.set("v", String(OFFER_VERSION));
-  params.set("rv", offer.rendezvousUrl);
-  params.set("id", offer.fingerprint);
-  params.set("pk", b64ToB64url(offer.daemonX25519Pub));
-  params.set("sk", b64ToB64url(offer.daemonEd25519Pub));
-  params.set("t", offer.token);
-  params.set("exp", String(offer.exp));
-  return `${OFFER_URL_SCHEME}//${OFFER_URL_HOST}?${params.toString()}`;
-}
-function parseOfferUrl(url, opts = {}) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new PairingError("malformed_offer", "offer is not a valid URL");
-  }
-  if (parsed.protocol !== OFFER_URL_SCHEME) {
-    throw new PairingError(
-      "malformed_offer",
-      `offer scheme must be "${OFFER_URL_SCHEME}//" (got "${parsed.protocol}//")`
-    );
-  }
-  const host = parsed.host || parsed.pathname.replace(/^\/+/, "");
-  if (host !== OFFER_URL_HOST) {
-    throw new PairingError("malformed_offer", `offer host must be "${OFFER_URL_HOST}"`);
-  }
-  const q = parsed.searchParams;
-  const v = q.get("v");
-  if (v !== String(OFFER_VERSION)) {
-    throw new PairingError("malformed_offer", `unsupported offer version "${v ?? "(absent)"}"`);
-  }
-  const rendezvousUrl = req(q, "rv");
-  let rvParsed;
-  try {
-    rvParsed = new URL(rendezvousUrl);
-  } catch {
-    throw new PairingError("malformed_offer", "offer `rv` is not a valid URL");
-  }
-  if (rvParsed.protocol !== "ws:" && rvParsed.protocol !== "wss:") {
-    throw new PairingError("malformed_offer", "offer `rv` must be a ws:// or wss:// URL");
-  }
-  const fingerprint = req(q, "id");
-  if (!/^[0-9a-f]{16}$/.test(fingerprint)) {
-    throw new PairingError("malformed_offer", "offer `id` is not a 16-hex fingerprint");
-  }
-  const pkUrl = req(q, "pk");
-  const skUrl = req(q, "sk");
-  if (!isB64url(pkUrl) || !isB64url(skUrl)) {
-    throw new PairingError("malformed_offer", "offer `pk`/`sk` must be base64url");
-  }
-  const daemonX25519Pub = b64urlToB64(pkUrl);
-  const daemonEd25519Pub = b64urlToB64(skUrl);
-  const token = req(q, "t");
-  if (!isB64url(token)) {
-    throw new PairingError("malformed_offer", "offer `t` (token) must be base64url");
-  }
-  const expRaw = req(q, "exp");
-  const exp = Number(expRaw);
-  if (!Number.isInteger(exp) || exp <= 0) {
-    throw new PairingError("malformed_offer", "offer `exp` is not a positive unix timestamp");
-  }
-  if (identityFingerprint(daemonX25519Pub) !== fingerprint) {
-    throw new PairingError(
-      "malformed_offer",
-      "offer `id` does not match fingerprint(pk) \u2014 tampered or corrupt offer"
-    );
-  }
-  if (opts.now !== void 0 && exp * 1e3 <= opts.now) {
-    throw new PairingError("offer_expired", "offer has expired");
-  }
-  return {
-    v: OFFER_VERSION,
-    rendezvousUrl,
-    fingerprint,
-    daemonX25519Pub,
-    daemonEd25519Pub,
-    token,
-    exp
-  };
-}
-function req(q, key) {
-  const v = q.get(key);
-  if (v === null || v === "") {
-    throw new PairingError("malformed_offer", `offer is missing required param "${key}"`);
-  }
-  return v;
-}
 
-// src/pairing/rendezvous.ts
-var HOSTED_RENDEZVOUS_URL = "wss://rdv.agentproto.sh/v1";
-var PAIR_ROOT_INFO = "agentproto/pair-root";
-var RV_ROUTE_INFO_PREFIX = "agentproto/rv-route";
-var RV_ROUTE_SALT = "agentproto/rv-route-salt";
-var ROUTE_TOKEN_LEN = 16;
-var PAIR_ROOT_LEN = 32;
-var MS_PER_DAY = 864e5;
-function toBuf(u8) {
-  return Buffer.isBuffer(u8) ? u8 : Buffer.from(u8);
-}
-function b64url(bytes) {
-  return bytes.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function derivePairRoot(session) {
-  const k1 = toBuf(session.sendKey);
-  const k2 = toBuf(session.recvKey);
-  const [lo, hi] = Buffer.compare(k1, k2) <= 0 ? [k1, k2] : [k2, k1];
-  const ikm = Buffer.concat([lo, hi]);
-  const okm = hkdfSync("sha256", ikm, toBuf(session.transcriptHash), PAIR_ROOT_INFO, PAIR_ROOT_LEN);
-  return Buffer.from(okm).toString("base64");
-}
-function currentEpoch(now = Date.now()) {
-  return Math.floor(now / MS_PER_DAY);
-}
-function deriveEpochRoutingToken(pairRoot, epoch) {
-  const ikm = Buffer.from(pairRoot, "base64");
-  const epochBytes = Buffer.alloc(8);
-  epochBytes.writeBigUInt64BE(BigInt(epoch));
-  const info = Buffer.concat([Buffer.from(RV_ROUTE_INFO_PREFIX, "utf8"), epochBytes]);
-  const okm = hkdfSync("sha256", ikm, Buffer.from(RV_ROUTE_SALT, "utf8"), info, ROUTE_TOKEN_LEN);
-  return b64url(Buffer.from(okm));
-}
-function epochRoutingTokens(pairRoot, now = Date.now()) {
-  const epoch = currentEpoch(now);
-  return [
-    { epoch, token: deriveEpochRoutingToken(pairRoot, epoch) },
-    { epoch: epoch - 1, token: deriveEpochRoutingToken(pairRoot, epoch - 1) }
-  ];
-}
-var TUNNEL_E2E_VERSION = 1;
-var SESSION_INFO = "agentproto/tunnel-e2e/v1";
-var AUTH_INFO = "agentproto/tunnel-e2e/auth/v1";
-var OFFER_MAC_LABEL = "offer/v1";
-var ACCEPT_MAC_LABEL = "accept/v1";
-var KEY_LEN2 = 32;
-var AUTH_KEY_LEN = 32;
-var TunnelHandshakeError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "TunnelHandshakeError";
-    this.code = code;
-  }
-};
-function tokenSalt(token) {
-  return createHash("sha256").update(Buffer.from(token, "utf8")).digest();
-}
-function deriveAuthKey(token) {
-  return Buffer.from(
-    hkdfSync("sha256", Buffer.from(token, "utf8"), tokenSalt(token), AUTH_INFO, AUTH_KEY_LEN)
-  );
-}
-function computeMac(authKey, label, ...parts) {
-  const h = createHmac("sha256", authKey);
-  h.update(Buffer.from(label, "utf8"));
-  for (const p of parts) h.update(p);
-  return h.digest();
-}
-function macMatches(expected, receivedB64) {
-  let received;
-  try {
-    received = Buffer.from(receivedB64, "base64");
-  } catch {
-    return false;
-  }
-  if (received.length !== expected.length) return false;
-  return timingSafeEqual(received, expected);
+// src/pairing/index.ts
+function startClientHandshake2(params, crypto = nodeCryptoProvider) {
+  return startClientHandshake(params, crypto);
 }
-function x25519PublicKey2(b64Der) {
-  try {
-    return createPublicKey({ key: Buffer.from(b64Der, "base64"), format: "der", type: "spki" });
-  } catch {
-    throw new TunnelHandshakeError("invalid_key", "peer ephemeral X25519 public key is invalid");
-  }
+function respondToHandshake2(hello, params, crypto = nodeCryptoProvider) {
+  return respondToHandshake(hello, params, crypto);
 }
-function transcriptHash2(ePubDRaw, ePubHRaw) {
-  return createHash("sha256").update(Buffer.from(SESSION_INFO, "utf8")).update(ePubDRaw).update(ePubHRaw).digest();
+function respondToLegacyHandshake2(helloBytes, identity, crypto = nodeCryptoProvider) {
+  return respondToLegacyHandshake(helloBytes, identity, crypto);
 }
-function deriveDirectionKeys2(ecdh, salt) {
-  const okm = Buffer.from(hkdfSync("sha256", ecdh, salt, SESSION_INFO, KEY_LEN2 * 2));
-  return { kd2h: okm.subarray(0, KEY_LEN2), kh2d: okm.subarray(KEY_LEN2, KEY_LEN2 * 2) };
+function parseOfferUrl2(url, opts = {}, crypto = nodeCryptoProvider) {
+  return parseOfferUrl(url, opts, crypto);
 }
-function generateEphemeral() {
-  const kp = generateKeyPairSync("x25519");
-  const pubRaw = kp.publicKey.export({ type: "spki", format: "der" });
-  return { priv: kp.privateKey, pubB64: pubRaw.toString("base64"), pubRaw };
+function derivePairRoot2(session, crypto = nodeCryptoProvider) {
+  return derivePairRoot(session, crypto);
 }
-function startTunnelHandshake(token) {
-  const authKey = deriveAuthKey(token);
-  const salt = tokenSalt(token);
-  const eph = generateEphemeral();
-  const offer = {
-    v: TUNNEL_E2E_VERSION,
-    ePub: eph.pubB64,
-    mac: computeMac(authKey, OFFER_MAC_LABEL, eph.pubRaw).toString("base64")
-  };
-  const complete = (accept) => {
-    if (accept.v !== TUNNEL_E2E_VERSION) {
-      throw new TunnelHandshakeError(
-        "unsupported_version",
-        `unsupported accept version ${String(accept.v)}`
-      );
-    }
-    const hostPub = x25519PublicKey2(accept.ePub);
-    const hostPubRaw = Buffer.from(accept.ePub, "base64");
-    const expected = computeMac(authKey, ACCEPT_MAC_LABEL, eph.pubRaw, hostPubRaw);
-    if (!macMatches(expected, accept.mac)) {
-      throw new TunnelHandshakeError(
-        "bad_auth",
-        "host accept did not authenticate under the shared tunnel token"
-      );
-    }
-    const ecdh = diffieHellman({ privateKey: eph.priv, publicKey: hostPub });
-    const { kd2h, kh2d } = deriveDirectionKeys2(ecdh, salt);
-    return {
-      // Daemon SENDS daemon→host (kd2h) and RECEIVES host→daemon (kh2d).
-      sendKey: kd2h,
-      recvKey: kh2d,
-      transcriptHash: transcriptHash2(eph.pubRaw, hostPubRaw)
-    };
-  };
-  return { offer, complete };
+function deriveEpochRoutingToken2(pairRoot, epoch, crypto = nodeCryptoProvider) {
+  return deriveEpochRoutingToken(pairRoot, epoch, crypto);
 }
-function respondToTunnelHandshake(offer, token) {
-  if (offer.v !== TUNNEL_E2E_VERSION) {
-    throw new TunnelHandshakeError(
-      "unsupported_version",
-      `unsupported offer version ${String(offer.v)}`
-    );
-  }
-  const authKey = deriveAuthKey(token);
-  const salt = tokenSalt(token);
-  const daemonPub = x25519PublicKey2(offer.ePub);
-  const daemonPubRaw = Buffer.from(offer.ePub, "base64");
-  const expected = computeMac(authKey, OFFER_MAC_LABEL, daemonPubRaw);
-  if (!macMatches(expected, offer.mac)) {
-    throw new TunnelHandshakeError(
-      "bad_auth",
-      "daemon offer did not authenticate under the shared tunnel token"
-    );
-  }
-  const eph = generateEphemeral();
-  const accept = {
-    v: TUNNEL_E2E_VERSION,
-    ePub: eph.pubB64,
-    mac: computeMac(authKey, ACCEPT_MAC_LABEL, daemonPubRaw, eph.pubRaw).toString("base64")
-  };
-  const ecdh = diffieHellman({ privateKey: eph.priv, publicKey: daemonPub });
-  const { kd2h, kh2d } = deriveDirectionKeys2(ecdh, salt);
-  return {
-    accept,
-    session: {
-      // Host SENDS host→daemon (kh2d) and RECEIVES daemon→host (kd2h).
-      sendKey: kh2d,
-      recvKey: kd2h,
-      transcriptHash: transcriptHash2(daemonPubRaw, eph.pubRaw)
-    }
-  };
+function deriveEpochAuthToken2(pairRoot, epoch, crypto = nodeCryptoProvider) {
+  return deriveEpochAuthToken(pairRoot, epoch, crypto);
 }
-function isRecord2(v) {
-  return typeof v === "object" && v !== null;
+function deriveEpochTokens2(pairRoot, epoch, crypto = nodeCryptoProvider) {
+  return deriveEpochTokens(pairRoot, epoch, crypto);
 }
-function encodeTunnelMessage(message) {
-  return Buffer.from(JSON.stringify(message), "utf8");
+function deriveOfferTokens2(offerSecret, crypto = nodeCryptoProvider) {
+  return deriveOfferTokens(offerSecret, crypto);
 }
-function parseJson2(bytes, code) {
-  try {
-    return JSON.parse(Buffer.from(bytes).toString("utf8"));
-  } catch {
-    throw new TunnelHandshakeError(code, "message was not valid JSON (truncated or corrupt)");
-  }
+function epochRoutingTokens2(pairRoot, now = Date.now(), crypto = nodeCryptoProvider) {
+  return epochRoutingTokens(pairRoot, now, crypto);
 }
-function decodeTunnelOffer(bytes) {
-  const parsed = parseJson2(bytes, "malformed_offer");
-  if (!isRecord2(parsed) || parsed["v"] !== TUNNEL_E2E_VERSION || typeof parsed["ePub"] !== "string" || typeof parsed["mac"] !== "string") {
-    throw new TunnelHandshakeError("malformed_offer", "offer message is malformed");
-  }
-  return { v: TUNNEL_E2E_VERSION, ePub: parsed["ePub"], mac: parsed["mac"] };
+function startTunnelHandshake2(token, crypto = nodeCryptoProvider) {
+  return startTunnelHandshake(token, crypto);
 }
-function decodeTunnelAccept(bytes) {
-  const parsed = parseJson2(bytes, "malformed_accept");
-  if (!isRecord2(parsed) || parsed["v"] !== TUNNEL_E2E_VERSION || typeof parsed["ePub"] !== "string" || typeof parsed["mac"] !== "string") {
-    throw new TunnelHandshakeError("malformed_accept", "accept message is malformed");
-  }
-  return { v: TUNNEL_E2E_VERSION, ePub: parsed["ePub"], mac: parsed["mac"] };
+function respondToTunnelHandshake2(offer, token, crypto = nodeCryptoProvider) {
+  return respondToTunnelHandshake(offer, token, crypto);
 }
 
-export { HOSTED_RENDEZVOUS_URL, OFFER_URL_HOST, OFFER_URL_SCHEME, OFFER_VERSION, PAIR_VERSION, PairingError, TUNNEL_E2E_VERSION, TunnelHandshakeError, currentEpoch, decodePairingHello, decodePairingReply, decodeTunnelAccept, decodeTunnelOffer, deriveEpochRoutingToken, derivePairRoot, encodeOfferUrl, encodePairingMessage, encodeTunnelMessage, epochRoutingTokens, parseOfferUrl, respondToHandshake, respondToTunnelHandshake, startClientHandshake, startTunnelHandshake };
+export { deriveEpochAuthToken2 as deriveEpochAuthToken, deriveEpochRoutingToken2 as deriveEpochRoutingToken, deriveEpochTokens2 as deriveEpochTokens, deriveOfferTokens2 as deriveOfferTokens, derivePairRoot2 as derivePairRoot, epochRoutingTokens2 as epochRoutingTokens, parseOfferUrl2 as parseOfferUrl, respondToHandshake2 as respondToHandshake, respondToLegacyHandshake2 as respondToLegacyHandshake, respondToTunnelHandshake2 as respondToTunnelHandshake, startClientHandshake2 as startClientHandshake, startTunnelHandshake2 as startTunnelHandshake };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map