@le-space/ui 0.1.62 → 0.3.0

package/shared/index.js

@@ -1831,6 +1831,28 @@ async function waitForVmRuntime(args) {
 }
 
 // ../core/src/guest.ts
+async function defaultHttpProbe(fetch2, url, timeoutMs = 1e4) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const response = await fetch2(url, {
+      method: "GET",
+      redirect: "follow",
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return {
+      ok: response.ok,
+      status: response.status,
+      url: response.url
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 async function notifyCrnAllocation2(args) {
   const normalizedCrnUrl = typeof args.crnUrl === "string" ? args.crnUrl.trim().replace(/\/+$/, "") : "";
   if (!normalizedCrnUrl) {
@@ -1911,6 +1933,324 @@ async function notifyCrnAllocationWithRetry(args) {
     reason: "CRN allocation notify was not confirmed."
   };
 }
+async function waitForSetupEndpoint(args) {
+  const attempts = Math.max(1, Number(args.attempts ?? 15));
+  const delayMs = Math.max(0, Number(args.delayMs ?? 4e3));
+  const sleep = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const url = `http://${args.hostIpv4}:${args.setupPort}/health`;
+  let result = await defaultHttpProbe(
+    args.fetch,
+    url,
+    Number(args.httpTimeoutMs ?? 1e4)
+  );
+  args.onAttempt?.(result, 1, attempts);
+  for (let attempt = 1; attempt < attempts; attempt += 1) {
+    if (result.ok) return result;
+    await sleep(delayMs);
+    result = await defaultHttpProbe(
+      args.fetch,
+      url,
+      Number(args.httpTimeoutMs ?? 1e4)
+    );
+    args.onAttempt?.(result, attempt + 1, attempts);
+  }
+  return result;
+}
+async function configureUcGoPeer(args) {
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    Number(args.timeoutMs ?? 18e4)
+  );
+  const payload = {
+    public_ipv4: args.hostIpv4,
+    public_ipv6: args.publicIpv6 ?? void 0,
+    proxy_url: args.proxyUrl ?? void 0,
+    tcp_port: args.tcpPort ?? void 0,
+    ws_port: args.wsPort ?? void 0,
+    udp_port: args.udpPort ?? void 0,
+    quic_port: args.quicPort ?? void 0,
+    webrtc_port: args.webrtcPort ?? void 0
+  };
+  try {
+    const response = await args.fetch(
+      `http://${args.hostIpv4}:${args.setupPort}/configure`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      }
+    );
+    const responsePayload = await response.json().catch(() => null);
+    if (!response.ok) {
+      throw new Error(
+        `Relay setup request failed: ${response.status} ${typeof responsePayload === "string" ? responsePayload : JSON.stringify(responsePayload ?? {})}`
+      );
+    }
+    return responsePayload;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function configureOrbitdbRelaySetup2(args) {
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    Number(args.timeoutMs ?? 18e4)
+  );
+  const payload = {
+    public_ipv4: args.hostIpv4,
+    public_ipv6: args.publicIpv6 ?? void 0,
+    tcp_port: args.tcpPort,
+    ws_port: args.wsPort,
+    proxy_url: args.proxyUrl ?? void 0,
+    metrics_port: args.metricsPort ?? void 0,
+    metrics_https_port: args.metricsHttpsPort ?? void 0,
+    webrtc_port: args.webrtcPort ?? void 0,
+    quic_port: args.quicPort ?? void 0
+  };
+  try {
+    const response = await args.fetch(
+      `http://${args.hostIpv4}:${args.setupPort}/configure`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      }
+    );
+    const responsePayload = await response.json().catch(() => null);
+    if (!response.ok) {
+      throw new Error(
+        `Relay setup request failed: ${response.status} ${typeof responsePayload === "string" ? responsePayload : JSON.stringify(responsePayload ?? {})}`
+      );
+    }
+    return responsePayload;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchUcGoPeerMetadata(args) {
+  const attempts = Math.max(1, Number(args.attempts ?? 60));
+  const delayMs = Math.max(0, Number(args.delayMs ?? 3e3));
+  const sleep = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let lastPayload = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      Number(args.timeoutMs ?? 18e4)
+    );
+    try {
+      const response = await args.fetch(
+        `http://${args.hostIpv4}:${args.setupPort}/metadata`,
+        {
+          signal: controller.signal
+        }
+      );
+      const payload = await response.json().catch(() => null);
+      lastPayload = payload;
+      args.onAttempt?.(
+        payload,
+        Boolean(
+          response.ok && payload && typeof payload === "object" && payload.status === "ready"
+        ),
+        attempt + 1,
+        attempts
+      );
+      if (response.ok && payload && typeof payload === "object" && payload.status === "ready") {
+        return payload;
+      }
+      if (response.status >= 500) {
+        throw new Error(
+          `Relay metadata request failed: ${response.status} ${typeof payload === "string" ? payload : JSON.stringify(payload ?? {})}`
+        );
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (attempt < attempts - 1) {
+      await sleep(delayMs);
+    }
+  }
+  throw new Error(
+    `Relay metadata did not become ready after ${attempts} attempts: ${typeof lastPayload === "string" ? lastPayload : JSON.stringify(lastPayload ?? {})}`
+  );
+}
+
+// ../aleph-bootstrap/src/index.ts
+var DEFAULT_ALEPH_API_HOST3 = "https://api2.aleph.im";
+var DEFAULT_ALEPH_BOOTSTRAP_CHANNEL = "simple-todo";
+var DEFAULT_ALEPH_BOOTSTRAP_REF = "simple-todo-bootstrap";
+var DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE = "relay-bootstrap";
+var DEFAULT_BOOTSTRAP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function normalizeHost(host) {
+  return host.trim().toLowerCase();
+}
+function splitMultiaddr(addr) {
+  return addr.split("/").filter(Boolean);
+}
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return false;
+  }
+  if (parts[0] === 10) return true;
+  if (parts[0] === 127) return true;
+  if (parts[0] === 0) return true;
+  if (parts[0] === 169 && parts[1] === 254) return true;
+  if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+  if (parts[0] === 192 && parts[1] === 168) return true;
+  if (parts[0] === 100 && parts[1] >= 64 && parts[1] <= 127) return true;
+  return false;
+}
+function isPrivateIpv6(ip) {
+  const normalized = ip.trim().toLowerCase();
+  return normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
+}
+function isLocalHostname(host) {
+  const normalized = normalizeHost(host);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local");
+}
+function hasPeerId(addr) {
+  return splitMultiaddr(addr).includes("p2p");
+}
+function isBrowserDialableMultiaddr(addr) {
+  const normalized = addr.toLowerCase();
+  return normalized.includes("/ws") || normalized.includes("/wss") || normalized.includes("/webtransport") || normalized.includes("/webrtc-direct");
+}
+function dedupeMultiaddrs(addrs) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of addrs) {
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
+function isPublicMultiaddr(addr) {
+  const parts = splitMultiaddr(addr);
+  for (let index = 0; index < parts.length; index += 1) {
+    const protocol = parts[index];
+    const value = parts[index + 1];
+    if (protocol === "ip4" && value) {
+      return !isPrivateIpv4(value);
+    }
+    if (protocol === "ip6" && value) {
+      return !isPrivateIpv6(value);
+    }
+    if ((protocol === "dns4" || protocol === "dns6" || protocol === "dnsaddr") && value) {
+      return !isLocalHostname(value);
+    }
+  }
+  return false;
+}
+function filterPublicMultiaddrs(addrs, options = {}) {
+  return dedupeMultiaddrs(addrs).filter((addr) => {
+    if (!isPublicMultiaddr(addr)) return false;
+    if (options.requirePeerId !== false && !hasPeerId(addr)) return false;
+    if (options.browserDialableOnly && !isBrowserDialableMultiaddr(addr)) {
+      return false;
+    }
+    return true;
+  });
+}
+function buildRelayBootstrapPostContent(args) {
+  const now = args.now ?? Date.now() / 1e3;
+  const updatedAt = args.now ?? Date.now();
+  return {
+    type: args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
+    address: args.sender,
+    ...args.ref ? { ref: args.ref } : {},
+    content: {
+      peerId: args.peerId,
+      multiaddrs: filterPublicMultiaddrs(args.multiaddrs),
+      browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
+        browserDialableOnly: true
+      }) : void 0,
+      profile: args.profile,
+      version: args.version,
+      updatedAt: Math.round(updatedAt)
+    },
+    time: now
+  };
+}
+async function createRelayBootstrapPost(args) {
+  const nowMillis = args.now ?? Date.now();
+  const nowSeconds = nowMillis / 1e3;
+  const itemContent = buildRelayBootstrapPostContent({
+    sender: args.sender,
+    peerId: args.peerId,
+    multiaddrs: args.multiaddrs,
+    browserMultiaddrs: args.browserMultiaddrs,
+    ref: args.ref ?? DEFAULT_ALEPH_BOOTSTRAP_REF,
+    postType: args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
+    profile: args.profile,
+    version: args.version,
+    now: nowMillis
+  });
+  itemContent.time = nowSeconds;
+  const serialized = JSON.stringify(itemContent);
+  const itemHash = await args.hasher(serialized);
+  return {
+    channel: args.channel ?? DEFAULT_ALEPH_BOOTSTRAP_CHANNEL,
+    sender: args.sender,
+    chain: "ETH",
+    type: "POST",
+    time: nowSeconds,
+    item_type: "inline",
+    item_content: serialized,
+    item_hash: itemHash
+  };
+}
+
+// ../core/src/bootstrap-registration.ts
+async function publishRelayBootstrapRegistration(args) {
+  const unsigned = await createRelayBootstrapPost({
+    sender: args.sender,
+    peerId: args.peerId,
+    multiaddrs: args.multiaddrs,
+    browserMultiaddrs: args.browserMultiaddrs,
+    channel: args.channel,
+    ref: args.ref,
+    postType: args.postType,
+    profile: args.profile,
+    version: args.version,
+    now: args.now,
+    hasher: args.hasher
+  });
+  const content = JSON.parse(unsigned.item_content);
+  if ((content.content?.multiaddrs?.length ?? 0) === 0) {
+    return {
+      status: "skipped",
+      reason: "No public relay multiaddrs remained after filtering.",
+      publishedMultiaddrs: [],
+      publishedBrowserMultiaddrs: content.content?.browserMultiaddrs ?? []
+    };
+  }
+  const message = await signAlephMessage(unsigned, args.signer);
+  const { response, httpStatus } = await broadcastAlephMessage2(message, {
+    apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST3,
+    sync: args.sync ?? true,
+    fetch: args.fetch
+  });
+  return {
+    status: "published",
+    itemHash: unsigned.item_hash,
+    message,
+    response,
+    httpStatus,
+    publishedMultiaddrs: content.content?.multiaddrs ?? [],
+    publishedBrowserMultiaddrs: content.content?.browserMultiaddrs ?? []
+  };
+}
 
 // src/shared/events.ts
 function createDeploymentProgressEmitter() {
@@ -1984,6 +2324,16 @@ function defaultState(props = {}) {
     deploymentProgress: IDLE_DEPLOYMENT_PROGRESS
   };
 }
