@le-space/ui 0.3.31 → 0.4.0

package/shared/index.js

@@ -7,6 +7,16 @@ var ROOTFS_MISSING_STATE = {
   label: "manifest missing",
   detail: "Provide a manifest URL or paste manifest JSON."
 };
+var RELAY_PING_IDLE_STATE = {
+  tone: "idle",
+  sent: false,
+  received: false,
+  lastPeerId: null,
+  lastLatencyMs: null,
+  lastSentAt: null,
+  lastReceivedAt: null,
+  error: null
+};
 var IDLE_DEPLOYMENT_PROGRESS = {
   stage: "idle",
   label: "Ready",
@@ -18,6 +28,7 @@ var IDLE_DEPLOYMENT_PROGRESS = {
   timestamp: Date.now()
 };
 var REFRESH_INTERVAL_MS = 3e4;
+var RELAY_PING_INTERVAL_MS = 2e4;
 var MANIFEST_SOURCE_REFRESH_DEBOUNCE_MS = 400;
 var INSTANCE_RUNTIME_READY_REFRESH_MS = 3e4;
 var INSTANCE_RUNTIME_PENDING_REFRESH_MS = 45e3;
@@ -27,7 +38,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.3.31";
+var UI_PACKAGE_VERSION = "0.4.0";
 
 // src/shared/format.ts
 function shortHash(value, head = 8, tail = 6) {
@@ -1236,6 +1247,16 @@ function normalizeBroadcastStatus(httpStatus, responseStatus) {
   if (httpStatus === 202) return "pending";
   return normalizeMessageStatus2(responseStatus);
 }
+function isInvalidMessageFormatResponse2(response, payload) {
+  if (response.status !== 422) return false;
+  const details = payload?.details;
+  if (typeof details === "string" && details.includes("InvalidMessageFormat")) return true;
+  if (details && typeof details === "object") {
+    const detailMessage = details.message;
+    if (typeof detailMessage === "string" && detailMessage.includes("InvalidMessageFormat")) return true;
+  }
+  return false;
+}
 function isRetryableBroadcastFailure(response, payload) {
   if (response.status >= 500) return true;
   const publicationStatus = payload?.publication_status?.status;
@@ -1257,22 +1278,25 @@ async function postBroadcastPayload2(body, options) {
   };
 }
 async function broadcastAlephMessage2(message, options) {
-  const requestBody = { sync: options.sync ?? false, message };
-  const maxAttempts = 3;
-  for (let index = 0; index < maxAttempts; index += 1) {
-    const result = await postBroadcastPayload2(requestBody, {
+  const attempts = [
+    { sync: options.sync ?? false, message },
+    { ...message, sync: options.sync ?? false },
+    { ...message }
+  ];
+  for (let index = 0; index < attempts.length; index += 1) {
+    const result = await postBroadcastPayload2(attempts[index], {
       apiHost: options.apiHost,
       fetch: options.fetch
     });
     if (result.httpStatus === 202 || normalizeBroadcastStatus(result.httpStatus, result.response?.message_status) !== "unknown" || result.httpStatus >= 200 && result.httpStatus < 300) {
       return result;
     }
-    const canRetry = index < maxAttempts - 1 && isRetryableBroadcastFailure({ status: result.httpStatus }, result.response);
+    const canRetry = index < attempts.length - 1 && (isInvalidMessageFormatResponse2({ status: result.httpStatus }, result.response) || isRetryableBroadcastFailure({ status: result.httpStatus }, result.response));
     if (!canRetry) {
       throw new Error(`Broadcast failed: ${result.httpStatus} ${JSON.stringify(result.response ?? {})}`);
     }
   }
-  throw new Error("Broadcast failed: retry budget exhausted");
+  throw new Error("Broadcast failed: no compatible request format was accepted");
 }
 
 // ../core/src/forget.ts
@@ -1877,13 +1901,6 @@ async function waitForVmRuntime(args) {
 }
 
 // ../core/src/guest.ts
-function proxyHostnameFromUrl(value) {
-  try {
-    return value ? new URL(value).hostname : null;
-  } catch {
-    return null;
-  }
-}
 async function defaultHttpProbe(fetch2, url, timeoutMs = 1e4) {
   try {
     const controller = new AbortController();
@@ -2125,59 +2142,6 @@ async function fetchUcGoPeerMetadata(args) {
     `Relay metadata did not become ready after ${attempts} attempts: ${lastError ? lastError : typeof lastPayload === "string" ? lastPayload : JSON.stringify(lastPayload ?? {})}`
   );
 }
-async function verifyUcGoPeerReachability(args) {
-  const checks = {};
-  const mappedPorts2 = args.mappedPorts ?? {};
-  const hostIpv4 = args.hostIpv4;
-  const skippedInternalPorts = new Set(
-    (args.skipInternalPorts ?? ["80"]).map((value) => String(value))
-  );
-  const httpProbe = args.httpProbe ?? ((url, timeoutMs) => defaultHttpProbe(args.fetch, url, timeoutMs));
-  if (hostIpv4) {
-    for (const [internalPort, mapping] of Object.entries(mappedPorts2)) {
-      if (skippedInternalPorts.has(String(internalPort))) continue;
-      if (mapping?.tcp === true && mapping?.host) {
-        checks[`tcp:${internalPort}`] = {
-          host: hostIpv4,
-          port: mapping.host,
-          ...await args.tcpProbe(
-            hostIpv4,
-            mapping.host,
-            Number(args.tcpTimeoutMs ?? 5e3)
-          )
-        };
-      } else if (mapping?.udp === true && mapping?.host) {
-        checks[`udp:${internalPort}`] = {
-          host: hostIpv4,
-          port: mapping.host,
-          ok: null,
-          note: "UDP mapping published; CI does not perform an application-level UDP handshake probe."
-        };
-      }
-    }
-  }
-  if (args.proxyUrl && args.verifyProxyHttp !== false) {
-    checks["https:proxy"] = await httpProbe(
-      args.proxyUrl,
-      Number(args.httpTimeoutMs ?? 1e4)
-    );
-  }
-  const proxyHostname = proxyHostnameFromUrl(args.proxyUrl);
-  if (proxyHostname) {
-    checks["tcp:proxy-443"] = await args.tcpProbe(
-      proxyHostname,
-      443,
-      Number(args.tcpTimeoutMs ?? 5e3)
-    );
-  }
-  const failedChecks = Object.entries(checks).filter(
-    ([, value]) => value?.ok === false
-  );
-  return {
-    ok: failedChecks.length === 0,
-    checks
-  };
-}
 
 // ../aleph-bootstrap/src/index.ts
 import { recoverMessageAddress } from "viem";
@@ -2719,16 +2683,6 @@ async function publishRelayBootstrapRegistration(args) {
 
 // ../core/src/bootstrap-config.ts
 var VM_BOOTSTRAP_CONFIG_AGGREGATE_KEY = "vm-bootstrap-config";
-var VM_BOOTSTRAP_CONFIG_SIGNAL_REF = "vm-bootstrap-config";
-var VM_BOOTSTRAP_CONFIG_SIGNAL_POST_TYPE = "vm-bootstrap-config-status";
-function parseJsonObject(value) {
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
 async function fetchVmBootstrapConfigAggregate(address, options) {
   const requestUrl = new URL(`/api/v0/aggregates/${address}.json`, options.apiHost ?? DEFAULT_ALEPH_API_HOST2);
   requestUrl.searchParams.set("keys", VM_BOOTSTRAP_CONFIG_AGGREGATE_KEY);
@@ -2848,89 +2802,6 @@ async function deleteVmBootstrapConfig(args) {
     aggregate: content
   };
 }
-function normalizeVmBootstrapConfigSignalRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const candidate = value;
-  const deploymentToken = typeof candidate.deploymentToken === "string" ? candidate.deploymentToken.trim() : "";
-  const status = typeof candidate.status === "string" ? candidate.status.trim() : "";
-  const profile = typeof candidate.profile === "string" ? candidate.profile.trim() : "";
-  const ownerAddress = typeof candidate.ownerAddress === "string" ? candidate.ownerAddress.trim() : "";
-  const instanceItemHash = typeof candidate.instanceItemHash === "string" ? candidate.instanceItemHash.trim() : "";
-  const updatedAt = typeof candidate.updatedAt === "string" ? candidate.updatedAt.trim() : "";
-  if (!deploymentToken || !status || !profile || !ownerAddress || !instanceItemHash || !updatedAt) {
-    return null;
-  }
-  return {
-    deploymentToken,
-    status,
-    profile,
-    ownerAddress,
-    instanceItemHash,
-    updatedAt,
-    publisherAddress: typeof candidate.publisherAddress === "string" && candidate.publisherAddress.trim() ? candidate.publisherAddress.trim() : null,
-    authorization: candidate.authorization,
-    peerId: typeof candidate.peerId === "string" && candidate.peerId.trim() ? candidate.peerId.trim() : null,
-    probeMultiaddrs: Array.isArray(candidate.probeMultiaddrs) ? candidate.probeMultiaddrs.filter(
-      (entry) => typeof entry === "string" && entry.trim().length > 0
-    ) : [],
-    browserBootstrapMultiaddrs: Array.isArray(candidate.browserBootstrapMultiaddrs) ? candidate.browserBootstrapMultiaddrs.filter(
-      (entry) => typeof entry === "string" && entry.trim().length > 0
-    ) : []
-  };
-}
-async function fetchVmBootstrapConfigSignals(args) {
-  const requestUrl = new URL("/api/v0/posts.json", args.apiHost ?? DEFAULT_ALEPH_API_HOST2);
-  requestUrl.searchParams.set("refs", args.ref ?? VM_BOOTSTRAP_CONFIG_SIGNAL_REF);
-  requestUrl.searchParams.set("types", args.postType ?? VM_BOOTSTRAP_CONFIG_SIGNAL_POST_TYPE);
-  requestUrl.searchParams.set("pagination", String(Math.max(1, Number(args.pagination ?? 100))));
-  requestUrl.searchParams.set("page", String(Math.max(1, Number(args.page ?? 1))));
-  requestUrl.searchParams.set("sortOrder", "-1");
-  const response = await args.fetch(requestUrl.toString(), { cache: "no-cache" });
-  if (!response.ok) {
-    throw new Error(`VM bootstrap config signal request failed: ${response.status}`);
-  }
-  const payload = await response.json();
-  const expectedDeploymentToken = args.deploymentToken?.trim() ?? "";
-  const expectedOwnerAddress = args.ownerAddress?.trim().toLowerCase() ?? "";
-  const expectedInstanceItemHash = args.instanceItemHash?.trim() ?? "";
-  return (payload.posts ?? []).map((entry) => {
-    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
-    const parsed = "content" in entry && entry.content && typeof entry.content === "object" && !Array.isArray(entry.content) ? entry.content : "item_content" in entry && typeof entry.item_content === "string" ? parseJsonObject(entry.item_content) : null;
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    const content = "deploymentToken" in parsed ? parsed : "content" in parsed && parsed.content && typeof parsed.content === "object" && !Array.isArray(parsed.content) ? parsed.content : null;
-    if (!content || typeof content !== "object" || Array.isArray(content)) return null;
-    return normalizeVmBootstrapConfigSignalRecord(content);
-  }).filter((entry) => {
-    if (!entry) return false;
-    if (expectedDeploymentToken && entry.deploymentToken !== expectedDeploymentToken) return false;
-    if (expectedOwnerAddress && entry.ownerAddress.toLowerCase() !== expectedOwnerAddress) return false;
-    if (expectedInstanceItemHash && entry.instanceItemHash !== expectedInstanceItemHash) return false;
-    return true;
-  });
-}
-async function waitForVmBootstrapConfigSignal(args) {
-  const attempts = Math.max(1, Number(args.attempts ?? 24));
-  const delayMs = Math.max(0, Number(args.delayMs ?? 2500));
-  const sleep2 = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-  const expectedStatus = args.expectedStatus ?? "applied";
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const signals = await fetchVmBootstrapConfigSignals({
-      deploymentToken: args.deploymentToken,
-      ownerAddress: args.ownerAddress,
-      instanceItemHash: args.instanceItemHash,
-      fetch: args.fetch,
-      apiHost: args.apiHost,
-      ref: args.ref,
-      postType: args.postType
-    }).catch(() => []);
-    const match = signals.find((entry) => entry.status === expectedStatus) ?? null;
-    if (match) return match;
-    if (attempt < attempts - 1) {
-      await sleep2(delayMs);
-    }
-  }
-  return null;
-}
 
 // ../core/src/bootstrap-reconcile.ts
 function createRelayBootstrapRegistrationId(profile, instanceName, itemHash) {
@@ -3043,7 +2914,8 @@ function defaultState(props = {}) {
       connectingWallet: false,
       refreshing: false,
       deploying: false,
-      deletingInstanceHash: null
+      deletingInstanceHash: null,
+      deletingRegistrationHash: null
     },
     statusText: "Ready",
     errorText: null,
@@ -3069,6 +2941,9 @@ function defaultState(props = {}) {
     crns: [],
     selectedCrn: null,
     instances: [],
+    bootstrapRegistrations: [],
+    orphanBootstrapRegistrations: [],
+    relayPing: RELAY_PING_IDLE_STATE,
     lastDeploymentHash: null,
     deploymentProgress: IDLE_DEPLOYMENT_PROGRESS
   };
@@ -3173,6 +3048,20 @@ function relayProfileForManifest(manifest) {
   }
   return null;
 }
+function registrationIdInstanceItemHash(registrationId) {
+  const normalized = String(registrationId ?? "").trim();
+  if (!normalized) return null;
+  const parts = normalized.split(":").map((part) => part.trim()).filter(Boolean);
+  const candidate = parts.at(-1) ?? "";
+  return /^[0-9a-f]{64}$/i.test(candidate) ? candidate : null;
+}
+function relayBootstrapInstanceItemHash(entry) {
+  const authorizedInstanceItemHash = typeof entry?.content?.authorization?.payload?.instanceItemHash === "string" ? entry.content.authorization.payload.instanceItemHash.trim() : "";
+  if (authorizedInstanceItemHash) {
+    return authorizedInstanceItemHash;
+  }
+  return registrationIdInstanceItemHash(entry?.content?.registrationId);
+}
 async function inspectInstanceRuntime(args) {
   const details = {
     messageStatus: String(
@@ -3281,12 +3170,61 @@ function compatibleCrnsForTier(crns, state) {
   );
   return filterDeployableCrns(crns, { spec });
 }
+async function pingPeer(libp2p) {
+  if (!libp2p || typeof libp2p !== "object") {
+    return RELAY_PING_IDLE_STATE;
+  }
+  const candidate = libp2p;
+  const peers = candidate.getPeers?.() ?? [];
+  const firstPeer = peers[0];
+  if (!firstPeer) {
+    return {
+      ...RELAY_PING_IDLE_STATE,
+      tone: "caution",
+      error: "No connected relay peers available."
+    };
+  }
+  const sentAt = Date.now();
+  try {
+    const pingFn = candidate.services?.ping?.ping?.bind(candidate.services.ping) ?? candidate.ping?.bind(candidate);
+    if (!pingFn) {
+      return {
+        ...RELAY_PING_IDLE_STATE,
+        tone: "caution",
+        sent: true,
+        lastPeerId: String(firstPeer),
+        lastSentAt: sentAt,
+        error: "libp2p ping service not available."
+      };
+    }
+    const latency = await pingFn(firstPeer);
+    return {
+      tone: "ok",
+      sent: true,
+      received: true,
+      lastPeerId: String(firstPeer),
+      lastLatencyMs: Number(latency),
+      lastSentAt: sentAt,
+      lastReceivedAt: Date.now(),
+      error: null
+    };
+  } catch (error) {
+    return {
+      tone: "error",
+      sent: true,
+      received: false,
+      lastPeerId: String(firstPeer),
+      lastLatencyMs: null,
+      lastSentAt: sentAt,
+      lastReceivedAt: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 var UI_DEPLOY_WAIT_ATTEMPTS = 60;
 var UI_DEPLOY_WAIT_DELAY_MS = 5e3;
 var UI_RUNTIME_WAIT_ATTEMPTS = 40;
 var UI_RUNTIME_WAIT_DELAY_MS = 5e3;
-var UI_REACHABILITY_VERIFY_ATTEMPTS = 25;
-var UI_REACHABILITY_VERIFY_DELAY_MS = 3e3;
 function hasUsableRuntime(details) {
   return Boolean(details.hostIpv4) || Boolean(details.vmIpv4) || details.mappedPorts.length > 0 || Boolean(details.webUrl) || Boolean(details.execution);
 }
@@ -3313,6 +3251,7 @@ var SponsorRelayController = class {
   subscribers = /* @__PURE__ */ new Set();
   client;
   refreshTimer = null;
+  pingTimer = null;
   manifestRefreshTimer = null;
   stopWalletWatch = null;
   props;
@@ -3368,7 +3307,8 @@ var SponsorRelayController = class {
       ...patch,
       busy: patch.busy ? { ...this.state.busy, ...patch.busy } : this.state.busy,
       wallet: patch.wallet ? { ...this.state.wallet, ...patch.wallet } : this.state.wallet,
-      pricingSummary: patch.pricingSummary ? { ...this.state.pricingSummary, ...patch.pricingSummary } : this.state.pricingSummary
+      pricingSummary: patch.pricingSummary ? { ...this.state.pricingSummary, ...patch.pricingSummary } : this.state.pricingSummary,
+      relayPing: patch.relayPing ? { ...this.state.relayPing, ...patch.relayPing } : this.state.relayPing
     };
     this.emit();
   }
@@ -3393,21 +3333,19 @@ var SponsorRelayController = class {
     this.progressEmitter.emit(nextEvent);
   }
   async configureRelayBootstrapRegistration(args) {
-    let runtime = args.runtime;
     const profile = relayProfileForManifest(this.state.manifest);
     if (!profile) return;
     if (!this.state.wallet.address) {
       throw new Error("A connected wallet is required to register relay bootstrap addresses.");
     }
-    if (!runtime.hostIpv4) {
+    if (!args.runtime.hostIpv4) {
       throw new Error("Relay runtime did not expose a host IPv4 address.");
     }
-    let mappedPorts2 = runtime.mappedPorts ?? {};
+    const mappedPorts2 = args.runtime.mappedPorts ?? {};
     const setupPort = mappedPorts2["80"]?.host ?? null;
     if (!setupPort) {
       throw new Error("Relay runtime did not expose the temporary setup endpoint.");
     }
-    let bootstrapSignalRelayMetadata = null;
     if (profile === "orbitdb-relay-pinner") {
       this.emitProgress({
         stage: "deployment-confirmed",
@@ -3418,7 +3356,7 @@ var SponsorRelayController = class {
         detail: "Waiting for the guest setup endpoint before collecting relay metadata."
       });
       const setupHealth = await waitForSetupEndpoint({
-        hostIpv4: runtime.hostIpv4,
+        hostIpv4: args.runtime.hostIpv4,
         setupPort,
         fetch: (url, init) => fetch(url, init),
         attempts: 15,
@@ -3444,12 +3382,12 @@ var SponsorRelayController = class {
         throw new Error("OrbitDB relay runtime is missing required mapped TCP/WS ports.");
       }
       const configureResult = await configureOrbitdbRelaySetup2({
-        hostIpv4: runtime.hostIpv4,
-        publicIpv6: runtime.ipv6,
+        hostIpv4: args.runtime.hostIpv4,
+        publicIpv6: args.runtime.ipv6,
         setupPort,
         tcpPort,
         wsPort,
-        proxyUrl: runtime.proxyUrl ?? void 0,
+        proxyUrl: args.runtime.proxyUrl ?? void 0,
         metricsPort: mappedPorts2["9090"]?.host ?? null,
         metricsHttpsPort: mappedPorts2["443"]?.host ?? null,
         webrtcPort: mappedPorts2["9093"]?.host ?? null,
@@ -3466,54 +3404,6 @@ var SponsorRelayController = class {
       if (!args.deploymentToken) {
         throw new Error("Missing deployment token for Aleph bootstrap config handoff.");
       }
-      if (runtime.proxyUrl && runtime.webAccess?.active !== true) {
-        this.emitProgress({
-          stage: "deployment-confirmed",
-          label: "Waiting for HTTPS route",
-          progress: 93,
-          status: "warning",
-          itemHash: args.itemHash,
-          detail: "The relay received a 2n6 hostname, but it is not active yet. Waiting before handing HTTPS config to the guest."
-        });
-        let latestRuntime = runtime;
-        for (let attempt = 0; attempt < UI_RUNTIME_WAIT_ATTEMPTS; attempt += 1) {
-          if (latestRuntime.webAccess?.active === true) {
-            break;
-          }
-          await new Promise(
-            (resolve) => globalThis.setTimeout(resolve, UI_RUNTIME_WAIT_DELAY_MS)
-          );
-          latestRuntime = await fetchVmRuntime({
-            itemHash: args.itemHash,
-            fetch: (url, init) => fetch(url, init),
-            crnHash: runtime.selectedCrn?.hash ?? runtime.allocation?.crnHash ?? void 0,
-            crns: this.state.crns,
-            crnListUrl: this.props.crnListUrl
-          }).catch(() => latestRuntime);
-          this.emitProgress({
-            stage: "deployment-confirmed",
-            label: "Waiting for HTTPS route",
-            progress: 93,
-            status: latestRuntime.webAccess?.active === true ? "info" : "warning",
-            itemHash: args.itemHash,
-            detail: `2n6 activation ${attempt + 1}/${UI_RUNTIME_WAIT_ATTEMPTS}: ${latestRuntime.webAccess?.active === true ? "active" : "still pending"} for ${latestRuntime.proxyUrl ?? runtime.proxyUrl ?? "reserved proxy URL"}.`
-          });
-          this.trace("deploy:bootstrap-proxy-activation", {
-            itemHash: args.itemHash,
-            attempt: attempt + 1,
-            attempts: UI_RUNTIME_WAIT_ATTEMPTS,
-            active: latestRuntime.webAccess?.active === true,
-            proxyUrl: latestRuntime.proxyUrl ?? null
-          });
-        }
-        runtime = latestRuntime;
-        mappedPorts2 = runtime.mappedPorts ?? mappedPorts2;
-      }
-      if (!runtime.hostIpv4) {
-        throw new Error("Relay runtime lost its host IPv4 address while waiting for HTTPS activation.");
-      }
-      const runtimeHostIpv4 = runtime.hostIpv4;
-      const activeProxyUrl = runtime.webAccess?.active === true ? runtime.proxyUrl ?? null : null;
       this.emitProgress({
         stage: "deployment-confirmed",
         label: "Publishing relay config",
@@ -3531,9 +3421,9 @@ var SponsorRelayController = class {
         expiresAt: new Date(Date.now() + 30 * 6e4).toISOString(),
         status: "pending",
         runtime: {
-          publicIpv4: runtimeHostIpv4,
-          publicIpv6: runtime.ipv6 ?? null,
-          proxyUrl: activeProxyUrl,
+          publicIpv4: args.runtime.hostIpv4,
+          publicIpv6: args.runtime.ipv6 ?? null,
+          proxyUrl: args.runtime.proxyUrl ?? null,
           mappedPorts: mappedPorts2
         },
         bootstrap: {
@@ -3562,164 +3452,49 @@ var SponsorRelayController = class {
         aggregateItemHash: bootstrapConfigPublication.aggregateItemHash,
         aggregateStatus: bootstrapConfigPublication.aggregateStatus
       });
-      this.emitProgress({
-        stage: "deployment-confirmed",
-        label: "Waiting for guest config",
-        progress: 94,
-        status: "info",
-        itemHash: args.itemHash,
-        detail: "Waiting for the relay VM to acknowledge that it consumed the Aleph bootstrap config."
-      });
-      const bootstrapConfigSignal = await waitForVmBootstrapConfigSignal({
-        deploymentToken: args.deploymentToken,
-        ownerAddress: this.state.wallet.address,
-        instanceItemHash: args.itemHash,
-        fetch: asJsonFetch,
-        apiHost: this.client.apiHost,
-        attempts: 40,
-        delayMs: 3e3
-      });
-      this.trace("deploy:bootstrap-config-signal-visible", {
-        itemHash: args.itemHash,
-        deploymentToken: args.deploymentToken,
-        bootstrapConfigSignal
-      });
-      if (!bootstrapConfigSignal) {
-        throw new Error(
-          "The relay VM did not confirm that it applied the Aleph bootstrap config in time."
-        );
-      }
-      bootstrapSignalRelayMetadata = typeof bootstrapConfigSignal.peerId === "string" && bootstrapConfigSignal.peerId.length > 0 && Array.isArray(bootstrapConfigSignal.probeMultiaddrs) && bootstrapConfigSignal.probeMultiaddrs.length > 0 ? {
-        peerId: bootstrapConfigSignal.peerId,
-        probeMultiaddrs: bootstrapConfigSignal.probeMultiaddrs,
-        browserBootstrapMultiaddrs: bootstrapConfigSignal.browserBootstrapMultiaddrs ?? []
-      } : null;
-      if (runtime.proxyUrl && runtime.webAccess?.active !== true) {
-        this.trace("deploy:bootstrap-proxy-fallback", {
-          itemHash: args.itemHash,
-          deploymentToken: args.deploymentToken,
-          proxyUrl: runtime.proxyUrl,
-          bootstrapSignalRelayMetadata
-        });
-        this.emitProgress({
-          stage: "deployment-confirmed",
-          label: "Continuing without HTTPS route",
-          progress: 94,
-          status: "warning",
+    }
+    this.emitProgress({
+      stage: "publishing-bootstrap",
+      label: "Reading relay multiaddrs",
+      progress: 95,
+      status: "info",
+      itemHash: args.itemHash,
+      detail: "Waiting for the relay to report its final public multiaddrs."
+    });
+    const relayMetadata = await fetchRelayMetadataForRuntime({
+      runtime: args.runtime,
+      fetch: (url, init) => fetch(url, init),
+      preferSecureMetadata: profile === "uc-go-peer",
+      attempts: 80,
+      delayMs: 3e3,
+      timeoutMs: 24e4,
+      onAttempt: (result) => {
+        const payload = result.payload && typeof result.payload === "object" ? result.payload : null;
+        const metadata = payload?.metadata && typeof payload.metadata === "object" ? payload.metadata : null;
+        this.trace("deploy:relay-metadata-attempt", {
           itemHash: args.itemHash,
-          detail: "The 2n6 HTTPS route stayed inactive, so guest setup continued without Caddy. Secure browser routing can be enabled later when the proxy becomes available."
+          attempt: result.attempt,
+          attempts: result.attempts,
+          requestUrl: result.requestUrl,
+          metadataUrl: result.metadataUrl,
+          hostIpv4: result.hostIpv4,
+          setupPort: result.setupPort,
+          ok: result.ok,
+          status: result.status,
+          ready: result.ready,
+          error: result.error ?? null,
+          payloadStatus: payload && typeof payload.status === "string" ? payload.status : null,
+          peerId: metadata && typeof metadata.peer_id === "string" ? metadata.peer_id : null,
+          probeMultiaddrCount: Array.isArray(metadata?.probe_multiaddrs) ? metadata.probe_multiaddrs.length : 0,
+          browserBootstrapMultiaddrCount: Array.isArray(
+            metadata?.browser_bootstrap_multiaddrs
+          ) ? metadata.browser_bootstrap_multiaddrs.length : 0
         });
-        runtime = {
-          ...runtime,
-          proxyUrl: null,
-          webAccess: runtime.webAccess ? {
-            ...runtime.webAccess,
-            active: false
-          } : runtime.webAccess
-        };
       }
-    }
-    let relayMetadata = bootstrapSignalRelayMetadata;
-    if (relayMetadata) {
-      this.trace("deploy:relay-metadata-from-bootstrap-signal", {
-        itemHash: args.itemHash,
-        peerId: relayMetadata.peerId,
-        probeMultiaddrCount: relayMetadata.probeMultiaddrs.length,
-        browserBootstrapMultiaddrCount: relayMetadata.browserBootstrapMultiaddrs.length
-      });
-    } else {
-      this.emitProgress({
-        stage: "publishing-bootstrap",
-        label: "Reading relay multiaddrs",
-        progress: 95,
-        status: "info",
-        itemHash: args.itemHash,
-        detail: "Waiting for the relay to report its final public multiaddrs."
-      });
-      relayMetadata = await fetchRelayMetadataForRuntime({
-        runtime,
-        fetch: (url, init) => fetch(url, init),
-        preferSecureMetadata: profile === "uc-go-peer" && Boolean(runtime.proxyUrl),
-        attempts: 80,
-        delayMs: 3e3,
-        timeoutMs: 24e4,
-        onAttempt: (result) => {
-          const payload = result.payload && typeof result.payload === "object" ? result.payload : null;
-          const metadata = payload?.metadata && typeof payload.metadata === "object" ? payload.metadata : null;
-          this.trace("deploy:relay-metadata-attempt", {
-            itemHash: args.itemHash,
-            attempt: result.attempt,
-            attempts: result.attempts,
-            requestUrl: result.requestUrl,
-            metadataUrl: result.metadataUrl,
-            hostIpv4: result.hostIpv4,
-            setupPort: result.setupPort,
-            ok: result.ok,
-            status: result.status,
-            ready: result.ready,
-            error: result.error ?? null,
-            payloadStatus: payload && typeof payload.status === "string" ? payload.status : null,
-            peerId: metadata && typeof metadata.peer_id === "string" ? metadata.peer_id : null,
-            probeMultiaddrCount: Array.isArray(metadata?.probe_multiaddrs) ? metadata.probe_multiaddrs.length : 0,
-            browserBootstrapMultiaddrCount: Array.isArray(
-              metadata?.browser_bootstrap_multiaddrs
-            ) ? metadata.browser_bootstrap_multiaddrs.length : 0
-          });
-        }
-      });
-    }
+    });
     if (!relayMetadata) {
       throw new Error("Relay metadata did not include a peer ID and public multiaddrs.");
     }
-    if (profile === "uc-go-peer" && runtime.proxyUrl) {
-      this.emitProgress({
-        stage: "publishing-bootstrap",
-        label: "Verifying reachability",
-        progress: 96,
-        status: "info",
-        itemHash: args.itemHash,
-        detail: "Checking that the secure relay endpoint is reachable before trusting the deployment as ready."
-      });
-      const verificationUrl = (() => {
-        try {
-          return new URL("/bootstrap/metadata", runtime.proxyUrl).toString();
-        } catch {
-          return runtime.proxyUrl ?? "";
-        }
-      })();
-      let verificationResult = null;
-      for (let attempt = 0; attempt < UI_REACHABILITY_VERIFY_ATTEMPTS; attempt += 1) {
-        verificationResult = await verifyUcGoPeerReachability({
-          proxyUrl: verificationUrl,
-          verifyProxyHttp: true,
-          fetch: (url, init) => fetch(url, init),
-          tcpProbe: async () => ({ ok: null })
-        });
-        this.trace("deploy:reachability-verification-attempt", {
-          itemHash: args.itemHash,
-          attempt: attempt + 1,
-          attempts: UI_REACHABILITY_VERIFY_ATTEMPTS,
-          verificationUrl,
-          ok: verificationResult.ok,
-          checks: verificationResult.checks
-        });
-        const proxyHttpCheck2 = verificationResult.checks["https:proxy"];
-        if (verificationResult.ok && proxyHttpCheck2?.ok === true) {
-          break;
-        }
-        if (attempt < UI_REACHABILITY_VERIFY_ATTEMPTS - 1) {
-          await new Promise(
-            (resolve) => globalThis.setTimeout(resolve, UI_REACHABILITY_VERIFY_DELAY_MS)
-          );
-        }
-      }
-      const proxyHttpCheck = verificationResult?.checks["https:proxy"];
-      if (!verificationResult?.ok || proxyHttpCheck?.ok !== true) {
-        throw new Error(
-          proxyHttpCheck?.error ? `Secure relay endpoint did not become reachable in time: ${proxyHttpCheck.error}` : "Secure relay endpoint did not become reachable in time."
-        );
-      }
-    }
     const { peerId } = relayMetadata;
     const registrationId = createRelayBootstrapRegistrationId(
       profile,
@@ -3837,7 +3612,6 @@ var SponsorRelayController = class {
     const currentProgress = this.state.deploymentProgress;
     const currentProgressIsForLatestHash = currentProgress.itemHash === itemHash || currentProgress.itemHash == null && currentProgress.stage !== "idle" && currentProgress.stage !== "error";
     const keepTerminalSuccess = this.lastCompletedDeploymentHash === itemHash || currentProgressIsForLatestHash && currentProgress.stage === "completed" && currentProgress.status === "success";
-    const keepSpecificInFlightProgress = currentProgressIsForLatestHash && currentProgress.stage !== "completed" && currentProgress.stage !== "error" && currentProgress.progress >= 93;
     const status = latest.details.messageStatus;
     if (status === "rejected") {
       this.emitProgress({
@@ -3880,16 +3654,6 @@ var SponsorRelayController = class {
         });
         return;
       }
-      if (keepSpecificInFlightProgress) {
-        this.trace("progress:retain-inflight", {
-          reason: "latest refresh would overwrite a more specific in-flight deployment phase",
-          itemHash,
-          currentStage: currentProgress.stage,
-          currentLabel: currentProgress.label,
-          currentProgress: currentProgress.progress
-        });
-        return;
-      }
       this.emitProgress({
         stage: "deployment-confirmed",
         label: "Waiting for runtime",
@@ -3900,16 +3664,6 @@ var SponsorRelayController = class {
       });
       return;
     }
-    if (keepSpecificInFlightProgress) {
-      this.trace("progress:retain-inflight", {
-        reason: "latest refresh would overwrite a more specific in-flight deployment phase",
-        itemHash,
-        currentStage: currentProgress.stage,
-        currentLabel: currentProgress.label,
-        currentProgress: currentProgress.progress
-      });
-      return;
-    }
     this.emitProgress({
       stage: "deployment-confirmed",
       label: "Runtime ready",
@@ -3988,11 +3742,16 @@ var SponsorRelayController = class {
     this.refreshTimer = setInterval(() => {
       void this.refresh();
     }, REFRESH_INTERVAL_MS);
+    this.pingTimer = setInterval(() => {
+      void this.refreshRelayPing();
+    }, RELAY_PING_INTERVAL_MS);
+    await this.refreshRelayPing();
     this.patch({ ready: true });
     this.trace("init:ready");
   }
   destroy() {
     if (this.refreshTimer) clearInterval(this.refreshTimer);
+    if (this.pingTimer) clearInterval(this.pingTimer);
     if (this.manifestRefreshTimer) clearTimeout(this.manifestRefreshTimer);
     this.stopWalletWatch?.();
   }
@@ -4136,10 +3895,16 @@ var SponsorRelayController = class {
       const manifest = manifestState.manifest;
       let balance = this.state.balance;
       let instances = [];
+      let bootstrapRegistrations = [];
+      let orphanBootstrapRegistrations = [];
       if (this.state.wallet.address) {
-        const [nextBalance, rawInstances] = await Promise.all([
+        const [nextBalance, rawInstances, rawBootstrapPosts] = await Promise.all([
           this.client.fetchBalance(this.state.wallet.address),
-          this.state.showInstances ? this.client.fetchInstances(this.state.wallet.address) : Promise.resolve([])
+          this.state.showInstances ? this.client.fetchInstances(this.state.wallet.address) : Promise.resolve([]),
+          fetchAlephBootstrapPosts({
+            apiHost: this.client.apiHost,
+            fetch
+          }).catch(() => [])
         ]);
         balance = nextBalance;
         instances = await Promise.all(
@@ -4199,6 +3964,37 @@ var SponsorRelayController = class {
             };
           })
         );
+        const normalizedWalletAddress = this.state.wallet.address.toLowerCase();
+        const activeInstanceHashes = new Set(
+          instances.map((entry) => entry.instance.item_hash)
+        );
+        bootstrapRegistrations = selectCurrentRelayBootstrapPosts(rawBootstrapPosts).filter(
+          (entry) => entry.address?.toLowerCase() === normalizedWalletAddress
+        ).map((entry) => {
+          const instanceItemHash = relayBootstrapInstanceItemHash(entry);
+          const messageHash = entry.itemHash ?? entry.hash ?? null;
+          return {
+            messageHash,
+            hash: entry.hash ?? null,
+            itemHash: entry.itemHash ?? null,
+            address: entry.address ?? null,
+            time: entry.time ?? null,
+            instanceItemHash,
+            confirmed: Boolean(
+              instanceItemHash && activeInstanceHashes.has(instanceItemHash)
+            ),
+            content: entry.content ? {
+              peerId: entry.content.peerId,
+              registrationId: entry.content.registrationId,
+              multiaddrs: Array.isArray(entry.content.multiaddrs) ? entry.content.multiaddrs : [],
+              browserMultiaddrs: Array.isArray(entry.content.browserMultiaddrs) ? entry.content.browserMultiaddrs : [],
+              updatedAt: entry.content.updatedAt
+            } : null
+          };
+        });
+        orphanBootstrapRegistrations = bootstrapRegistrations.filter(
+          (entry) => !entry.confirmed
+        );
       }
       let rootfsVerified = false;
       let rootfsResolution = null;
@@ -4229,6 +4025,8 @@ var SponsorRelayController = class {
         balance,
         crns,
         instances,
+        bootstrapRegistrations,
+        orphanBootstrapRegistrations,
         busy: { refreshing: false },
         statusText: "Relay sponsor data ready"
       });
@@ -4248,6 +4046,11 @@ var SponsorRelayController = class {
       });
     }
   }
+  async refreshRelayPing() {
+    const relayPing = await pingPeer(this.props.libp2p);
+    this.patch({ relayPing });
+    this.trace("libp2p:relay-ping", relayPing);
+  }
   async deploy() {
     this.trace("deploy:start", {
       wallet: this.state.wallet.address,
@@ -4540,15 +4343,6 @@ var SponsorRelayController = class {
           });
           if (attemptItemHash) {
             if (attemptDeploymentToken) {
-              this.emitProgress({
-                stage: "refreshing-instances",
-                label: "Cleaning up failed attempt",
-                progress: 16,
-                status: "warning",
-                itemHash: attemptItemHash,
-                detail: `Removing bootstrap handoff state for failed deployment on ${attemptLabel}.`,
-                error: lastError.message
-              });
               this.trace("deploy:bootstrap-config-cleanup-start", {
                 itemHash: attemptItemHash,
                 deploymentToken: attemptDeploymentToken
@@ -4574,26 +4368,8 @@ var SponsorRelayController = class {
                   deploymentToken: attemptDeploymentToken,
                   error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
                 });
-                this.emitProgress({
-                  stage: "refreshing-instances",
-                  label: "Cleanup warning",
-                  progress: 16,
-                  status: "warning",
-                  itemHash: attemptItemHash,
-                  detail: `Bootstrap cleanup reported an issue for ${attemptLabel}, but retry cleanup will continue.`,
-                  error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
-                });
               });
             }
-            this.emitProgress({
-              stage: "refreshing-instances",
-              label: "Discarding failed deployment",
-              progress: 17,
-              status: "warning",
-              itemHash: attemptItemHash,
-              detail: `Forgetting failed deployment ${attemptItemHash.slice(0, 12)} on ${attemptLabel} before retrying.`,
-              error: lastError.message
-            });
             this.trace("deploy:forget-failed-attempt-start", {
               itemHash: attemptItemHash,
               crnHash: candidateCrn.hash,
@@ -4616,30 +4392,12 @@ var SponsorRelayController = class {
                 itemHash: attemptItemHash,
                 error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
               });
-              this.emitProgress({
-                stage: "refreshing-instances",
-                label: "Cleanup warning",
-                progress: 17,
-                status: "warning",
-                itemHash: attemptItemHash,
-                detail: `Failed deployment cleanup reported an issue for ${attemptLabel}.`,
-                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
-              });
             });
             this.trace("deploy:forget-failed-attempt-complete", {
               itemHash: attemptItemHash,
               crnHash: candidateCrn.hash,
               crnName: candidateCrn.name
             });
-            this.emitProgress({
-              stage: "refreshing-instances",
-              label: "Cleanup complete",
-              progress: 18,
-              status: "info",
-              itemHash: attemptItemHash,
-              detail: `Finished cleaning up failed deployment on ${attemptLabel}.`,
-              error: null
-            });
           }
           if (candidateIndex < orderedCrns.length - 1) {
             this.emitProgress({
@@ -4738,6 +4496,72 @@ var SponsorRelayController = class {
       });
     }
   }
+  async deleteBootstrapRegistration(registrationHash) {
+    this.trace("registration-delete:start", { registrationHash });
+    if (!this.state.wallet.address) {
+      this.patch({
+        errorText: "Connect MetaMask before forgetting registrations."
+      });
+      return;
+    }
+    this.patch({
+      busy: { deletingRegistrationHash: registrationHash },
+      errorText: null,
+      statusText: `Forgetting registration ${registrationHash}`
+    });
+    try {
+      this.emitProgress({
+        stage: "validating",
+        label: "Validating registration cleanup",
+        progress: 6,
+        status: "warning",
+        itemHash: registrationHash,
+        detail: "Preparing Aleph FORGET message for the orphan bootstrap registration."
+      });
+      await forgetAlephMessages({
+        sender: this.state.wallet.address,
+        hashes: [registrationHash],
+        reason: "Deleted orphan relay bootstrap registration from Sponsor Relay panel",
+        signer: personalSign,
+        hasher: sha256Hex,
+        fetch: asJsonFetch,
+        apiHost: this.client.apiHost,
+        onProgress: (event) => {
+          this.emitProgress(event);
+        }
+      });
+      this.patch({
+        busy: { deletingRegistrationHash: null },
+        statusText: `Deletion submitted for ${registrationHash}`
+      });
+      this.emitProgress({
+        stage: "refreshing-instances",
+        label: "Refreshing registrations after delete",
+        progress: 92,
+        status: "info",
+        itemHash: registrationHash,
+        detail: "Reloading deployments and relay bootstrap registrations."
+      });
+      await this.refresh();
+      this.trace("registration-delete:submitted", { registrationHash });
+      this.emitProgress({
+        stage: "completed",
+        label: "Registration cleanup completed",
+        progress: 100,
+        status: "success",
+        itemHash: registrationHash,
+        detail: "Orphan relay bootstrap registration forgotten and state refreshed.",
+        error: null
+      });
+    } catch (error) {
+      this.trace("registration-delete:error", error);
+      this.patch({
+        busy: { deletingRegistrationHash: null },
+        errorText: error instanceof Error ? error.message : String(error),
+        statusText: "Registration cleanup failed"
+      });
+    }
+  }
 };
 function createSponsorRelayController(props = {}) {
   return new SponsorRelayController(props);
@@ -4754,6 +4578,8 @@ export {
   MANIFEST_SOURCE_REFRESH_DEBOUNCE_MS,
   RECENT_INSTANCE_RUNTIME_GRACE_MS,
   REFRESH_INTERVAL_MS,
+  RELAY_PING_IDLE_STATE,
+  RELAY_PING_INTERVAL_MS,
   ROOTFS_MISSING_STATE,
   STALE_INSTANCE_ALLOCATION_COOLDOWN_MS,
   SponsorRelayController,