@calimero-network/mero-js 25.0.7 → 25.1.0

package/dist/index.mjs

@@ -48,14 +48,14 @@ function extractErrorMessage(bodyText) {
   return void 0;
 }
 var HTTPError = class extends Error {
-  constructor(status, statusText, url, headers, bodyText) {
+  constructor(status, statusText, url2, headers, bodyText) {
     const explanation = extractErrorMessage(bodyText) ?? (status === 0 && bodyText?.trim() ? bodyText.trim() : void 0);
     super(
       explanation ? `HTTP ${status} ${statusText}: ${explanation}` : `HTTP ${status} ${statusText}`
     );
     this.status = status;
     this.statusText = statusText;
-    this.url = url;
+    this.url = url2;
     this.headers = headers;
     this.bodyText = bodyText;
     this.name = "HTTPError";
@@ -72,8 +72,8 @@ var HTTPError = class extends Error {
   }
 };
 var AuthRevokedError = class extends HTTPError {
-  constructor(reason, status, statusText, url, headers, bodyText) {
-    super(status, statusText, url, headers, bodyText);
+  constructor(reason, status, statusText, url2, headers, bodyText) {
+    super(status, statusText, url2, headers, bodyText);
     this.reason = reason;
     this.name = "AuthRevokedError";
     this.message = `Authentication revoked (${reason}): HTTP ${status} ${statusText}`;
@@ -86,12 +86,12 @@ function headersToRecord(headers) {
   });
   return record;
 }
-function pathForProof(url) {
+function pathForProof(url2) {
   try {
-    return new URL(url).pathname;
+    return new URL(url2).pathname;
   } catch {
-    const query = url.indexOf("?");
-    return query === -1 ? url : url.slice(0, query);
+    const query = url2.indexOf("?");
+    return query === -1 ? url2 : url2.slice(0, query);
   }
 }
 var WebHttpClient = class {
@@ -157,7 +157,7 @@ var WebHttpClient = class {
   }
   async makeRequest(path, init, retryCount = 0, requestStartTime) {
     const MAX_RETRY_ATTEMPTS = 1;
-    const url = this.buildUrl(path);
+    const url2 = this.buildUrl(path);
     const startTime = requestStartTime ?? Date.now();
     const signal = this.createAbortSignal(init);
     const headers = await this.buildHeaders(init?.headers);
@@ -182,7 +182,7 @@ var WebHttpClient = class {
         headersObj,
         await this.transport.authorizeRequest({
           method,
-          path: new URL(url).pathname,
+          path: new URL(url2).pathname,
           // Narrowed by the guard above; `BodyInit` is wider than what can be
           // signed.
           body
@@ -242,7 +242,7 @@ var WebHttpClient = class {
     if (this.transport.getProof) {
       const proof = await this.transport.getProof({
         method: requestInit.method ?? "GET",
-        path: pathForProof(url),
+        path: pathForProof(url2),
         body: requestInit.body
       });
       if (proof) {
@@ -250,13 +250,13 @@ var WebHttpClient = class {
       }
     }
     try {
-      const response = await this.transport.fetch(url, requestInit);
+      const response = await this.transport.fetch(url2, requestInit);
       if (!response.ok) {
         const bodyText = await this.getBodyText(response);
         const httpError = new HTTPError(
           response.status,
           response.statusText,
-          url,
+          url2,
           response.headers,
           bodyText
         );
@@ -274,7 +274,7 @@ var WebHttpClient = class {
             authError,
             response.status,
             response.statusText,
-            url,
+            url2,
             response.headers,
             bodyText
           );
@@ -339,7 +339,7 @@ var WebHttpClient = class {
       throw new HTTPError(
         0,
         "Network Error",
-        url,
+        url2,
         new Headers(),
         error instanceof Error ? error.message : "Unknown error"
       );
@@ -442,7 +442,7 @@ function createBrowserHttpClient(options) {
   const transport2 = {
     // globalThis.fetch must be called as a method on globalThis, not through a
     // variable, or browsers throw "Illegal invocation".
-    fetch: (url, init) => options.fetch ? options.fetch(url, init) : globalThis.fetch(url, init),
+    fetch: (url2, init) => options.fetch ? options.fetch(url2, init) : globalThis.fetch(url2, init),
     baseUrl: options.baseUrl,
     getAuthToken: options.getAuthToken,
     getProof: options.getProof,
@@ -469,7 +469,7 @@ function createNodeHttpClient(options) {
     // Wrap fetch in arrow function to prevent "Illegal invocation" error
     // For globalThis.fetch, call it directly to preserve 'this' context
     // For custom implementations, calling through the variable is safe
-    fetch: isDefaultFetch ? (url, init) => globalThis.fetch(url, init) : (url, init) => fetchImpl(url, init),
+    fetch: isDefaultFetch ? (url2, init) => globalThis.fetch(url2, init) : (url2, init) => fetchImpl(url2, init),
     baseUrl: options.baseUrl,
     getAuthToken: options.getAuthToken,
     getProof: options.getProof,
@@ -1045,10 +1045,10 @@ function compareSemverId(a, b) {
   if (nb) return 1;
   return a < b ? -1 : a > b ? 1 : 0;
 }
-async function fetchRegistry(url, kind, context) {
+async function fetchRegistry(url2, kind, context) {
   return withRetry(
     async () => {
-      const resp = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      const resp = await fetch(url2, { signal: AbortSignal.timeout(1e4) });
       if (!resp.ok) {
         const err = new Error(
           `registry ${kind} fetch failed (${resp.status}) for ${context}`
@@ -1100,9 +1100,9 @@ var AdminApiClient = class {
    * the running `Context.applicationVersion` to detect "a new version exists".
    */
   async getRegistryVersions(registryUrl, packageName) {
-    const url = new URL("/api/v2/bundles", new URL(registryUrl).origin);
-    url.searchParams.set("package", packageName);
-    const resp = await fetchRegistry(url.toString(), "versions", packageName);
+    const url2 = new URL("/api/v2/bundles", new URL(registryUrl).origin);
+    url2.searchParams.set("package", packageName);
+    const resp = await fetchRegistry(url2.toString(), "versions", packageName);
     const bundles = await resp.json();
     return (Array.isArray(bundles) ? bundles : []).map((b) => b.appVersion).filter((v) => typeof v === "string").sort((a, b) => compareSemver(b, a));
   }
@@ -2420,11 +2420,11 @@ function createAdminApiClientFromHttpClient(httpClient, _config) {
 }
 
 // src/auth/index.ts
-function parseAuthCallback(url) {
+function parseAuthCallback(url2) {
   try {
-    const hashIndex = url.indexOf("#");
+    const hashIndex = url2.indexOf("#");
     if (hashIndex === -1) return null;
-    const hash = url.substring(hashIndex + 1);
+    const hash = url2.substring(hashIndex + 1);
     const params = new URLSearchParams(hash);
     const accessToken = params.get("access_token");
     if (!accessToken) return null;
@@ -2781,7 +2781,7 @@ var SseClient = class {
       throw new Error("SseClient needs either `getAuthToken` or `authorize`");
     }
     this.reconnectDelayMs = opts.reconnectDelayMs ?? 3e3;
-    this.fetchImpl = (url, init) => opts.fetch ? opts.fetch(url, init) : globalThis.fetch(url, init);
+    this.fetchImpl = (url2, init) => opts.fetch ? opts.fetch(url2, init) : globalThis.fetch(url2, init);
   }
   on(event, handler) {
     const key = event;
@@ -2846,10 +2846,10 @@ var SseClient = class {
     this.closed = false;
     this.abortController = new AbortController();
     try {
-      const url = `${this.baseUrl}/sse`;
-      const response = await this.fetchImpl(url, {
+      const url2 = `${this.baseUrl}/sse`;
+      const response = await this.fetchImpl(url2, {
         headers: {
-          ...await this.authorize({ method: "GET", path: new URL(url).pathname }),
+          ...await this.authorize({ method: "GET", path: new URL(url2).pathname }),
           "Accept": "text/event-stream"
         },
         signal: this.abortController.signal
@@ -2862,7 +2862,7 @@ var SseClient = class {
             terminal,
             response.status,
             response.statusText,
-            url,
+            url2,
             response.headers,
             bodyText
           );
@@ -2870,7 +2870,7 @@ var SseClient = class {
         throw new HTTPError(
           response.status,
           response.statusText,
-          url,
+          url2,
           response.headers,
           bodyText
         );
@@ -3049,12 +3049,12 @@ var SseClient = class {
       const params = {};
       if (ids.contextIds && ids.contextIds.length > 0) params.contextIds = ids.contextIds;
       if (ids.groupIds && ids.groupIds.length > 0) params.groupIds = ids.groupIds;
-      const url = `${this.baseUrl}/sse/subscription`;
+      const url2 = `${this.baseUrl}/sse/subscription`;
       const body = JSON.stringify({ id: this.sessionId, method, params });
-      const response = await this.fetchImpl(url, {
+      const response = await this.fetchImpl(url2, {
         method: "POST",
         headers: {
-          ...await this.authorize({ method: "POST", path: new URL(url).pathname, body }),
+          ...await this.authorize({ method: "POST", path: new URL(url2).pathname, body }),
           "Content-Type": "application/json"
         },
         body,
@@ -5965,14 +5965,14 @@ function reportDataOf(quote) {
 }
 async function attestRelayNodeKey(opts) {
   const nonce2 = crypto.getRandomValues(new Uint8Array(32));
-  const url = `${opts.relayUrl.replace(/\/+$/, "")}/admin-api/tee/attest`;
+  const url2 = `${opts.relayUrl.replace(/\/+$/, "")}/admin-api/tee/attest`;
   const body = JSON.stringify({
     nonce: hex(nonce2),
     bindNodeKey: true,
     ...opts.verify?.includeCollateral ? { includeCollateral: true } : {}
   });
   const init = { method: "POST", headers: { "Content-Type": "application/json" }, body };
-  const response = opts.fetch ? await opts.fetch(url, init) : await globalThis.fetch(url, init);
+  const response = opts.fetch ? await opts.fetch(url2, init) : await globalThis.fetch(url2, init);
   if (!response.ok) {
     const text = await response.text().catch(() => "");
     throw new Error(`the relay would not attest (HTTP ${response.status})${text ? `: ${text}` : ""}`);
@@ -6294,13 +6294,13 @@ function createSealedFetch(options) {
   };
   return async (input, init) => {
     const request = new Request(input, init);
-    const url = new URL(request.url);
-    if (url.origin !== base.origin || !url.pathname.startsWith(`${basePath}/`)) {
-      throw new Error(`Refusing to send ${url.href} outside the sealed node at ${options.baseUrl}`);
+    const url2 = new URL(request.url);
+    if (url2.origin !== base.origin || !url2.pathname.startsWith(`${basePath}/`)) {
+      throw new Error(`Refusing to send ${url2.href} outside the sealed node at ${options.baseUrl}`);
     }
     const headers = [];
     request.headers.forEach((value, name) => headers.push([name, value]));
-    const head = { method: request.method, path: url.pathname.slice(basePath.length) + url.search, headers };
+    const head = { method: request.method, path: url2.pathname.slice(basePath.length) + url2.search, headers };
     const body = new Uint8Array(await request.arrayBuffer());
     const send = async (open2) => {
       const { requestId, header, envelope } = await sealRequest(open2, head, body);
@@ -6522,7 +6522,7 @@ function createQuoteVerifier(options) {
   const allowedMrtd = measurements(options.allowedMrtd ?? [], "allowedMrtd");
   const allowedImages = (options.allowedMeasurements ?? []).map((image, index) => {
     const label2 = `allowedMeasurements[${index}]`;
-    return REGISTERS.map((register) => measurements([image?.[register] ?? ""], `${label2}.${register}`)[0]).join();
+    return REGISTERS.map((register2) => measurements([image?.[register2] ?? ""], `${label2}.${register2}`)[0]).join();
   });
   const allowedRtmr = [
     measurements(options.allowedRtmr0 ?? [], "allowedRtmr0"),
@@ -6571,7 +6571,7 @@ function createQuoteVerifier(options) {
     if (td.tdAttributes?.length !== 8 || (td.tdAttributes[0] & 1) !== 0) {
       throw new Error("The quote is from a debug TD, or its TD attributes cannot be read");
     }
-    const measured = [td.mrTd, td.rtMr0, td.rtMr1, td.rtMr2, td.rtMr3].map((register) => hex(register));
+    const measured = [td.mrTd, td.rtMr0, td.rtMr1, td.rtMr2, td.rtMr3].map((register2) => hex(register2));
     if (allowedImages.length > 0 && !allowedImages.includes(measured.join())) {
       throw new Error(
         `The measurements (MRTD ${measured[0]}, RTMR0-3 ${measured.slice(1).join(", ")}) are not an image this verifier trusts`
@@ -6581,10 +6581,10 @@ function createQuoteVerifier(options) {
       throw new Error(`MRTD ${measured[0]} is not an image this verifier trusts`);
     }
     const registers = [td.rtMr0, td.rtMr1, td.rtMr2, td.rtMr3];
-    registers.forEach((register, index) => {
+    registers.forEach((register2, index) => {
       const allowed = allowedRtmr[index];
-      if (allowed.length > 0 && !allowed.includes(hex(register))) {
-        throw new Error(`RTMR${index} ${hex(register)} is not one this verifier trusts`);
+      if (allowed.length > 0 && !allowed.includes(hex(register2))) {
+        throw new Error(`RTMR${index} ${hex(register2)} is not one this verifier trusts`);
       }
     });
     if (hex(td.reportData) !== `${nonce2}${reportDataSuffix}`.toLowerCase()) {
@@ -7061,7 +7061,7 @@ async function verifySignedNodeRelease(publishedMrtds, bundle, options = {}) {
     throw new Error(`The signed release is a ${JSON.stringify(release?.role)} release, not a node one`);
   }
   const profiles = Object.values(release.profiles ?? {});
-  const measured = (image) => MEASUREMENTS.every((register) => /^[0-9a-f]{96}$/i.test(String(image?.[register])));
+  const measured = (image) => MEASUREMENTS.every((register2) => /^[0-9a-f]{96}$/i.test(String(image?.[register2])));
   if (typeof release.tag !== "string" || profiles.length === 0 || !profiles.every(measured)) {
     throw new Error("The signed file is not a release's published-mrtds.json: it lists no measured profiles");
   }
@@ -7070,17 +7070,17 @@ async function verifySignedNodeRelease(publishedMrtds, bundle, options = {}) {
   }
   return release;
 }
-async function fetchNodeRelease(url, options = {}) {
-  const response = await (options.fetch ?? fetch)(url, { headers: { accept: "application/json" } });
-  if (!response.ok) throw new Error(`Fetching the node release from ${url} failed: HTTP ${response.status}`);
+async function fetchNodeRelease(url2, options = {}) {
+  const response = await (options.fetch ?? fetch)(url2, { headers: { accept: "application/json" } });
+  if (!response.ok) throw new Error(`Fetching the node release from ${url2} failed: HTTP ${response.status}`);
   let release;
   try {
     release = (await response.json())?.data;
   } catch {
-    throw new Error(`${url} did not answer with JSON`);
+    throw new Error(`${url2} did not answer with JSON`);
   }
   if (typeof release?.version !== "string" || typeof release.publishedMrtds !== "string" || typeof release.bundle !== "string") {
-    throw new Error(`${url} did not answer with a signed node release`);
+    throw new Error(`${url2} did not answer with a signed node release`);
   }
   return { version: release.version, publishedMrtds: release.publishedMrtds, bundle: release.bundle };
 }
@@ -7102,20 +7102,20 @@ function infoUrl(baseUrl) {
   return `${baseUrl.replace(/\/+$/, "")}/admin-api/tee/info`;
 }
 async function readNodeReleaseVersion(baseUrl, givenFetch) {
-  const url = infoUrl(baseUrl);
-  const response = await givenFetch(url, { headers: { accept: "application/json" } });
+  const url2 = infoUrl(baseUrl);
+  const response = await givenFetch(url2, { headers: { accept: "application/json" } });
   if (response.status === 403) {
     const code = await response.json().then((body) => body?.error?.code).catch(() => void 0);
     if (code === "sealed_required") return void 0;
   }
-  if (!response.ok) throw new Error(`Fetching ${url} failed: HTTP ${response.status}`);
+  if (!response.ok) throw new Error(`Fetching ${url2} failed: HTTP ${response.status}`);
   let osImage;
   try {
     osImage = (await response.json())?.data?.osImage;
   } catch {
-    throw new Error(`${url} did not answer with JSON`);
+    throw new Error(`${url2} did not answer with JSON`);
   }
-  if (typeof osImage !== "string") throw new Error(`${url} did not name the node's image`);
+  if (typeof osImage !== "string") throw new Error(`${url2} did not name the node's image`);
   return nodeReleaseVersionFromImage(osImage);
 }
 function cloudNodeReleaseUrl(cloudUrl, version) {
@@ -8725,8 +8725,8 @@ function createProofAuthorizer(credential) {
     return { [REQUEST_PROOF_HEADER]: proof };
   };
 }
-function signedPath(url) {
-  return new URL(url).pathname;
+function signedPath(url2) {
+  return new URL(url2).pathname;
 }
 
 // src/presence/statement.ts
@@ -8913,7 +8913,7 @@ var MeroClient = class {
         const authorizeRequest = this.proofAuthorizer;
         this.relayAdmin = createAdminApiClientFromHttpClient(
           createHttpClient({
-            fetch: (url, init) => fetchImpl ? fetchImpl(url, init) : globalThis.fetch(url, init),
+            fetch: (url2, init) => fetchImpl ? fetchImpl(url2, init) : globalThis.fetch(url2, init),
             baseUrl: relay.relayUrl,
             authorizeRequest
           }),
@@ -9556,9 +9556,9 @@ function writeRelayMap(account, map) {
 }
 function rememberRelay(account, relayUrl, at) {
   const map = readRelayMap(account);
-  const url = relayOrigin(relayUrl);
-  if (at.namespaceId) map.namespaces[at.namespaceId] = url;
-  if (at.contextId) map.contexts[at.contextId] = url;
+  const url2 = relayOrigin(relayUrl);
+  if (at.namespaceId) map.namespaces[at.namespaceId] = url2;
+  if (at.contextId) map.contexts[at.contextId] = url2;
   writeRelayMap(account, map);
 }
 function relayForContext(account, contextId) {
@@ -9941,7 +9941,7 @@ function beginLinkState(account, returnTo) {
   if (!ACCOUNT_HEX.test(account)) {
     throw new Error("accountId must be 64 lowercase hex characters");
   }
-  const url = new URL(returnTo);
+  const url2 = new URL(returnTo);
   const now = Date.now();
   const pending = readPending(now);
   const bytes = crypto.getRandomValues(new Uint8Array(16));
@@ -9950,8 +9950,8 @@ function beginLinkState(account, returnTo) {
   );
   pending[state] = { account, expiresAt: now + LIFETIME_MS };
   writePending(Object.fromEntries(Object.entries(pending).slice(-MAX_PENDING)));
-  url.searchParams.set(STATE_PARAM, state);
-  return url.toString();
+  url2.searchParams.set(STATE_PARAM, state);
+  return url2.toString();
 }
 function takeLinkState(search) {
   const state = new URLSearchParams(search).get(STATE_PARAM);
@@ -9973,10 +9973,10 @@ function withoutLinkState(search) {
 // src/cloud/link-redirect.ts
 var DEFAULT_CLOUD_WEB_URL = "https://cloud.calimero.network";
 function cloudLinkUrl(options) {
-  const url = new URL(options.cloudWebUrl ?? DEFAULT_CLOUD_WEB_URL);
-  url.searchParams.set("link-account", options.accountId);
-  url.searchParams.set("callback-url", beginLinkState(options.accountId, options.returnTo));
-  return url.toString();
+  const url2 = new URL(options.cloudWebUrl ?? DEFAULT_CLOUD_WEB_URL);
+  url2.searchParams.set("link-account", options.accountId);
+  url2.searchParams.set("callback-url", beginLinkState(options.accountId, options.returnTo));
+  return url2.toString();
 }
 function beginCloudLink(options) {
   window.location.assign(cloudLinkUrl(options));
@@ -10032,12 +10032,12 @@ function deviceEnrolmentUrl(options) {
   assertHex(options.kemPublicKey, "kemPublicKey");
   assertSafeReturnTo(options.returnTo);
   warnOnForeignCallback(options.returnTo);
-  const url = new URL(options.walletUrl);
-  url.searchParams.set(DEVICE_PARAM, options.devicePublicKey);
-  url.searchParams.set(KEM_PARAM, options.kemPublicKey);
-  url.searchParams.set(CALLBACK_PARAM, options.returnTo);
-  if (options.state) url.searchParams.set(STATE_PARAM2, options.state);
-  return url.toString();
+  const url2 = new URL(options.walletUrl);
+  url2.searchParams.set(DEVICE_PARAM, options.devicePublicKey);
+  url2.searchParams.set(KEM_PARAM, options.kemPublicKey);
+  url2.searchParams.set(CALLBACK_PARAM, options.returnTo);
+  if (options.state) url2.searchParams.set(STATE_PARAM2, options.state);
+  return url2.toString();
 }
 function beginDeviceEnrolment(options) {
   window.location.assign(deviceEnrolmentUrl(options));
@@ -10122,17 +10122,17 @@ function warnOnForeignCallback(returnTo) {
   );
 }
 function assertSafeReturnTo(returnTo) {
-  let url;
+  let url2;
   try {
-    url = new URL(returnTo);
+    url2 = new URL(returnTo);
   } catch {
     throw new Error(`returnTo must be an absolute URL, got ${returnTo}`);
   }
-  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]" || url.hostname === "::1";
-  if (url.protocol === "https:") return;
-  if (url.protocol === "http:" && loopback) return;
+  const loopback = url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.hostname === "[::1]" || url2.hostname === "::1";
+  if (url2.protocol === "https:") return;
+  if (url2.protocol === "http:" && loopback) return;
   throw new Error(
-    `returnTo must be https:, or http: on localhost \u2014 got ${url.protocol}//${url.hostname}`
+    `returnTo must be https:, or http: on localhost \u2014 got ${url2.protocol}//${url2.hostname}`
   );
 }
 
@@ -10419,8 +10419,8 @@ function joinNonce(account) {
   const source = createLocalStorageNonceSource(`calimero.delegated.joinnonce.${account}`);
   return () => source.next();
 }
-function origin(url) {
-  return url.replace(/\/+$/, "");
+function origin(url2) {
+  return url2.replace(/\/+$/, "");
 }
 async function joinWithNode(input) {
   const { account, credential, deviceSecret } = input.credential;
@@ -10442,11 +10442,11 @@ async function joinWithNode(input) {
     };
   }
   const body = { invitation: input.invitation, signedOp };
-  const url = input.admitUrl ?? `${origin(input.nodeUrl)}/admin-api/namespaces/${pathSegment(input.namespaceId)}/admit`;
+  const url2 = input.admitUrl ?? `${origin(input.nodeUrl)}/admin-api/namespaces/${pathSegment(input.namespaceId)}/admit`;
   const doFetch = input.deps?.fetch ?? fetch;
   let response;
   try {
-    response = await doFetch(url, {
+    response = await doFetch(url2, {
       method: "POST",
       // No Authorization header and no request proof, deliberately: the route is
       // unauthenticated because the joiner's signature is the authorization.
@@ -10569,8 +10569,8 @@ function selectLatestBundle(bundles) {
   );
 }
 async function fetchRegistryBundles(registryUrl, pkg, fetchFn = globalThis.fetch) {
-  const url = `${registryUrl.replace(/\/+$/, "")}/api/v2/bundles?package=${encodeURIComponent(pkg)}`;
-  const response = await fetchFn(url, { headers: { Accept: "application/json" } });
+  const url2 = `${registryUrl.replace(/\/+$/, "")}/api/v2/bundles?package=${encodeURIComponent(pkg)}`;
+  const response = await fetchFn(url2, { headers: { Accept: "application/json" } });
   if (!response.ok) throw new Error(`the registry has no ${pkg} (HTTP ${response.status})`);
   const body = await response.json();
   return Array.isArray(body) ? body : [];
@@ -10610,9 +10610,9 @@ function nextGovernanceNonce(relay, group) {
   return next;
 }
 function relayFor(s, namespaceId) {
-  const url = readRelayMap(s.account).namespaces[namespaceId] ?? s.relayUrl;
-  if (!url) throw new Error("no relay is known for this namespace, so there is nowhere to send this");
-  return url.replace(/\/+$/, "");
+  const url2 = readRelayMap(s.account).namespaces[namespaceId] ?? s.relayUrl;
+  if (!url2) throw new Error("no relay is known for this namespace, so there is nowhere to send this");
+  return url2.replace(/\/+$/, "");
 }
 function initArgsOf(params) {
   if (!params || params.length === 0) return {};
@@ -10695,7 +10695,7 @@ async function foundingExecutor(s, relay, fetch2) {
   const named = s.executorAccount && s.relayUrl?.replace(/\/+$/, "") === relay ? s.executorAccount : null;
   if (named) return { executorAccount: named, executorKey: await attestedNodeKey(relay) };
   const known = Object.entries(readRelayMap(s.account).namespaces).find(
-    ([, url]) => url.replace(/\/+$/, "") === relay
+    ([, url2]) => url2.replace(/\/+$/, "") === relay
   )?.[0];
   if (!known) {
     throw new Error(
@@ -11142,8 +11142,8 @@ function accountHexOrNull(value) {
   return typeof value === "string" && ACCOUNT_HEX.test(value) ? value : null;
 }
 var AccountHaRefusedError = class extends HTTPError {
-  constructor(code, status, statusText, url, headers, bodyText) {
-    super(status, statusText, url, headers, bodyText);
+  constructor(code, status, statusText, url2, headers, bodyText) {
+    super(status, statusText, url2, headers, bodyText);
     this.code = code;
     this.name = "AccountHaRefusedError";
   }
@@ -12460,8 +12460,8 @@ var MeroJs = class {
   /**
    * Parse an auth callback URL hash fragment (static utility)
    */
-  static parseAuthCallback(url) {
-    return parseAuthCallback(url);
+  static parseAuthCallback(url2) {
+    return parseAuthCallback(url2);
   }
   /**
    * Build an auth login URL (static utility)
@@ -12726,8 +12726,8 @@ async function probeNodeHealth(baseUrl, options = {}) {
   if (abortSignal) abortSignal.addEventListener("abort", onAbort, { once: true });
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const url = nodeEndpoint(baseUrl, "admin-api/health");
-    const res = await fetch(url, {
+    const url2 = nodeEndpoint(baseUrl, "admin-api/health");
+    const res = await fetch(url2, {
       method: "GET",
       signal: controller.signal
     });
@@ -12751,20 +12751,457 @@ async function discoverLocalNodes(options = {}) {
   const { ports = DEFAULT_LOCAL_NODE_PORTS, timeoutMs, signal } = options;
   const results = await Promise.all(
     ports.map(async (port) => {
-      const url = localNodeUrl(port);
-      const ok = await probeNodeHealth(url, { timeoutMs, signal });
-      return ok ? url : null;
+      const url2 = localNodeUrl(port);
+      const ok = await probeNodeHealth(url2, { timeoutMs, signal });
+      return ok ? url2 : null;
     })
   );
-  return results.filter((url) => url !== null);
+  return results.filter((url2) => url2 !== null);
+}
+
+// src/agent-gate/chacha20poly1305.ts
+var KEY_LEN = 32;
+var NONCE_LEN = 12;
+var TAG_LEN2 = 16;
+function rotl(value, shift) {
+  return (value << shift | value >>> 32 - shift) >>> 0;
+}
+function quarterRound(s, a, b, c, d) {
+  s[a] = s[a] + s[b] >>> 0;
+  s[d] = rotl(s[d] ^ s[a], 16);
+  s[c] = s[c] + s[d] >>> 0;
+  s[b] = rotl(s[b] ^ s[c], 12);
+  s[a] = s[a] + s[b] >>> 0;
+  s[d] = rotl(s[d] ^ s[a], 8);
+  s[c] = s[c] + s[d] >>> 0;
+  s[b] = rotl(s[b] ^ s[c], 7);
+}
+function u32le2(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function chacha20Block(key, counter, nonce2) {
+  const state = new Uint32Array(16);
+  state[0] = 1634760805;
+  state[1] = 857760878;
+  state[2] = 2036477234;
+  state[3] = 1797285236;
+  for (let i = 0; i < 8; i += 1) state[4 + i] = u32le2(key, i * 4);
+  state[12] = counter >>> 0;
+  for (let i = 0; i < 3; i += 1) state[13 + i] = u32le2(nonce2, i * 4);
+  const working = state.slice();
+  for (let round = 0; round < 10; round += 1) {
+    quarterRound(working, 0, 4, 8, 12);
+    quarterRound(working, 1, 5, 9, 13);
+    quarterRound(working, 2, 6, 10, 14);
+    quarterRound(working, 3, 7, 11, 15);
+    quarterRound(working, 0, 5, 10, 15);
+    quarterRound(working, 1, 6, 11, 12);
+    quarterRound(working, 2, 7, 8, 13);
+    quarterRound(working, 3, 4, 9, 14);
+  }
+  const out = new Uint8Array(64);
+  for (let i = 0; i < 16; i += 1) {
+    const word = working[i] + state[i] >>> 0;
+    out[i * 4] = word & 255;
+    out[i * 4 + 1] = word >>> 8 & 255;
+    out[i * 4 + 2] = word >>> 16 & 255;
+    out[i * 4 + 3] = word >>> 24 & 255;
+  }
+  return out;
+}
+function chacha20(key, counter, nonce2, data) {
+  const out = new Uint8Array(data.length);
+  for (let offset = 0, block = counter; offset < data.length; offset += 64, block += 1) {
+    const stream = chacha20Block(key, block, nonce2);
+    const end = Math.min(offset + 64, data.length);
+    for (let i = offset; i < end; i += 1) out[i] = data[i] ^ stream[i - offset];
+  }
+  return out;
+}
+function leToBigInt(bytes) {
+  let value = 0n;
+  for (let i = bytes.length - 1; i >= 0; i -= 1) value = value << 8n | BigInt(bytes[i]);
+  return value;
+}
+var P1305 = (1n << 130n) - 5n;
+function poly1305(key, message) {
+  const r = leToBigInt(key.subarray(0, 16)) & 0x0ffffffc0ffffffc0ffffffc0fffffffn;
+  const s = leToBigInt(key.subarray(16, 32));
+  let acc = 0n;
+  for (let offset = 0; offset < message.length; offset += 16) {
+    const block = message.subarray(offset, Math.min(offset + 16, message.length));
+    const n = leToBigInt(block) + (1n << BigInt(8 * block.length));
+    acc = (acc + n) * r % P1305;
+  }
+  let tag3 = acc + s & (1n << 128n) - 1n;
+  const out = new Uint8Array(TAG_LEN2);
+  for (let i = 0; i < TAG_LEN2; i += 1) {
+    out[i] = Number(tag3 & 0xffn);
+    tag3 >>= 8n;
+  }
+  return out;
+}
+function pad16(length) {
+  return new Uint8Array((16 - length % 16) % 16);
+}
+function u64le2(value) {
+  const out = new Uint8Array(8);
+  new DataView(out.buffer).setBigUint64(0, BigInt(value), true);
+  return out;
+}
+function macData(aad, ciphertext) {
+  const parts = [aad, pad16(aad.length), ciphertext, pad16(ciphertext.length), u64le2(aad.length), u64le2(ciphertext.length)];
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function check(key, nonce2) {
+  if (key.length !== KEY_LEN) throw new Error("ChaCha20-Poly1305 needs a 32-byte key");
+  if (nonce2.length !== NONCE_LEN) throw new Error("ChaCha20-Poly1305 needs a 12-byte nonce");
+}
+function chacha20Poly1305Seal(key, nonce2, plaintext, aad = new Uint8Array(0)) {
+  check(key, nonce2);
+  const otk = chacha20Block(key, 0, nonce2).subarray(0, 32);
+  const ciphertext = chacha20(key, 1, nonce2, plaintext);
+  const tag3 = poly1305(otk, macData(aad, ciphertext));
+  const out = new Uint8Array(ciphertext.length + TAG_LEN2);
+  out.set(ciphertext);
+  out.set(tag3, ciphertext.length);
+  return out;
+}
+
+// src/agent-gate/hpke.ts
+var KEM_ID = 32;
+var KDF_ID = 1;
+var AEAD_ID = 3;
+var MODE_AUTH = 2;
+var N_SECRET = 32;
+var N_KEY = 32;
+var N_NONCE = 12;
+var utf84 = (s) => new TextEncoder().encode(s);
+var i2osp2 = (n) => new Uint8Array([n >> 8 & 255, n & 255]);
+var KEM_SUITE = concat(utf84("KEM"), i2osp2(KEM_ID));
+var HPKE_SUITE = concat(utf84("HPKE"), i2osp2(KEM_ID), i2osp2(KDF_ID), i2osp2(AEAD_ID));
+async function hmac(key, data) {
+  const raw = key.length === 0 ? new Uint8Array(32) : key;
+  const k = await crypto.subtle.importKey("raw", raw, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return new Uint8Array(await crypto.subtle.sign("HMAC", k, data));
+}
+async function expand(prk, info, length) {
+  const out = new Uint8Array(length);
+  let previous = new Uint8Array(0);
+  for (let i = 1, offset = 0; offset < length; i += 1) {
+    previous = await hmac(prk, concat(previous, info, new Uint8Array([i])));
+    out.set(previous.subarray(0, Math.min(previous.length, length - offset)), offset);
+    offset += previous.length;
+  }
+  return out;
+}
+function labeledExtract(suite, salt, label2, ikm) {
+  return hmac(salt, concat(utf84("HPKE-v1"), suite, utf84(label2), ikm));
+}
+function labeledExpand(suite, prk, label2, info, length) {
+  return expand(prk, concat(i2osp2(length), utf84("HPKE-v1"), suite, utf84(label2), info), length);
+}
+async function extractAndExpand(dhValue, kemContext) {
+  const prk = await labeledExtract(KEM_SUITE, new Uint8Array(0), "eae_prk", dhValue);
+  return labeledExpand(KEM_SUITE, prk, "shared_secret", kemContext, N_SECRET);
+}
+async function keySchedule(sharedSecret, info) {
+  const empty = new Uint8Array(0);
+  const pskIdHash = await labeledExtract(HPKE_SUITE, empty, "psk_id_hash", empty);
+  const infoHash = await labeledExtract(HPKE_SUITE, empty, "info_hash", info);
+  const context = concat(new Uint8Array([MODE_AUTH]), pskIdHash, infoHash);
+  const secret = await labeledExtract(HPKE_SUITE, sharedSecret, "secret", empty);
+  return {
+    key: await labeledExpand(HPKE_SUITE, secret, "key", context, N_KEY),
+    nonce: await labeledExpand(HPKE_SUITE, secret, "base_nonce", context, N_NONCE)
+  };
+}
+async function hpkeSealAuth(recipientPublic, senderSecret, info, plaintext, aad = new Uint8Array(0), ephemeralSecret) {
+  if (recipientPublic.length !== 32) throw new Error("The recipient key is not 32 bytes of X25519");
+  const ephemeral = await x25519KeyPair(ephemeralSecret);
+  const sender = await x25519KeyPair(senderSecret);
+  const dhValue = concat(await dh(ephemeral.privateKey, recipientPublic), await dh(sender.privateKey, recipientPublic));
+  const shared = await extractAndExpand(dhValue, concat(ephemeral.publicKey, recipientPublic, sender.publicKey));
+  const { key, nonce: nonce2 } = await keySchedule(shared, info);
+  return { enc: ephemeral.publicKey, ciphertext: chacha20Poly1305Seal(key, nonce2, plaintext, aad) };
+}
+
+// src/agent-gate/gate.ts
+var AGENT_ATTEST_DOMAIN = "mero-agent-gate/attest/v3";
+var AGENT_PROVISION_INFO_DOMAIN = "mero-agent-gate/provision/v2";
+var AGENT_ID = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var SECRET_NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
+var MAX_SECRETS = 64;
+var MAX_SECRET_LEN = 64 * 1024;
+var AgentGateError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "AgentGateError";
+  }
+};
+function validateAgentId(agentId) {
+  if (!AGENT_ID.test(agentId)) {
+    throw new Error(`Agent id ${JSON.stringify(agentId)} must match [a-z0-9][a-z0-9-]{0,62}`);
+  }
+}
+function utf85(value) {
+  return new TextEncoder().encode(value);
+}
+function lengthPrefixed(agentId) {
+  const id = utf85(agentId);
+  return concat(new Uint8Array([id.length]), id);
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function fromBase644(value, label2, length) {
+  let bytes;
+  try {
+    bytes = Uint8Array.from(atob(value.trim()), (c) => c.charCodeAt(0));
+  } catch {
+    throw new Error(`${label2} is not base64`);
+  }
+  if (length !== void 0 && bytes.length !== length) throw new Error(`${label2} is not ${length} bytes`);
+  return bytes;
+}
+async function agentKeyBinding(provisioningPublic, agentId, signingPublic, ownerPublic) {
+  const zero = new Uint8Array(32);
+  const data = concat(
+    utf85(AGENT_ATTEST_DOMAIN),
+    provisioningPublic,
+    lengthPrefixed(agentId),
+    signingPublic ?? zero,
+    ownerPublic ?? zero
+  );
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", data));
+}
+function provisionInfo(recipientPublic, agentId) {
+  return concat(utf85(AGENT_PROVISION_INFO_DOMAIN), recipientPublic, lengthPrefixed(agentId));
+}
+async function generateOwnerKey() {
+  const secret = crypto.getRandomValues(new Uint8Array(32));
+  return { secret, publicKey: await ownerPublicKey(secret) };
+}
+async function ownerPublicKey(secret) {
+  if (secret.length !== 32) throw new Error("An owner key is 32 bytes");
+  return toBase64((await x25519KeyPair(secret)).publicKey);
+}
+function url(gateUrl, path) {
+  return `${gateUrl.replace(/\/+$/, "")}${path}`;
+}
+async function postJson(fetchImpl, target, body) {
+  const response = await fetchImpl(target, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  let parsed = void 0;
+  try {
+    parsed = text ? JSON.parse(text) : void 0;
+  } catch {
+  }
+  if (!response.ok) {
+    const error = parsed;
+    throw new AgentGateError(
+      `The gate answered ${response.status}${error?.error ? ` ${error.error}` : ""}: ${error?.details ?? text.slice(0, 200)}`,
+      response.status,
+      error?.error
+    );
+  }
+  return parsed;
+}
+async function attestAgent(options) {
+  const agentId = options.agentId ?? "";
+  if (agentId) validateAgentId(agentId);
+  const nonce2 = crypto.getRandomValues(new Uint8Array(32));
+  const body = await postJson(options.fetch ?? fetch, url(options.gateUrl, "/attest"), {
+    nonceB64: toBase64(nonce2),
+    ...agentId ? { agentId } : {}
+  });
+  if ((body?.agentId ?? "") !== agentId) {
+    throw new Error(`Asked about agent ${JSON.stringify(agentId)}, the gate answered for ${JSON.stringify(body?.agentId)}`);
+  }
+  const provisioning = fromBase644(body.provisioningPublicKeyB64 ?? "", "provisioningPublicKeyB64", 32);
+  const signing = body.signingPublicKeyB64 ? fromBase644(body.signingPublicKeyB64, "signingPublicKeyB64", 32) : void 0;
+  const owner = body.ownerPublicKeyB64 ? fromBase644(body.ownerPublicKeyB64, "ownerPublicKeyB64", 32) : void 0;
+  if (!signing !== !owner) {
+    throw new Error("A claimed agent has both a signing key and an owner; the gate named one");
+  }
+  const binding = await agentKeyBinding(provisioning, agentId, signing, owner);
+  await options.verifier({ quoteB64: body.quoteB64, nonce: hex(nonce2), reportDataSuffix: hex(binding) });
+  return {
+    agentId,
+    provisioningPublicKey: toBase64(provisioning),
+    ...signing ? { signingPublicKey: toBase64(signing) } : {},
+    ...owner ? { ownerPublicKey: toBase64(owner) } : {}
+  };
+}
+async function checkOwner(agent, ownerSecret) {
+  const mine = await ownerPublicKey(ownerSecret);
+  if (agent.ownerPublicKey && agent.ownerPublicKey !== mine) {
+    throw new AgentGateError(
+      `This agent is claimed by another key (${agent.ownerPublicKey}); it is not yours. Send it nothing and do not authorize its signing key`,
+      void 0,
+      "not_yours"
+    );
+  }
+  return mine;
+}
+function validateSecrets(secrets) {
+  const names = Object.keys(secrets);
+  if (names.length === 0) throw new Error("There are no secrets to provision");
+  if (names.length > MAX_SECRETS) throw new Error(`At most ${MAX_SECRETS} secrets at once`);
+  for (const name of names) {
+    if (!SECRET_NAME.test(name)) throw new Error(`Secret name ${JSON.stringify(name)} must match [A-Za-z0-9][A-Za-z0-9_.-]{0,63}`);
+    if (typeof secrets[name] !== "string") throw new Error(`Secret ${name} is not a string`);
+    if (utf85(secrets[name]).length > MAX_SECRET_LEN) throw new Error(`Secret ${name} is over ${MAX_SECRET_LEN} bytes`);
+  }
+}
+async function sendSealed(fetchImpl, gateUrl, path, agent, ownerSecret, message) {
+  if (!agent.agentId) throw new Error("This quote names no agent; attest with the agent id");
+  const mine = await checkOwner(agent, ownerSecret);
+  const recipient = fromBase644(agent.provisioningPublicKey, "provisioningPublicKey", 32);
+  const sealed = await hpkeSealAuth(
+    recipient,
+    ownerSecret,
+    provisionInfo(recipient, agent.agentId),
+    utf85(JSON.stringify(message))
+  );
+  return postJson(fetchImpl, url(gateUrl, path), {
+    agentId: agent.agentId,
+    provisioningPublicKeyB64: agent.provisioningPublicKey,
+    senderPublicKeyB64: mine,
+    encappedKeyB64: toBase64(sealed.enc),
+    ciphertextB64: toBase64(sealed.ciphertext)
+  });
+}
+async function provisionAgent(options) {
+  validateSecrets(options.secrets);
+  const fetchImpl = options.fetch ?? fetch;
+  const answer = await sendSealed(fetchImpl, options.gateUrl, "/provision", options.agent, options.ownerSecret, {
+    secrets: options.secrets
+  });
+  const after = await attestAgent({ gateUrl: options.gateUrl, agentId: options.agent.agentId, verifier: options.verifier, fetch: fetchImpl });
+  const mine = await ownerPublicKey(options.ownerSecret);
+  if (after.ownerPublicKey !== mine || !after.signingPublicKey) {
+    throw new AgentGateError("The gate accepted the secrets, but its quote does not name your key as owner");
+  }
+  if (options.agent.signingPublicKey && options.agent.signingPublicKey !== after.signingPublicKey) {
+    throw new AgentGateError("The agent's signing key changed while provisioning");
+  }
+  return {
+    agentId: after.agentId,
+    provisioningPublicKey: after.provisioningPublicKey,
+    signingPublicKey: after.signingPublicKey,
+    ownerPublicKey: mine,
+    written: answer?.written ?? [],
+    claimed: answer?.claimed === true
+  };
+}
+async function releaseAgent(options) {
+  if (!options.agent.ownerPublicKey) throw new Error("This agent is not claimed; there is nothing to release");
+  const fetchImpl = options.fetch ?? fetch;
+  await sendSealed(fetchImpl, options.gateUrl, "/release", options.agent, options.ownerSecret, { release: true });
+  const after = await attestAgent({ gateUrl: options.gateUrl, agentId: options.agent.agentId, verifier: options.verifier, fetch: fetchImpl });
+  if (after.ownerPublicKey) {
+    throw new AgentGateError("The gate says it released the agent, but its quote still names an owner");
+  }
+}
+
+// src/agent-gate/policy.ts
+var KMS_RELEASE_SIGNER = Object.freeze({
+  identity: "https://github.com/calimero-network/mero-tee/.github/workflows/release-kms.yaml@refs/heads/master",
+  issuer: "https://token.actions.githubusercontent.com"
+});
+var LISTS = [
+  "allowed_tcb_statuses",
+  "allowed_mrtd",
+  "allowed_rtmr0",
+  "allowed_rtmr1",
+  "allowed_rtmr2",
+  "allowed_rtmr3"
+];
+async function verifySignedAgentPolicy(policy, bundle, options = {}) {
+  const body = typeof policy === "string" ? new TextEncoder().encode(policy) : policy;
+  await verifyCosignBundle(body, bundle, {
+    identity: options.identity ?? KMS_RELEASE_SIGNER.identity,
+    issuer: options.issuer ?? KMS_RELEASE_SIGNER.issuer
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    throw new Error("The signed agent policy is not JSON");
+  }
+  if (parsed?.role !== "agent") {
+    throw new Error(`The signed file is a ${JSON.stringify(parsed?.role)} policy, not an agent one`);
+  }
+  const profile = options.profile ?? PRODUCTION_PROFILE;
+  if (parsed.profile !== profile) {
+    throw new Error(`The signed agent policy is for the ${JSON.stringify(parsed.profile)} profile, not ${profile}`);
+  }
+  if (options.expectedVersion !== void 0 && parsed.version !== options.expectedVersion) {
+    throw new Error(`The signed agent policy is release ${JSON.stringify(parsed.version)}, not ${options.expectedVersion}`);
+  }
+  checkLists(parsed);
+  return parsed;
+}
+function checkLists(policy) {
+  for (const list of LISTS) {
+    if (!Array.isArray(policy?.[list]) || policy[list].length === 0) {
+      throw new Error(`The agent policy's ${list} is empty, so no agent would be accepted`);
+    }
+  }
+}
+var TCB_STATUSES2 = [
+  "UpToDate",
+  "SWHardeningNeeded",
+  "ConfigurationNeeded",
+  "ConfigurationAndSWHardeningNeeded",
+  "OutOfDate",
+  "OutOfDateConfigurationNeeded"
+];
+function tcbStatus2(value) {
+  const found = TCB_STATUSES2.find((status) => status.toLowerCase() === value.trim().toLowerCase());
+  if (!found) throw new Error(`The agent policy allows an unknown TCB status ${JSON.stringify(value)}`);
+  return found;
+}
+var register = (value) => value.trim().replace(/^0x/i, "");
+function agentQuoteVerifier(policy, options) {
+  checkLists(policy);
+  return createQuoteVerifier({
+    dcapVerify: options.dcapVerify,
+    fetchCollateral: options.fetchCollateral,
+    now: options.now,
+    allowedTcbStatuses: policy.allowed_tcb_statuses.map(tcbStatus2),
+    allowedMrtd: policy.allowed_mrtd.map(register),
+    allowedRtmr0: policy.allowed_rtmr0.map(register),
+    allowedRtmr1: policy.allowed_rtmr1.map(register),
+    allowedRtmr2: policy.allowed_rtmr2.map(register),
+    allowedRtmr3: policy.allowed_rtmr3.map(register)
+  });
 }
 export {
   ACCOUNT_HA_AUDIENCE,
   ACCOUNT_OWNERSHIP_AUDIENCE,
+  AGENT_ATTEST_DOMAIN,
+  AGENT_PROVISION_INFO_DOMAIN,
   AccountHaRefusedError,
   AccountLinkedToSeveralUsersError,
   AccountNotLinkedError,
   AdminApiClient,
+  AgentGateError,
   AuthApiClient,
   AuthRevokedError,
   CAPABILITIES,
@@ -12781,6 +13218,7 @@ export {
   INVITED_ROLE,
   IntentRefusedError,
   InvitationNotClaimableError,
+  KMS_RELEASE_SIGNER,
   LocalStorageTokenStore,
   MAX_INVITATION_VALIDITY_SECS,
   MemoryTokenStore,
@@ -12819,8 +13257,11 @@ export {
   accountRootSignerFromPhrase,
   adminChangedOp,
   admitterAddrsFromNetworkStatus,
+  agentKeyBinding,
+  agentQuoteVerifier,
   applicationIdForBundle,
   attemptRelayNodeKey,
+  attestAgent,
   attestKeyBinding,
   attestRelayNodeKey,
   authorNonceLookup,
@@ -12834,6 +13275,7 @@ export {
   capMask,
   capNames,
   carryExecutorAccount,
+  checkOwner,
   classifyError,
   clearDelegatedCredential,
   clearDelegatedSession,
@@ -12901,6 +13343,7 @@ export {
   foundDelegatedNamespace,
   foundedNamespaceId,
   generateAccountRoot,
+  generateOwnerKey,
   generateSessionKey,
   governGroup,
   governRoot,
@@ -12941,6 +13384,7 @@ export {
   normaliseAccount,
   ownerOpDigest,
   ownerOpSigningPayload,
+  ownerPublicKey,
   parseAuthCallback,
   parseCreationWarrant,
   parseDeviceCredential,
@@ -12950,6 +13394,8 @@ export {
   pinRelayNodeKey,
   presenceStatementBytes,
   probeNodeHealth,
+  provisionAgent,
+  provisionInfo,
   readCloudLinkCallback,
   readDelegatedCredential,
   readDelegatedSession,
@@ -12959,6 +13405,7 @@ export {
   redeemInvitation,
   relayForContext,
   relayTransportFetch,
+  releaseAgent,
   rememberGroupNamespace,
   rememberRelay,
   reportDataOf,
@@ -13005,7 +13452,9 @@ export {
   transportKeyBinding,
   trustSignedRelease,
   trustedMeasurementsFromReleases,
+  validateAgentId,
   verifyDeviceCredential,
+  verifySignedAgentPolicy,
   verifySignedNodeRelease,
   withCap,
   withRetry,