+function isDebugEnabled(props) {
+  if (props.debug) {
+    return true;
+  }
+  try {
+    return globalThis.localStorage?.getItem("LE_SPACE_UI_DEBUG") === "1";
+  } catch {
+    return false;
+  }
+}
 async function sha256Hex(payload) {
   const digest = await globalThis.crypto.subtle.digest(
     "SHA-256",
@@ -1999,6 +2349,12 @@ function mappedPorts(execution) {
     })
   );
 }
+function runtimeMappedPorts(mappedPortsRecord) {
+  return Object.entries(mappedPortsRecord ?? {}).map(([port, mapping]) => ({
+    label: `${port}/${mapping.udp ? "udp" : "tcp"}`,
+    hostPort: mapping.host ?? null
+  }));
+}
 function rootfsHealth(args) {
   if (!args.manifestState.valid || !args.manifestState.manifest) {
     return {
@@ -2053,6 +2409,13 @@ async function resolveManifest(args) {
   if (pasted) return pasted;
   return loadRootfsManifest(args.manifestUrl);
 }
+function relayProfileForManifest(manifest) {
+  if (manifest?.profile === "uc-go-peer") return "uc-go-peer";
+  if (manifest?.profile === "orbitdb-relay-pinner") {
+    return "orbitdb-relay-pinner";
+  }
+  return null;
+}
 async function inspectInstanceRuntime(args) {
   const details = {
     messageStatus: String(
@@ -2069,8 +2432,18 @@ async function inspectInstanceRuntime(args) {
     execution: null,
     error: null
   };
-  if (details.messageStatus !== "processed") {
-    return details;
+  const lookup = {
+    allocationFound: false,
+    allocationSource: null,
+    crnUrl: null,
+    webUrl: null,
+    executionPayloadFound: false,
+    executionLookupBlocked: false,
+    executionLookupRequestUrl: null,
+    executionLookupVersion: null
+  };
+  if (details.messageStatus === "rejected" || details.messageStatus === "removing") {
+    return { details, lookup };
   }
   try {
     const allocation = await args.client.fetchSchedulerAllocation(args.instance.item_hash) ?? (() => {
@@ -2085,26 +2458,35 @@ async function inspectInstanceRuntime(args) {
         period: null
       } : null;
     })();
+    lookup.allocationFound = Boolean(allocation);
+    lookup.allocationSource = allocation?.source ?? null;
     details.allocationSource = allocation?.source ?? null;
     details.crnUrl = allocation?.crnUrl ?? null;
     details.ipv6 = allocation?.vmIpv6 ?? null;
     details.webUrl = await args.client.fetch2n6WebAccessUrl(
       args.instance.item_hash
     );
+    lookup.crnUrl = details.crnUrl;
+    lookup.webUrl = details.webUrl;
     if (!allocation?.crnUrl) {
-      return details;
+      return { details, lookup };
     }
     const executionLookup = await args.client.fetchCrnExecutionMap(
       allocation.crnUrl
     );
+    lookup.executionLookupBlocked = executionLookup.blocked;
+    lookup.executionLookupRequestUrl = executionLookup.requestUrl ?? null;
+    lookup.executionLookupVersion = executionLookup.version ?? null;
     const executionPayload = executionLookup.payload?.[args.instance.item_hash];
+    lookup.executionPayloadFound = Boolean(executionPayload);
     if (!executionPayload) {
-      return details;
+      return { details, lookup };
     }
     const execution = normalizeExecution(executionPayload, allocation.crnUrl);
     if (!execution.networking.proxy_url && details.webUrl) {
       execution.networking.proxy_url = details.webUrl;
     }
+    details.messageStatus = "processed";
     details.execution = execution;
     details.hostIpv4 = execution.networking.host_ipv4 ?? execution.networking.ipv4 ?? null;
     details.ipv6 = execution.networking.ipv6_ip ?? execution.networking.ipv6 ?? details.ipv6;
@@ -2112,11 +2494,14 @@ async function inspectInstanceRuntime(args) {
     details.webUrl = execution.networking.proxy_url ?? details.webUrl;
     details.mappedPorts = mappedPorts(execution);
     details.sshCommand = buildSshCommand(details.hostIpv4, details.mappedPorts);
-    return details;
+    return { details, lookup };
   } catch (error) {
     return {
-      ...details,
-      error: error instanceof Error ? error.message : String(error)
+      details: {
+        ...details,
+        error: error instanceof Error ? error.message : String(error)
+      },
+      lookup
     };
   }
 }
@@ -2225,9 +2610,13 @@ var SponsorRelayController = class {
   props;
   progressEmitter = createDeploymentProgressEmitter();
   runtimeCooldownByHash = /* @__PURE__ */ new Map();
+  runtimeDetailsByHash = /* @__PURE__ */ new Map();
+  debugEnabled;
+  lastRuntimeReadyHash = null;
   constructor(props = {}) {
     this.props = props;
     this.state = defaultState(props);
+    this.debugEnabled = isDebugEnabled(props);
     this.client = createAlephBrowserClient({
       apiHost: props.apiHost,
       crnListUrl: props.crnListUrl,
@@ -2247,10 +2636,24 @@ var SponsorRelayController = class {
   getState() {
     return this.state;
   }
+  updateProps(props) {
+    this.props = { ...this.props, ...props };
+    this.debugEnabled = isDebugEnabled(this.props);
+  }
   emit() {
     const next = this.state;
     this.subscribers.forEach((subscriber) => subscriber(next));
   }
+  trace(message, data) {
+    if (!this.debugEnabled) {
+      return;
+    }
+    if (data === void 0) {
+      console.debug("[le-space/ui]", message);
+      return;
+    }
+    console.debug("[le-space/ui]", message, data);
+  }
   patch(patch) {
     this.state = {
       ...this.state,
@@ -2267,6 +2670,14 @@ var SponsorRelayController = class {
       ...event,
       timestamp: Date.now()
     };
+    this.trace(`progress:${nextEvent.stage}`, {
+      label: nextEvent.label,
+      progress: nextEvent.progress,
+      status: nextEvent.status,
+      itemHash: nextEvent.itemHash ?? null,
+      detail: nextEvent.detail ?? null,
+      error: nextEvent.error ?? null
+    });
     this.patch({
       deploymentProgress: nextEvent,
       statusText: event.error ?? event.detail ?? event.label,
@@ -2274,6 +2685,145 @@ var SponsorRelayController = class {
     });
     this.progressEmitter.emit(nextEvent);
   }
+  async configureRelayBootstrapRegistration(args) {
+    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 (!args.runtime.hostIpv4) {
+      throw new Error("Relay runtime did not expose a host IPv4 address.");
+    }
+    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.");
+    }
+    this.emitProgress({
+      stage: "deployment-confirmed",
+      label: "Configuring relay",
+      progress: 93,
+      status: "info",
+      itemHash: args.itemHash,
+      detail: "Waiting for the guest setup endpoint before collecting relay metadata."
+    });
+    const setupHealth = await waitForSetupEndpoint({
+      hostIpv4: args.runtime.hostIpv4,
+      setupPort,
+      fetch: (url, init) => fetch(url, init),
+      attempts: 15,
+      delayMs: 4e3,
+      httpTimeoutMs: 1e4
+    });
+    if (!setupHealth.ok) {
+      throw new Error(
+        `Relay setup endpoint did not become reachable at http://${args.runtime.hostIpv4}:${setupPort}/health.`
+      );
+    }
+    this.emitProgress({
+      stage: "deployment-confirmed",
+      label: "Applying relay networking",
+      progress: 94,
+      status: "info",
+      itemHash: args.itemHash,
+      detail: "Publishing the host port mapping into the guest relay configuration."
+    });
+    if (profile === "orbitdb-relay-pinner") {
+      const tcpPort = mappedPorts2["9091"]?.host ?? 0;
+      const wsPort = mappedPorts2["9092"]?.host ?? mappedPorts2["443"]?.host ?? 0;
+      if (!tcpPort || !wsPort) {
+        throw new Error("OrbitDB relay runtime is missing required mapped TCP/WS ports.");
+      }
+      await configureOrbitdbRelaySetup2({
+        hostIpv4: args.runtime.hostIpv4,
+        publicIpv6: args.runtime.ipv6,
+        setupPort,
+        tcpPort,
+        wsPort,
+        proxyUrl: args.runtime.proxyUrl ?? void 0,
+        metricsPort: mappedPorts2["9090"]?.host ?? null,
+        metricsHttpsPort: mappedPorts2["443"]?.host ?? null,
+        webrtcPort: mappedPorts2["9093"]?.host ?? null,
+        quicPort: mappedPorts2["9094"]?.host ?? null,
+        fetch: (url, init) => fetch(url, init),
+        timeoutMs: 18e4
+      });
+    } else {
+      await configureUcGoPeer({
+        hostIpv4: args.runtime.hostIpv4,
+        publicIpv6: args.runtime.ipv6,
+        setupPort,
+        tcpPort: mappedPorts2["9095"]?.host ?? null,
+        wsPort: mappedPorts2["9097"]?.host ?? mappedPorts2["9095"]?.host ?? null,
+        udpPort: mappedPorts2["9095"]?.udp === true ? mappedPorts2["9095"]?.host ?? null : null,
+        quicPort: mappedPorts2["9095"]?.udp === true ? mappedPorts2["9095"]?.host ?? null : null,
+        webrtcPort: mappedPorts2["9095"]?.udp === true ? mappedPorts2["9095"]?.host ?? null : null,
+        proxyUrl: args.runtime.proxyUrl ?? void 0,
+        fetch: (url, init) => fetch(url, init),
+        timeoutMs: 18e4
+      });
+    }
+    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 metadataResult = await fetchUcGoPeerMetadata({
+      hostIpv4: args.runtime.hostIpv4,
+      setupPort,
+      fetch: (url, init) => fetch(url, init),
+      attempts: 80,
+      delayMs: 3e3,
+      timeoutMs: 24e4
+    });
+    const metadata = metadataResult && typeof metadataResult === "object" && metadataResult.metadata && typeof metadataResult.metadata === "object" ? metadataResult.metadata : null;
+    const peerId = typeof metadata?.peer_id === "string" ? metadata.peer_id : null;
+    const probeMultiaddrs = Array.isArray(metadata?.probe_multiaddrs) ? metadata.probe_multiaddrs.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    const browserBootstrapMultiaddrs = Array.isArray(
+      metadata?.browser_bootstrap_multiaddrs
+    ) ? metadata.browser_bootstrap_multiaddrs.filter(
+      (entry) => typeof entry === "string"
+    ) : [];
+    if (!peerId || probeMultiaddrs.length === 0) {
+      throw new Error("Relay metadata did not include a peer ID and public multiaddrs.");
+    }
+    this.emitProgress({
+      stage: "publishing-bootstrap",
+      label: "Publishing bootstrap registration",
+      progress: 96,
+      status: "info",
+      itemHash: args.itemHash,
+      detail: "Writing the relay bootstrap registration to Aleph."
+    });
+    const publication = await publishRelayBootstrapRegistration({
+      sender: this.state.wallet.address,
+      signer: personalSign,
+      hasher: sha256Hex,
+      fetch: (url, init) => fetch(url, init).then(async (response) => ({
+        ok: response.ok,
+        status: response.status,
+        json: async () => await response.json()
+      })),
+      apiHost: this.client.apiHost,
+      peerId,
+      multiaddrs: probeMultiaddrs,
+      browserMultiaddrs: browserBootstrapMultiaddrs,
+      profile,
+      version: this.state.manifest?.version,
+      sync: true
+    });
+    this.trace("deploy:bootstrap-registration", {
+      itemHash: args.itemHash,
+      peerId,
+      metadata,
+      publication
+    });
+  }
   syncLatestDeploymentProgress(instances) {
     const itemHash = this.state.lastDeploymentHash;
     if (!itemHash) {
@@ -2285,6 +2835,9 @@ var SponsorRelayController = class {
     if (!latest) {
       return;
     }
+    const currentProgress = this.state.deploymentProgress;
+    const currentProgressIsForLatestHash = currentProgress.itemHash === itemHash || currentProgress.itemHash == null && currentProgress.stage !== "idle" && currentProgress.stage !== "error";
+    const keepTerminalSuccess = this.lastRuntimeReadyHash === itemHash || currentProgressIsForLatestHash && currentProgress.stage === "completed" && currentProgress.status === "success";
     const status = latest.details.messageStatus;
     if (status === "rejected") {
       this.emitProgress({
@@ -2299,6 +2852,14 @@ var SponsorRelayController = class {
       return;
     }
     if (status !== "processed") {
+      if (keepTerminalSuccess) {
+        this.trace("progress:retain-completed", {
+          reason: "latest refresh still reports non-processed status",
+          itemHash,
+          status
+        });
+        return;
+      }
       const submittedAtMs = instanceTimestampMs(latest.instance);
       const pendingTooLong = submittedAtMs != null && Date.now() - submittedAtMs >= DEPLOYMENT_PENDING_WARNING_MS;
       this.emitProgress({
@@ -2312,6 +2873,13 @@ var SponsorRelayController = class {
       return;
     }
     if (!hasUsableRuntime(latest.details)) {
+      if (keepTerminalSuccess) {
+        this.trace("progress:retain-completed", {
+          reason: "latest refresh lacks runtime details after completed state",
+          itemHash
+        });
+        return;
+      }
       this.emitProgress({
         stage: "deployment-confirmed",
         label: "Waiting for runtime",
@@ -2358,8 +2926,42 @@ var SponsorRelayController = class {
       Date.now() + STALE_INSTANCE_ALLOCATION_COOLDOWN_MS
     );
   }
+  rememberRuntimeDetails(itemHash, details) {
+    if (!hasUsableRuntime(details)) {
+      return;
+    }
+    this.runtimeDetailsByHash.set(itemHash, {
+      ...details,
+      mappedPorts: [...details.mappedPorts]
+    });
+  }
+  mergeRememberedRuntimeDetails(itemHash, details) {
+    const remembered = this.runtimeDetailsByHash.get(itemHash);
+    if (!remembered) {
+      return details;
+    }
+    if (details.messageStatus === "processed" && hasUsableRuntime(details)) {
+      return details;
+    }
+    this.trace("runtime:retain-known-details", {
+      itemHash,
+      currentStatus: details.messageStatus,
+      rememberedStatus: remembered.messageStatus,
+      currentHasRuntime: hasUsableRuntime(details)
+    });
+    return {
+      ...details,
+      ...remembered,
+      error: details.error ?? remembered.error
+    };
+  }
   async init() {
+    this.trace("init:start", {
+      launcherMode: this.props.launcherMode ?? "floating",
+      manifestUrl: this.state.manifestUrl
+    });
     this.stopWalletWatch = watchWallet(() => {
+      this.trace("wallet:changed");
       void this.refreshWalletDerivedState();
     });
     await this.refresh();
@@ -2371,6 +2973,7 @@ var SponsorRelayController = class {
     }, RELAY_PING_INTERVAL_MS);
     await this.refreshRelayPing();
     this.patch({ ready: true });
+    this.trace("init:ready");
   }
   destroy() {
     if (this.refreshTimer) clearInterval(this.refreshTimer);
@@ -2471,6 +3074,11 @@ var SponsorRelayController = class {
     }
   }
   async refresh() {
+    this.trace("refresh:start", {
+      wallet: this.state.wallet.address,
+      manifestUrl: this.state.manifestUrl,
+      showInstances: this.state.showInstances
+    });
     this.patch({
       busy: { refreshing: true },
       errorText: null,
@@ -2496,29 +3104,58 @@ var SponsorRelayController = class {
         balance = nextBalance;
         instances = await Promise.all(
           rawInstances.map(async (instance) => {
-            const details = this.canSkipRuntimeRefresh(instance) ? {
-              messageStatus: String(
-                instance.status ?? (instance.confirmed ? "processed" : "pending")
-              ).toLowerCase(),
-              allocationSource: null,
-              crnUrl: null,
-              hostIpv4: null,
-              ipv6: null,
-              vmIpv4: null,
-              webUrl: null,
-              sshCommand: null,
-              mappedPorts: [],
-              execution: null,
-              error: null
+            const inspected = this.canSkipRuntimeRefresh(instance) ? {
+              details: {
+                messageStatus: String(
+                  instance.status ?? (instance.confirmed ? "processed" : "pending")
+                ).toLowerCase(),
+                allocationSource: null,
+                crnUrl: null,
+                hostIpv4: null,
+                ipv6: null,
+                vmIpv4: null,
+                webUrl: null,
+                sshCommand: null,
+                mappedPorts: [],
+                execution: null,
+                error: null
+              },
+              lookup: {
+                allocationFound: false,
+                allocationSource: null,
+                crnUrl: null,
+                webUrl: null,
+                executionPayloadFound: false,
+                executionLookupBlocked: false,
+                executionLookupRequestUrl: null,
+                executionLookupVersion: null
+              }
             } : await inspectInstanceRuntime({
               client: this.client,
               instance,
               crns
             });
-            this.noteRuntimeRefreshResult(instance, details);
+            const details = inspected.details;
+            const mergedDetails = this.mergeRememberedRuntimeDetails(
+              instance.item_hash,
+              details
+            );
+            if (this.debugEnabled && instance.item_hash === this.state.lastDeploymentHash) {
+              this.trace("runtime:inspect-result", {
+                itemHash: instance.item_hash,
+                messageStatus: details.messageStatus,
+                hostIpv4: details.hostIpv4,
+                vmIpv4: details.vmIpv4,
+                mappedPorts: details.mappedPorts,
+                error: details.error,
+                lookup: inspected.lookup
+              });
+            }
+            this.rememberRuntimeDetails(instance.item_hash, mergedDetails);
+            this.noteRuntimeRefreshResult(instance, mergedDetails);
             return {
               instance,
-              details
+              details: mergedDetails
             };
           })
         );
@@ -2555,9 +3192,15 @@ var SponsorRelayController = class {
         busy: { refreshing: false },
         statusText: "Relay sponsor data ready"
       });
+      this.trace("refresh:success", {
+        manifestValid: manifestState.valid,
+        rootfsVerified,
+        instances: instances.length
+      });
       this.recomputePricingSummary();
       this.syncLatestDeploymentProgress(instances);
     } catch (error) {
+      this.trace("refresh:error", error);
       this.patch({
         busy: { refreshing: false },
         errorText: error instanceof Error ? error.message : String(error),
@@ -2568,8 +3211,17 @@ 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,
+      instanceName: this.state.instanceName,
+      tierId: this.state.tierId,
+      selectedCrn: this.state.selectedCrn?.name ?? null,
+      manifestRootfsItemHash: this.state.manifest?.rootfsItemHash ?? null,
+      requiredPortForwards: this.state.manifest?.requiredPortForwards ?? []
+    });
     if (!this.state.wallet.address) {
       this.patch({ errorText: "Connect MetaMask before deploying." });
       return;
@@ -2634,6 +3286,8 @@ var SponsorRelayController = class {
         statusText: `Deployment submitted: ${result.itemHash}`,
         lastDeploymentHash: result.itemHash
       });
+      this.trace("deploy:broadcasted", result);
+      this.lastRuntimeReadyHash = null;
       const inspection = await waitForDeploymentResult2(result.itemHash, {
         rootfsRef: this.state.manifest.rootfsItemHash,
         apiHost: this.client.apiHost,
@@ -2679,6 +3333,7 @@ var SponsorRelayController = class {
           inspection.rejectionReason ?? `Deployment ${result.itemHash} stayed ${inspection.status} on Aleph.`
         );
       }
+      this.trace("deploy:aleph-processed", inspection);
       if ((this.state.manifest.requiredPortForwards?.length ?? 0) > 0) {
         this.emitProgress({
           stage: "refreshing-instances",
@@ -2698,8 +3353,18 @@ var SponsorRelayController = class {
           apiHost: this.client.apiHost,
           sync: true
         });
+        this.trace("deploy:port-forwards-published", {
+          itemHash: result.itemHash,
+          requiredPortForwards: this.state.manifest.requiredPortForwards
+        });
       }
       if (this.state.selectedCrn?.address) {
+        this.trace("deploy:notifying-crn", {
+          itemHash: result.itemHash,
+          crnName: this.state.selectedCrn.name,
+          crnHash: this.state.selectedCrn.hash,
+          crnUrl: this.state.selectedCrn.address
+        });
         await notifyCrnAllocationWithRetry({
           crnUrl: this.state.selectedCrn.address,
           itemHash: result.itemHash,
@@ -2752,6 +3417,25 @@ var SponsorRelayController = class {
           runtime.diagnostics?.reason ?? "Deployment was processed, but runtime networking never exposed mapped ports."
         );
       }
+      this.trace("deploy:runtime-ready", runtime);
+      this.lastRuntimeReadyHash = result.itemHash;
+      this.rememberRuntimeDetails(result.itemHash, {
+        messageStatus: "processed",
+        allocationSource: runtime.allocation?.source ?? null,
+        crnUrl: runtime.allocation?.crnUrl ?? runtime.execution?.crnUrl ?? null,
+        hostIpv4: runtime.hostIpv4 ?? null,
+        ipv6: runtime.ipv6 ?? null,
+        vmIpv4: runtime.execution?.networking?.ipv4_ip ?? null,
+        webUrl: runtime.webAccessUrl ?? runtime.proxyUrl ?? runtime.execution?.networking?.proxy_url ?? null,
+        sshCommand: runtime.sshCommand ?? null,
+        mappedPorts: runtime.execution != null ? mappedPorts(runtime.execution) : runtimeMappedPorts(runtime.mappedPorts),
+        execution: runtime.execution ?? null,
+        error: null
+      });
+      await this.configureRelayBootstrapRegistration({
+        itemHash: result.itemHash,
+        runtime
+      });
       this.patch({
         busy: { deploying: false }
       });
@@ -2765,6 +3449,7 @@ var SponsorRelayController = class {
       });
       await this.refresh();
     } catch (error) {
+      this.trace("deploy:error", error);
       this.patch({
         busy: { deploying: false },
         errorText: error instanceof Error ? error.message : String(error),
@@ -2780,6 +3465,7 @@ var SponsorRelayController = class {
     }
   }
   async deleteInstance(instanceHash) {
+    this.trace("delete:start", { instanceHash });
     if (!this.state.wallet.address) {
       this.patch({ errorText: "Connect MetaMask before deleting instances." });
       return;
@@ -2827,6 +3513,7 @@ var SponsorRelayController = class {
         detail: "Reloading current deployments."
       });
       await this.refresh();
+      this.trace("delete:submitted", { instanceHash });
       this.emitProgress({
         stage: "completed",
         label: "Delete completed",
@@ -2837,6 +3524,7 @@ var SponsorRelayController = class {
         error: null
       });
     } catch (error) {
+      this.trace("delete:error", error);
       this.patch({
         busy: { deletingInstanceHash: null },
         errorText: error instanceof Error ? error.message : String(error),