@le-space/ui 0.7.0 → 0.9.0

package/shared/index.js

@@ -42,7 +42,7 @@ var RECENT_INSTANCE_RUNTIME_GRACE_MS = 10 * 60 * 1e3;
 var DEPLOYMENT_PENDING_WARNING_MS = 3 * 60 * 1e3;
 
 // src/shared/package-version.ts
-var UI_PACKAGE_VERSION = "0.7.0";
+var UI_PACKAGE_VERSION = "0.9.0";
 
 // src/shared/format.ts
 function shortHash(value, head = 8, tail = 6) {
@@ -140,6 +140,8 @@ var DEFAULT_ALEPH_API_HOSTS = [
 ];
 var DEFAULT_ALEPH_API_HOST = DEFAULT_ALEPH_API_HOSTS[0] ?? "https://api2.aleph.im";
 var DEFAULT_CRN_LIST_URL = "https://crns-list.aleph.sh/crns.json";
+var DEFAULT_CRN_AGGREGATE_ADDRESS = "0xa1B3bb7d2332383D96b7796B908fB7f7F3c2Be10";
+var DEFAULT_CRN_AGGREGATE_KEY = "corechannel";
 var DEFAULT_ALEPH_SCHEDULER_API_HOST = "https://scheduler.api.aleph.cloud";
 var DEFAULT_2N6_API_HOST = "https://api.2n6.me";
 function normalizeMessageStatus(status) {
@@ -194,7 +196,7 @@ async function fetchBalance(address, apiHost = DEFAULT_ALEPH_API_HOST) {
   if (!response.ok) throw new Error(`Balance request failed: ${response.status}`);
   return await response.json();
 }
-async function fetchCrns(url = DEFAULT_CRN_LIST_URL) {
+async function fetchCrnsFromList(url = DEFAULT_CRN_LIST_URL) {
   const requestUrl = new URL(url);
   requestUrl.searchParams.set("filter_inactive", "true");
   const response = await fetchWithTimeout(requestUrl, { cache: "no-cache" });
@@ -202,6 +204,130 @@ async function fetchCrns(url = DEFAULT_CRN_LIST_URL) {
   const payload = await response.json();
   return payload.crns ?? [];
 }
+function asFiniteNumber(value) {
+  if (value == null || value === "") return null;
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function normalizeCrnAddress(value) {
+  const address = asString(value);
+  if (!address) return null;
+  const withScheme = /^https?:\/\//i.test(address) ? address : `https://${address}`;
+  try {
+    return new URL(withScheme).toString().replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function mapResourceNodesToCrns(resourceNodes) {
+  if (!Array.isArray(resourceNodes)) return [];
+  const crns = [];
+  for (const node of resourceNodes) {
+    if (!node || typeof node !== "object") continue;
+    const entry = node;
+    const hash = asString(entry.hash);
+    const address = normalizeCrnAddress(entry.address);
+    const type = asString(entry.type)?.toLowerCase();
+    const status = asString(entry.status)?.toLowerCase();
+    if (!hash || !address) continue;
+    if (entry.inactive_since != null || entry.locked === true) continue;
+    if (type && type !== "compute") continue;
+    if (status && status !== "linked" && status !== "active") continue;
+    if (!asString(entry.parent)) continue;
+    const score = asFiniteNumber(entry.score) ?? asFiniteNumber(entry.scoreV1);
+    const performance = asFiniteNumber(entry.performance);
+    const decentralization = asFiniteNumber(entry.decentralization);
+    crns.push({
+      hash,
+      address,
+      name: asString(entry.name) ?? hash,
+      ...score == null ? {} : { score },
+      ...performance == null ? {} : { performance },
+      ...decentralization == null ? {} : { decentralization }
+    });
+  }
+  return crns;
+}
+async function fetchCrnsFromAggregate(apiHosts = DEFAULT_ALEPH_API_HOSTS, address = DEFAULT_CRN_AGGREGATE_ADDRESS) {
+  const hosts = apiHosts.length > 0 ? apiHosts : DEFAULT_ALEPH_API_HOSTS;
+  let lastError = null;
+  for (const apiHost of hosts) {
+    try {
+      const url = new URL(`/api/v0/aggregates/${address}.json`, apiHost);
+      url.searchParams.set("keys", DEFAULT_CRN_AGGREGATE_KEY);
+      const response = await fetchWithTimeout(url, { cache: "no-cache" });
+      if (!response.ok) {
+        lastError = new Error(`CRN aggregate request failed: ${response.status}`);
+        continue;
+      }
+      const payload = await response.json();
+      const crns = mapResourceNodesToCrns(payload?.data?.corechannel?.resource_nodes);
+      if (crns.length > 0) return crns;
+      lastError = new Error("CRN aggregate contained no deployable resource nodes");
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "CRN aggregate request failed"));
+}
+async function fetchCrnsWithSource(url = DEFAULT_CRN_LIST_URL, options = {}) {
+  const apiHosts = options.apiHosts ?? DEFAULT_ALEPH_API_HOSTS;
+  const source = options.source ?? "auto";
+  if (source === "aggregate") {
+    return {
+      crns: await fetchCrnsFromAggregate(apiHosts, options.aggregateAddress),
+      source: "aggregate"
+    };
+  }
+  let listError;
+  try {
+    const crns = await fetchCrnsFromList(url);
+    if (crns.length > 0) return { crns, source: "list" };
+    listError = new Error("CRN list returned no entries");
+  } catch (error) {
+    listError = error instanceof Error ? error : new Error(String(error));
+  }
+  if (source === "list") throw listError;
+  return {
+    crns: await fetchCrnsFromAggregate(apiHosts, options.aggregateAddress),
+    source: "aggregate",
+    listError
+  };
+}
+async function fetchCrns(url = DEFAULT_CRN_LIST_URL, options = {}) {
+  return (await fetchCrnsWithSource(url, options)).crns;
+}
+async function probeCrnAvailability(crn) {
+  const address = String(crn.address ?? "").trim();
+  if (!address) return "unreachable";
+  const lookup = await fetchCrnExecutionMap(address);
+  if (lookup.payload !== null) return "reachable";
+  return lookup.blocked ? "unknown" : "unreachable";
+}
+async function filterReachableCrns(crns, options = {}) {
+  const limit = Math.max(1, Number(options.limit) || 5);
+  const probed = crns.slice(0, limit);
+  if (probed.length === 0) return [...crns];
+  const verdicts = await Promise.all(
+    probed.map(async (crn) => {
+      try {
+        return { crn, verdict: await probeCrnAvailability(crn) };
+      } catch {
+        return { crn, verdict: "unknown" };
+      }
+    })
+  );
+  const kept = verdicts.filter((entry) => entry.verdict !== "unreachable").map((entry) => entry.crn);
+  if (kept.length === 0) {
+    options.onDiagnostic?.(`No CRN answered its executions endpoint (${probed.length} probed); keeping the unverified order`);
+    return [...crns];
+  }
+  const dropped = probed.length - kept.length;
+  if (dropped > 0) {
+    options.onDiagnostic?.(`Skipping ${dropped} unreachable CRN${dropped === 1 ? "" : "s"} of ${probed.length} probed`);
+  }
+  return [...kept, ...crns.slice(limit)];
+}
 async function fetchInstances(address, apiHost = DEFAULT_ALEPH_API_HOST) {
   const url = new URL("/api/v0/messages.json", apiHost);
   url.searchParams.set("msgTypes", "INSTANCE");
@@ -856,18 +982,23 @@ function createAlephBrowserClient(options = {}) {
   const apiHosts = options.apiHosts === void 0 && options.apiHost === void 0 ? [...DEFAULT_ALEPH_API_HOSTS] : normalizeApiHosts(options.apiHosts, options.apiHost ?? DEFAULT_ALEPH_API_HOST);
   const apiHost = apiHosts[0] ?? DEFAULT_ALEPH_API_HOST;
   const crnListUrl = options.crnListUrl ?? DEFAULT_CRN_LIST_URL;
+  const crnSource = options.crnSource ?? "auto";
   const schedulerApiHost = options.schedulerApiHost ?? DEFAULT_ALEPH_SCHEDULER_API_HOST;
   const twoN6ApiHost = options.twoN6ApiHost ?? DEFAULT_2N6_API_HOST;
   return {
     apiHost,
     apiHosts,
     crnListUrl,
+    crnSource,
     schedulerApiHost,
     fetchBalance(address) {
       return withApiHostFallback(apiHosts, (host) => fetchBalance(address, host));
     },
     fetchCrns() {
-      return fetchCrns(crnListUrl);
+      return fetchCrns(crnListUrl, { apiHosts, source: crnSource });
+    },
+    fetchCrnsWithSource(source) {
+      return fetchCrnsWithSource(crnListUrl, { apiHosts, source: source ?? crnSource });
     },
     fetchInstances(address) {
       return withApiHostFallback(apiHosts, (host) => fetchInstances(address, host));
@@ -942,6 +1073,15 @@ var DEFAULT_ALEPH_API_HOST2 = "https://api.aleph.im";
 
 // ../core/src/crns.ts
 var DEFAULT_CRN_LIST_URL2 = "https://crns-list.aleph.sh/crns.json";
+var DEFAULT_CRN_AGGREGATE_ADDRESS2 = "0xa1B3bb7d2332383D96b7796B908fB7f7F3c2Be10";
+var DEFAULT_CRN_AGGREGATE_KEY2 = "corechannel";
+var DEFAULT_CRN_AGGREGATE_API_HOSTS = [
+  "https://api2.aleph.im",
+  "https://api.aleph.im"
+];
+function asString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
 function compatibleCrns(crns, excludedHashes = []) {
   const excluded = new Set(excludedHashes.filter(Boolean));
   return [...crns].filter((crn) => {
@@ -975,7 +1115,7 @@ function filterDeployableCrns(crns, options = {}) {
     compatibleCrns(crns, options.excludedHashes).filter((crn) => hasCrnCapacity(crn, options.spec))
   );
 }
-async function fetchCrns2(options) {
+async function fetchCrnsFromList2(options) {
   const requestUrl = new URL(options.url ?? DEFAULT_CRN_LIST_URL2);
   requestUrl.searchParams.set("filter_inactive", "true");
   const response = await options.fetch(requestUrl.toString(), {
@@ -987,6 +1127,101 @@ async function fetchCrns2(options) {
   const payload = await response.json();
   return Array.isArray(payload?.crns) ? payload.crns : [];
 }
+function normalizeCrnAddress2(value) {
+  const address = asString2(value);
+  if (!address) return null;
+  const withScheme = /^https?:\/\//i.test(address) ? address : `https://${address}`;
+  try {
+    return new URL(withScheme).toString().replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+}
+function aggregateScore(node) {
+  for (const candidate of [node.score, node.scoreV1]) {
+    if (candidate == null || candidate === "") continue;
+    const numeric = typeof candidate === "number" ? candidate : Number(candidate);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  return null;
+}
+function isDeployableResourceNode(node) {
+  if (!asString2(node.hash)) return false;
+  if (!normalizeCrnAddress2(node.address)) return false;
+  if (node.inactive_since != null) return false;
+  if (node.locked === true) return false;
+  const type = asString2(node.type)?.toLowerCase();
+  if (type && type !== "compute") return false;
+  const status = asString2(node.status)?.toLowerCase();
+  if (status && status !== "linked" && status !== "active") return false;
+  return Boolean(asString2(node.parent));
+}
+function mapResourceNodesToCrns2(resourceNodes) {
+  if (!Array.isArray(resourceNodes)) return [];
+  return resourceNodes.filter((node) => Boolean(node) && typeof node === "object").filter(isDeployableResourceNode).map((node) => {
+    const record = {
+      hash: asString2(node.hash),
+      address: normalizeCrnAddress2(node.address)
+    };
+    const name = asString2(node.name);
+    if (name) record.name = name;
+    const score = aggregateScore(node);
+    if (score != null) record.score = score;
+    return record;
+  });
+}
+async function fetchCrnsFromAggregate2(options) {
+  const apiHosts = options.apiHosts?.length ? options.apiHosts : DEFAULT_CRN_AGGREGATE_API_HOSTS;
+  const address = options.address ?? DEFAULT_CRN_AGGREGATE_ADDRESS2;
+  const aggregateKey = options.aggregateKey ?? DEFAULT_CRN_AGGREGATE_KEY2;
+  let lastError = null;
+  for (const apiHost of apiHosts) {
+    try {
+      const url = new URL(`/api/v0/aggregates/${address}.json`, apiHost);
+      url.searchParams.set("keys", aggregateKey);
+      const response = await options.fetch(url.toString(), { cache: "no-cache" });
+      if (!response.ok) {
+        lastError = new Error(`CRN aggregate request failed: ${response.status}`);
+        continue;
+      }
+      const payload = await response.json();
+      const crns = mapResourceNodesToCrns2(payload?.data?.corechannel?.resource_nodes);
+      if (crns.length > 0) return crns;
+      lastError = new Error("CRN aggregate contained no deployable resource nodes");
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "CRN aggregate request failed"));
+}
+async function fetchCrnsWithSource2(options) {
+  const aggregateOptions = {
+    fetch: options.fetch,
+    apiHosts: options.aggregateApiHosts,
+    address: options.aggregateAddress
+  };
+  if (options.preferAggregate) {
+    return { crns: await fetchCrnsFromAggregate2(aggregateOptions), source: "aggregate" };
+  }
+  let listError;
+  try {
+    const crns = await fetchCrnsFromList2({ url: options.url, fetch: options.fetch });
+    if (crns.length > 0) return { crns, source: "list" };
+    listError = new Error("CRN list returned no entries");
+  } catch (error) {
+    listError = error instanceof Error ? error : new Error(String(error));
+  }
+  options.onDiagnostic?.(`CRN list unavailable (${listError.message}); falling back to the ${DEFAULT_CRN_AGGREGATE_KEY2} aggregate`);
+  try {
+    return { crns: await fetchCrnsFromAggregate2(aggregateOptions), source: "aggregate", listError };
+  } catch (aggregateError) {
+    const message = aggregateError instanceof Error ? aggregateError.message : String(aggregateError);
+    throw new Error(`${listError.message}; CRN aggregate fallback failed: ${message}`);
+  }
+}
+async function fetchCrns2(options) {
+  return (await fetchCrnsWithSource2(options)).crns;
+}
 
 // ../core/src/port-forwarding.ts
 var DEFAULT_INSTANCE_PORT_FORWARDS = [
@@ -1076,7 +1311,7 @@ async function fetchPortForwardAggregate(address, options) {
 }
 
 // ../core/src/aleph-normalizers.ts
-function asString2(value) {
+function asString3(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
 function asNumber2(value) {
@@ -1091,7 +1326,7 @@ function normalizeMessageStatus2(status) {
   return "unknown";
 }
 function normalizeProxyUrl2(value) {
-  const stringValue = asString2(value);
+  const stringValue = asString3(value);
   if (!stringValue) return null;
   if (/^https?:\/\//i.test(stringValue)) return stringValue;
   return `https://${stringValue}`;
@@ -1186,22 +1421,22 @@ function normalizeExecution2(item, crnUrl) {
       version: "v2",
       running: typeof v2Item.running === "boolean" ? v2Item.running : void 0,
       networking: {
-        ipv4_network: asString2(networking.ipv4_network),
-        host_ipv4: asString2(networking.host_ipv4),
-        ipv6_network: asString2(networking.ipv6_network),
-        ipv6_ip: asString2(networking.ipv6_ip),
-        ipv4_ip: asString2(networking.ipv4_ip),
+        ipv4_network: asString3(networking.ipv4_network),
+        host_ipv4: asString3(networking.host_ipv4),
+        ipv6_network: asString3(networking.ipv6_network),
+        ipv6_ip: asString3(networking.ipv6_ip),
+        ipv4_ip: asString3(networking.ipv4_ip),
         proxy_url: extractProxyUrl2(v2Item, networking),
         mapped_ports: mappedPorts2
       },
       status: v2Item.status ? {
-        defined_at: asString2(v2Item.status.defined_at),
-        preparing_at: asString2(v2Item.status.preparing_at),
-        prepared_at: asString2(v2Item.status.prepared_at),
-        starting_at: asString2(v2Item.status.starting_at),
-        started_at: asString2(v2Item.status.started_at),
-        stopping_at: asString2(v2Item.status.stopping_at),
-        stopped_at: asString2(v2Item.status.stopped_at)
+        defined_at: asString3(v2Item.status.defined_at),
+        preparing_at: asString3(v2Item.status.preparing_at),
+        prepared_at: asString3(v2Item.status.prepared_at),
+        starting_at: asString3(v2Item.status.starting_at),
+        started_at: asString3(v2Item.status.started_at),
+        stopping_at: asString3(v2Item.status.stopping_at),
+        stopped_at: asString3(v2Item.status.stopped_at)
       } : null
     };
   }
@@ -1209,8 +1444,8 @@ function normalizeExecution2(item, crnUrl) {
     crnUrl,
     version: "v1",
     networking: {
-      ipv4: networking && "ipv4" in networking ? asString2(networking.ipv4) : null,
-      ipv6: networking && "ipv6" in networking ? asString2(networking.ipv6) : null
+      ipv4: networking && "ipv4" in networking ? asString3(networking.ipv4) : null,
+      ipv6: networking && "ipv6" in networking ? asString3(networking.ipv6) : null
     },
     status: null
   };
@@ -1372,7 +1607,7 @@ async function broadcastAlephMessage2(message, options) {
 // ../core/src/runtime.ts
 var DEFAULT_SCHEDULER_ALLOCATION_URL = "https://scheduler.api.aleph.cloud/api/v0/allocation";
 var DEFAULT_TWO_N_SIX_HASH_URL = "https://api.2n6.me/api/hash";
-function asString3(value) {
+function asString4(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function asNumber3(value) {
@@ -1414,17 +1649,17 @@ async function fetchSchedulerAllocation2(itemHash, options) {
   const node = payload?.node;
   return {
     source: "scheduler",
-    crnHash: asString3(node?.node_id),
-    crnUrl: asString3(node?.url),
+    crnHash: asString4(node?.node_id),
+    crnUrl: asString4(node?.url),
     node: node ? {
-      node_id: asString3(node.node_id) ?? void 0,
-      url: asString3(node.url) ?? void 0,
-      ipv6: asString3(node.ipv6),
+      node_id: asString4(node.node_id) ?? void 0,
+      url: asString4(node.url) ?? void 0,
+      ipv6: asString4(node.ipv6),
       supports_ipv6: typeof node.supports_ipv6 === "boolean" ? node.supports_ipv6 : void 0
     } : null,
-    vmIpv6: asString3(payload?.vm_ipv6),
+    vmIpv6: asString4(payload?.vm_ipv6),
     period: payload?.period ? {
-      start_timestamp: asString3(payload.period.start_timestamp) ?? void 0,
+      start_timestamp: asString4(payload.period.start_timestamp) ?? void 0,
       duration_seconds: asNumber3(payload.period.duration_seconds) ?? void 0
     } : null
   };
@@ -1439,7 +1674,7 @@ async function fetch2n6WebAccessUrl2(itemHash, options) {
   return {
     url: normalizeProxyUrl2(payload?.url ?? payload?.subdomain),
     active: typeof payload?.active === "boolean" ? payload.active : null,
-    subdomain: asString3(payload?.subdomain)
+    subdomain: asString4(payload?.subdomain)
   };
 }
 async function fetchCrnExecutionMap2(crnUrl, options) {
@@ -1659,7 +1894,7 @@ function utf8Hex(value) {
 function normalizeHexSignature(signature) {
   return signature.startsWith("0x") ? signature : `0x${signature}`;
 }
-function asString4(value) {
+function asString5(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function trimTrailingSlashes(value) {
@@ -1736,14 +1971,14 @@ async function fetchInstanceNodeHash(args) {
     apiHost: args.apiHost
   });
   const payload = envelope;
-  return asString4(payload?.content?.requirements?.node?.node_hash) ?? asString4(payload?.message?.content?.requirements?.node?.node_hash) ?? null;
+  return asString5(payload?.content?.requirements?.node?.node_hash) ?? asString5(payload?.message?.content?.requirements?.node?.node_hash) ?? null;
 }
 async function resolveInstanceCrn(args) {
-  const providedCrnUrl = asString4(args.crnUrl);
+  const providedCrnUrl = asString5(args.crnUrl);
   if (providedCrnUrl) {
     return {
       crnUrl: trimTrailingSlashes(providedCrnUrl),
-      crnHash: asString4(args.crnHash),
+      crnHash: asString5(args.crnHash),
       source: "provided"
     };
   }
@@ -1754,11 +1989,11 @@ async function resolveInstanceCrn(args) {
   if (allocation?.crnUrl) {
     return {
       crnUrl: trimTrailingSlashes(allocation.crnUrl),
-      crnHash: asString4(allocation.crnHash),
+      crnHash: asString5(allocation.crnHash),
       source: "scheduler"
     };
   }
-  const manualCrnHash = asString4(args.crnHash) ?? await fetchInstanceNodeHash({
+  const manualCrnHash = asString5(args.crnHash) ?? await fetchInstanceNodeHash({
     instanceHash: args.instanceHash,
     fetch: args.fetch,
     apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST2
@@ -3824,6 +4059,7 @@ function defaultState(props = {}) {
     },
     balance: null,
     crns: [],
+    crnSource: null,
     selectedCrn: null,
     crnOptions: [],
     crnPinnedByUser: false,
@@ -3831,7 +4067,8 @@ function defaultState(props = {}) {
     bootstrapRegistrations: [],
     orphanBootstrapRegistrations: [],
     lastDeploymentHash: null,
-    deploymentProgress: IDLE_DEPLOYMENT_PROGRESS
+    deploymentProgress: IDLE_DEPLOYMENT_PROGRESS,
+    instanceAddresses: {}
   };
 }
 function manifestLoadErrorState(error) {
@@ -3852,6 +4089,17 @@ function isDebugEnabled(props) {
     return false;
   }
 }
+function crnSourcePreference(props) {
+  const fromStorage = (() => {
+    try {
+      return globalThis.localStorage?.getItem("LE_SPACE_CRN_SOURCE") ?? null;
+    } catch {
+      return null;
+    }
+  })();
+  const raw = (fromStorage ?? props.crnSource ?? "auto").trim().toLowerCase();
+  return raw === "aggregate" || raw === "list" ? raw : "auto";
+}
 async function sha256Hex(payload) {
   const digest = await globalThis.crypto.subtle.digest(
     "SHA-256",
@@ -3859,6 +4107,83 @@ async function sha256Hex(payload) {
   );
   return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
+function hostnameOfUrl(value) {
+  if (!value) return null;
+  try {
+    return new URL(value).hostname || null;
+  } catch {
+    return null;
+  }
+}
+function emptyInstanceAddresses() {
+  return {
+    status: "idle",
+    groups: [],
+    pwaEnv: null,
+    payload: null,
+    peerId: null,
+    version: null,
+    fetchedAt: null,
+    error: null,
+    sourceUrl: null
+  };
+}
+var TRANSPORT_LABELS = {
+  tcp: "TCP",
+  websocket: "WebSocket",
+  webrtc: "WebRTC",
+  direct_tcp: "Direct TCP",
+  autotls_wss: "AutoTLS WSS",
+  proxy_wss: "Proxy WSS",
+  webtransport: "WebTransport",
+  webrtc_direct: "WebRTC Direct",
+  browser_bootstrap: "Browser bootstrap",
+  probe: "Probe"
+};
+function transportLabel(key) {
+  return TRANSPORT_LABELS[key] ?? key.replace(/[_-]+/g, " ").replace(/^./, (first) => first.toUpperCase());
+}
+function addressList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && Boolean(entry.trim())) : [];
+}
+function parseInstanceAddressPayload(payload) {
+  const groups = [];
+  const byTransport = payload.byTransport;
+  if (byTransport && typeof byTransport === "object") {
+    for (const [key, value] of Object.entries(
+      byTransport
+    )) {
+      const addresses = addressList(value);
+      if (addresses.length > 0) {
+        groups.push({ key, label: transportLabel(key), addresses });
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(payload)) {
+    if (!key.endsWith("_multiaddrs")) continue;
+    const addresses = addressList(value);
+    if (addresses.length === 0) continue;
+    const groupKey = key.replace(/_multiaddrs$/, "");
+    groups.push({
+      key: groupKey,
+      label: transportLabel(groupKey),
+      addresses
+    });
+  }
+  const pwaEnvRaw = payload.pwa_env;
+  const pwaEnv = pwaEnvRaw && typeof pwaEnvRaw === "object" ? Object.fromEntries(
+    Object.entries(pwaEnvRaw).filter(([, entry]) => typeof entry === "string").map(([entryKey, entry]) => [entryKey, entry])
+  ) : null;
+  const peerId = typeof payload.peerId === "string" ? payload.peerId : typeof payload.peer_id === "string" ? payload.peer_id : null;
+  return {
+    ...emptyInstanceAddresses(),
+    groups,
+    pwaEnv,
+    payload,
+    peerId,
+    version: typeof payload.version === "string" ? payload.version : null
+  };
+}
 function mappedPorts(execution) {
   return Object.entries(execution?.networking?.mapped_ports ?? {}).map(
     ([port, mapping]) => ({
@@ -4007,6 +4332,7 @@ async function inspectInstanceRuntime(args) {
     vmIpv4: null,
     webUrl: null,
     sshCommand: null,
+    proxyHostname: null,
     mappedPorts: [],
     execution: null,
     error: null
@@ -4071,6 +4397,7 @@ async function inspectInstanceRuntime(args) {
     details.ipv6 = execution.networking.ipv6_ip ?? execution.networking.ipv6 ?? details.ipv6;
     details.vmIpv4 = execution.networking.ipv4_ip ?? null;
     details.webUrl = execution.networking.proxy_url ?? details.webUrl;
+    details.proxyHostname = hostnameOfUrl(details.webUrl);
     details.mappedPorts = mappedPorts(execution);
     details.sshCommand = buildSshCommand(details.hostIpv4, details.mappedPorts);
     return { details, lookup };
@@ -4149,6 +4476,7 @@ var SponsorRelayController = class {
       apiHost: props.apiHost,
       apiHosts: props.apiHosts,
       crnListUrl: props.crnListUrl,
+      crnSource: crnSourcePreference(props),
       schedulerApiHost: props.schedulerApiHost,
       twoN6ApiHost: props.twoN6ApiHost
     });
@@ -4420,10 +4748,14 @@ var SponsorRelayController = class {
         detail: "Publishing the host port mapping into the guest relay configuration."
       });
       const tcpPort = mappedPorts2["9091"]?.host ?? 0;
-      const wsPort = mappedPorts2["9092"]?.host ?? mappedPorts2["443"]?.host ?? 0;
+      const wsPort = mappedPorts2["9092"]?.host ?? 0;
       if (!tcpPort || !wsPort) {
+        const missing = [
+          tcpPort ? null : "9091 (libp2p TCP)",
+          wsPort ? null : "9092 (libp2p WebSocket)"
+        ].filter(Boolean);
         throw new Error(
-          "OrbitDB relay runtime is missing required mapped TCP/WS ports."
+          `OrbitDB relay runtime has no mapped host port for ${missing.join(" and ")}. Deploy a rootfs whose manifest requests these forwards.`
         );
       }
       const configureResult = await configureOrbitdbRelaySetup2({
@@ -5367,10 +5699,18 @@ var SponsorRelayController = class {
       statusText: currentProfile === "ucan-store" ? "Refreshing service deployment data" : "Refreshing relay deployment data"
     });
     try {
-      const [pricingSummary, crns] = await Promise.all([
+      const [pricingSummary, crnList] = await Promise.all([
         fetchInstancePricing(this.client.apiHost),
-        this.client.fetchCrns()
+        this.client.fetchCrnsWithSource(crnSourcePreference(this.props))
       ]);
+      const { crns, source: crnSource } = crnList;
+      if (crnList.listError) {
+        this.trace("crns:fallback", {
+          source: crnSource,
+          count: crns.length,
+          listError: crnList.listError.message
+        });
+      }
       const manifestState = await resolveManifest({
         manifestUrl: this.state.manifestUrl,
         manifestJson: this.state.manifestJson
@@ -5406,6 +5746,7 @@ var SponsorRelayController = class {
                 vmIpv4: null,
                 webUrl: null,
                 sshCommand: null,
+                proxyHostname: null,
                 mappedPorts: [],
                 execution: null,
                 error: null
@@ -5519,6 +5860,7 @@ var SponsorRelayController = class {
         },
         balance,
         crns,
+        crnSource,
         instances,
         bootstrapRegistrations,
         orphanBootstrapRegistrations,
@@ -5596,10 +5938,21 @@ var SponsorRelayController = class {
         }
       });
       const preferredCrnHash = this.state.selectedCrn?.hash ?? null;
-      const orderedCrns = [
+      const rankedCrns = [
         ...compatibleCrns2.filter((crn) => crn.hash === preferredCrnHash),
         ...compatibleCrns2.filter((crn) => crn.hash !== preferredCrnHash)
       ].slice(0, 5);
+      const orderedCrns = this.state.crnSource === "aggregate" ? await filterReachableCrns(rankedCrns, {
+        limit: rankedCrns.length,
+        onDiagnostic: (message) => this.trace("crns:probe", { message })
+      }).then(
+        (reachable) => preferredCrnHash && !reachable.some((crn) => crn.hash === preferredCrnHash) ? [
+          ...rankedCrns.filter(
+            (crn) => crn.hash === preferredCrnHash
+          ),
+          ...reachable
+        ] : reachable
+      ) : rankedCrns;
       if (orderedCrns.length === 0) {
         throw new Error(
           "No compatible CRN is currently available for this tier."
@@ -5821,6 +6174,9 @@ var SponsorRelayController = class {
             vmIpv4: runtime.execution?.networking?.ipv4_ip ?? null,
             webUrl: runtime.webAccessUrl ?? runtime.proxyUrl ?? runtime.execution?.networking?.proxy_url ?? null,
             sshCommand: runtime.sshCommand ?? null,
+            proxyHostname: hostnameOfUrl(
+              runtime.proxyUrl ?? runtime.webAccessUrl ?? runtime.execution?.networking?.proxy_url ?? null
+            ),
             mappedPorts: runtime.execution != null ? mappedPorts(runtime.execution) : runtimeMappedPorts(runtime.mappedPorts),
             execution: runtime.execution ?? null,
             error: null
@@ -5918,6 +6274,9 @@ var SponsorRelayController = class {
                       vmIpv4: latestRuntime.execution?.networking?.ipv4_ip ?? null,
                       webUrl: latestRuntime.webAccessUrl ?? latestRuntime.proxyUrl ?? latestRuntime.execution?.networking?.proxy_url ?? null,
                       sshCommand: latestRuntime.sshCommand ?? null,
+                      proxyHostname: hostnameOfUrl(
+                        latestRuntime.proxyUrl ?? latestRuntime.webAccessUrl ?? latestRuntime.execution?.networking?.proxy_url ?? null
+                      ),
                       mappedPorts: latestRuntime.execution != null ? mappedPorts(latestRuntime.execution) : runtimeMappedPorts(latestRuntime.mappedPorts),
                       execution: latestRuntime.execution ?? null,
                       error: null
@@ -6098,6 +6457,82 @@ var SponsorRelayController = class {
       });
     }
   }
+  /**
+   * Read one deployment's own address document over its HTTPS proxy.
+   *
+   * The mapped ports are plain HTTP, which a browser on an HTTPS page refuses to
+   * fetch, so the proxy hostname is the only way in. Deliberately single-shot:
+   * unlike the deploy-time readiness probe this backs a button someone pressed,
+   * and a caller who wants newer data presses it again.
+   */
+  async loadInstanceAddresses(instanceHash, options = {}) {
+    const existing = this.state.instanceAddresses[instanceHash];
+    if (!options.force && existing && existing.status !== "idle") return;
+    const record = this.state.instances.find(
+      (entry) => entry.instance.item_hash === instanceHash
+    );
+    const proxyHostname = record?.details.proxyHostname ?? null;
+    if (!proxyHostname) {
+      this.patchInstanceAddresses(instanceHash, {
+        ...emptyInstanceAddresses(),
+        status: "unsupported",
+        error: "This deployment has no HTTPS proxy hostname yet, so its addresses cannot be read from the browser."
+      });
+      return;
+    }
+    const sourceUrl = `https://${proxyHostname}/multiaddrs`;
+    this.patchInstanceAddresses(instanceHash, {
+      ...existing ?? emptyInstanceAddresses(),
+      status: "loading",
+      sourceUrl,
+      error: null
+    });
+    try {
+      const abort = new AbortController();
+      const timeout = globalThis.setTimeout(() => abort.abort(), 1e4);
+      const response = await fetch(sourceUrl, {
+        cache: "no-cache",
+        signal: abort.signal
+      });
+      globalThis.clearTimeout(timeout);
+      if (response.status === 404) {
+        this.patchInstanceAddresses(instanceHash, {
+          ...emptyInstanceAddresses(),
+          status: "unsupported",
+          sourceUrl,
+          fetchedAt: Date.now(),
+          error: "This profile does not publish an address document."
+        });
+        return;
+      }
+      if (!response.ok) {
+        throw new Error(`${sourceUrl} answered ${response.status}.`);
+      }
+      const payload = await response.json();
+      this.patchInstanceAddresses(instanceHash, {
+        ...parseInstanceAddressPayload(payload),
+        status: "ready",
+        sourceUrl,
+        fetchedAt: Date.now(),
+        error: null
+      });
+    } catch (error) {
+      this.patchInstanceAddresses(instanceHash, {
+        ...this.state.instanceAddresses[instanceHash] ?? emptyInstanceAddresses(),
+        status: "error",
+        sourceUrl,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  patchInstanceAddresses(instanceHash, value) {
+    this.patch({
+      instanceAddresses: {
+        ...this.state.instanceAddresses,
+        [instanceHash]: value
+      }
+    });
+  }
   async deleteInstance(instanceHash) {
     this.trace("delete:start", { instanceHash });
     if (!this.state.wallet.address) {
@@ -6302,6 +6737,7 @@ export {
   getEthereumProvider,
   joinMappedPorts,
   joinRequiredPortForwards,
+  parseInstanceAddressPayload,
   personalSign,
   resolveManifestSource,
   rootfsHealth,