@le-space/ui 0.3.17 → 0.3.19

package/react/index.js

@@ -39,7 +39,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.17";
+var UI_PACKAGE_VERSION = "0.3.19";
 
 // src/shared/format.ts
 function shortHash(value, head = 8, tail = 6) {
@@ -1219,14 +1219,14 @@ async function inspectDeploymentResult2(itemHash, options) {
 async function waitForDeploymentResult2(itemHash, options) {
   const attempts = Math.max(1, Number(options.attempts ?? 15));
   const delayMs = Math.max(0, Number(options.delayMs ?? 2e3));
-  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   let lastResult = await inspectDeploymentResult2(itemHash, options);
   options.onAttempt?.(lastResult, 1, attempts);
   for (let attempt = 1; attempt < attempts; attempt += 1) {
     if (lastResult.status === "processed" || lastResult.status === "rejected") {
       return lastResult;
     }
-    await sleep(delayMs);
+    await sleep2(delayMs);
     lastResult = await inspectDeploymentResult2(itemHash, options);
     options.onAttempt?.(lastResult, attempt + 1, attempts);
   }
@@ -1884,14 +1884,14 @@ async function fetchVmRuntime(args) {
 async function waitForVmRuntime(args) {
   const attempts = Math.max(1, Number(args.attempts ?? 20));
   const delayMs = Math.max(0, Number(args.delayMs ?? 4e3));
-  const sleep = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   let lastRuntime = await fetchVmRuntime(args);
   args.onAttempt?.(lastRuntime, 1, attempts);
   for (let attempt = 0; attempt < attempts - 1; attempt += 1) {
     if (lastRuntime.hostIpv4 && Object.keys(lastRuntime.mappedPorts ?? {}).length > 0) {
       return lastRuntime;
     }
-    await sleep(delayMs);
+    await sleep2(delayMs);
     lastRuntime = await fetchVmRuntime(args);
     args.onAttempt?.(lastRuntime, attempt + 2, attempts);
   }
@@ -1970,7 +1970,7 @@ function isRetryableAllocationNotifyReason(reason) {
 async function notifyCrnAllocationWithRetry(args) {
   const attempts = Math.max(1, Number(args.attempts ?? 6));
   const delayMs = Math.max(0, Number(args.delayMs ?? 2e3));
-  const sleep = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const sleep2 = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   let lastResult = null;
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     args.onProgress?.({
@@ -1996,7 +1996,7 @@ async function notifyCrnAllocationWithRetry(args) {
       return result;
     }
     if (attempt < attempts - 1) {
-      await sleep(delayMs);
+      await sleep2(delayMs);
     }
   }
   return lastResult ?? {
@@ -2007,7 +2007,7 @@ async function notifyCrnAllocationWithRetry(args) {
 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 sleep2 = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   const url = `http://${args.hostIpv4}:${args.setupPort}/health`;
   let result = await defaultHttpProbe(
     args.fetch,
@@ -2017,7 +2017,7 @@ async function waitForSetupEndpoint(args) {
   args.onAttempt?.(result, 1, attempts);
   for (let attempt = 1; attempt < attempts; attempt += 1) {
     if (result.ok) return result;
-    await sleep(delayMs);
+    await sleep2(delayMs);
     result = await defaultHttpProbe(
       args.fetch,
       url,
@@ -2076,7 +2076,7 @@ async function configureOrbitdbRelaySetup2(args) {
 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)));
+  const sleep2 = args.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   let lastPayload = null;
   let lastError = null;
   for (let attempt = 0; attempt < attempts; attempt += 1) {
@@ -2136,7 +2136,7 @@ async function fetchUcGoPeerMetadata(args) {
       clearTimeout(timeout);
     }
     if (attempt < attempts - 1) {
-      await sleep(delayMs);
+      await sleep2(delayMs);
     }
   }
   throw new Error(
@@ -2152,31 +2152,6 @@ 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;
 var DEFAULT_BOOTSTRAP_PAGINATION = 50;
-var RELAY_BOOTSTRAP_SIGNATURE_SCHEME = "personal_sign";
-function serializeOwnerAuthorizationPayload(payload) {
-  return JSON.stringify({
-    ownerAddress: payload.ownerAddress,
-    publisherAddress: payload.publisherAddress,
-    peerId: payload.peerId,
-    registrationId: payload.registrationId,
-    profile: payload.profile,
-    version: payload.version,
-    instanceItemHash: payload.instanceItemHash,
-    issuedAt: payload.issuedAt,
-    expiresAt: payload.expiresAt
-  });
-}
-function serializeRelayProofPayload(payload) {
-  return JSON.stringify({
-    peerId: payload.peerId,
-    multiaddrs: dedupeMultiaddrs(payload.multiaddrs),
-    browserMultiaddrs: payload.browserMultiaddrs ? dedupeMultiaddrs(payload.browserMultiaddrs) : void 0,
-    registrationId: payload.registrationId,
-    profile: payload.profile,
-    version: payload.version,
-    updatedAt: payload.updatedAt
-  });
-}
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
@@ -2188,48 +2163,9 @@ function asNumber4(value) {
   }
   return null;
 }
-function normalizeHost(host) {
-  return host.trim().toLowerCase();
-}
 function normalizeAddress(address) {
   return address.trim().toLowerCase();
 }
-function normalizeSignature(signature) {
-  const trimmed = signature.trim();
-  return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
-}
-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 = [];
@@ -2241,33 +2177,6 @@ function dedupeMultiaddrs(addrs) {
   }
   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 normalizeRelayBootstrapContent(value) {
   if (!value || typeof value !== "object") return null;
   const content = value;
@@ -2362,104 +2271,6 @@ function normalizeRelayBootstrapPostRecord(value) {
     content: normalizeRelayBootstrapContent(entry.content)
   };
 }
-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,
-      registrationId: args.registrationId,
-      profile: args.profile,
-      version: args.version,
-      ownerAddress: args.ownerAddress,
-      publisherAddress: args.publisherAddress,
-      authorization: args.authorization,
-      relayProof: args.relayProof,
-      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,
-    registrationId: args.registrationId,
-    ref: args.ref ?? DEFAULT_ALEPH_BOOTSTRAP_REF,
-    postType: args.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE,
-    profile: args.profile,
-    version: args.version,
-    ownerAddress: args.ownerAddress,
-    publisherAddress: args.publisherAddress,
-    authorization: args.authorization,
-    relayProof: args.relayProof,
-    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
-  };
-}
-async function signRelayBootstrapAuthorization(args) {
-  const payload = {
-    ownerAddress: args.ownerAddress,
-    publisherAddress: args.publisherAddress,
-    peerId: args.peerId,
-    registrationId: args.registrationId,
-    profile: args.profile,
-    version: args.version,
-    instanceItemHash: args.instanceItemHash,
-    issuedAt: args.issuedAt ?? Date.now(),
-    expiresAt: args.expiresAt
-  };
-  const serialized = serializeOwnerAuthorizationPayload(payload);
-  const signature = await args.signer(args.ownerAddress, serialized);
-  return {
-    scheme: RELAY_BOOTSTRAP_SIGNATURE_SCHEME,
-    payload,
-    signature: normalizeSignature(signature)
-  };
-}
-async function signRelayBootstrapProof(args) {
-  const payload = {
-    peerId: args.peerId,
-    multiaddrs: filterPublicMultiaddrs(args.multiaddrs),
-    browserMultiaddrs: args.browserMultiaddrs ? filterPublicMultiaddrs(args.browserMultiaddrs, {
-      browserDialableOnly: true
-    }) : void 0,
-    registrationId: args.registrationId,
-    profile: args.profile,
-    version: args.version,
-    updatedAt: args.updatedAt ?? Date.now()
-  };
-  const serialized = serializeRelayProofPayload(payload);
-  const signature = await args.signer(args.publisherAddress, serialized);
-  return {
-    scheme: RELAY_BOOTSTRAP_SIGNATURE_SCHEME,
-    payload,
-    signature: normalizeSignature(signature)
-  };
-}
 async function fetchAlephBootstrapPosts(options = {}) {
   const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
   if (typeof fetchImpl !== "function") {
@@ -2531,108 +2342,52 @@ function selectCurrentRelayBootstrapPosts(posts, options = {}) {
 }
 
 // ../core/src/bootstrap-registration.ts
-async function publishRelayBootstrapRegistration(args) {
-  const publisherAddress = args.publisherAddress ?? args.sender;
-  const ownerAddress = args.ownerAddress;
-  let ownerAuthorization = args.ownerAuthorization;
-  let relayProof = args.relayProof;
-  if (!ownerAuthorization && ownerAddress && args.ownerSigner) {
-    ownerAuthorization = await signRelayBootstrapAuthorization({
-      ownerAddress,
-      publisherAddress,
-      peerId: args.peerId,
-      registrationId: args.registrationId,
-      profile: args.profile,
-      version: args.version,
-      instanceItemHash: args.instanceItemHash,
-      issuedAt: args.authorizationIssuedAt ?? args.now ?? Date.now(),
-      expiresAt: args.authorizationExpiresAt,
-      signer: args.ownerSigner
-    });
-  }
-  if (!relayProof && args.publisherSigner) {
-    relayProof = await signRelayBootstrapProof({
-      publisherAddress,
-      peerId: args.peerId,
-      multiaddrs: args.multiaddrs,
-      browserMultiaddrs: args.browserMultiaddrs,
-      registrationId: args.registrationId,
-      profile: args.profile,
-      version: args.version,
-      updatedAt: args.now ?? Date.now(),
-      signer: args.publisherSigner
-    });
-  }
-  const unsigned = await createRelayBootstrapPost({
-    sender: args.sender,
-    peerId: args.peerId,
-    multiaddrs: args.multiaddrs,
-    browserMultiaddrs: args.browserMultiaddrs,
-    registrationId: args.registrationId,
-    channel: args.channel,
-    ref: args.ref,
-    postType: args.postType,
-    profile: args.profile,
-    version: args.version,
-    ownerAddress,
-    publisherAddress,
-    authorization: ownerAuthorization,
-    relayProof,
-    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
-  });
-  let forgottenHashes = [];
-  let forgetResult;
-  if (args.forgetPrevious && args.registrationId) {
-    const previousPosts = await fetchAlephBootstrapPosts({
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForRelayBootstrapRegistration(args) {
+  const attempts = Math.max(1, Number(args.attempts ?? 10));
+  const delayMs = Math.max(0, Number(args.delayMs ?? 2e3));
+  const expectedSender = args.sender?.trim().toLowerCase() || null;
+  const expectedRegistrationId = args.registrationId?.trim() || null;
+  const expectedPeerId = args.peerId?.trim() || null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const posts = await fetchAlephBootstrapPosts({
       apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST3,
       channel: args.channel,
       ref: args.ref,
       postType: args.postType,
       fetch: args.fetch
     });
-    forgottenHashes = previousPosts.filter(
-      (post) => post.address?.toLowerCase() === args.sender.toLowerCase() && post.content?.registrationId === args.registrationId && (post.itemHash ?? post.hash) != null && (post.itemHash ?? post.hash) !== unsigned.item_hash
-    ).map((post) => post.itemHash ?? post.hash ?? "").filter(Boolean);
-    if (forgottenHashes.length > 0) {
-      forgetResult = await forgetAlephMessages({
-        sender: args.sender,
-        hashes: forgottenHashes,
-        reason: args.forgetPreviousReason ?? `Replace older relay bootstrap records for ${args.registrationId}`,
-        signer: args.signer,
-        hasher: args.hasher,
-        fetch: args.fetch,
-        apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST3,
-        sync: args.sync ?? true
-      });
+    const currentPosts = selectCurrentRelayBootstrapPosts(posts);
+    const match = currentPosts.find((post) => {
+      if (expectedSender && post.address?.toLowerCase() !== expectedSender) {
+        return false;
+      }
+      if (expectedRegistrationId && post.content?.registrationId === expectedRegistrationId) {
+        return true;
+      }
+      if (expectedPeerId && post.content?.peerId === expectedPeerId) {
+        return true;
+      }
+      return false;
+    });
+    if (match?.content) {
+      return {
+        itemHash: match.itemHash ?? null,
+        hash: match.hash ?? null,
+        sender: typeof match.address === "string" ? match.address : null,
+        registrationId: match.content.registrationId,
+        peerId: match.content.peerId,
+        multiaddrs: Array.isArray(match.content.multiaddrs) ? match.content.multiaddrs : [],
+        browserMultiaddrs: Array.isArray(match.content.browserMultiaddrs) ? match.content.browserMultiaddrs : []
+      };
+    }
+    if (attempt < attempts - 1) {
+      await sleep(delayMs);
     }
   }
-  return {
-    status: "published",
-    itemHash: unsigned.item_hash,
-    message,
-    response,
-    httpStatus,
-    publishedMultiaddrs: content.content?.multiaddrs ?? [],
-    publishedBrowserMultiaddrs: content.content?.browserMultiaddrs ?? [],
-    forgottenHashes,
-    forgetResult
-  };
+  return null;
 }
 
 // ../core/src/bootstrap-config.ts
@@ -2787,24 +2542,6 @@ function extractRelayMetadata(payload) {
     browserBootstrapMultiaddrs
   };
 }
-async function fetchOwnerInstances(address, options) {
-  const url = new URL("/api/v0/messages.json", options.apiHost ?? DEFAULT_ALEPH_API_HOST2);
-  url.searchParams.set("msgTypes", "INSTANCE");
-  url.searchParams.set("addresses", address);
-  url.searchParams.set("message_statuses", "processed,pending,rejected,removing");
-  url.searchParams.set("pagination", "100");
-  url.searchParams.set("page", "1");
-  url.searchParams.set("sortOrder", "-1");
-  const response = await options.fetch(url.toString(), { cache: "no-cache" });
-  if (!response.ok) {
-    throw new Error(`Instance list request failed: ${response.status}`);
-  }
-  const payload = await response.json();
-  return (payload.messages ?? []).map((message) => ({
-    ...message,
-    status: typeof message.status === "string" && message.status.trim() ? message.status : message.confirmed ? "processed" : "pending"
-  }));
-}
 async function fetchRelayMetadataForRuntime(args) {
   const setupPort = args.runtime.mappedPorts?.["80"]?.host ?? 80;
   const metadataUrl = args.preferSecureMetadata ? secureBootstrapMetadataUrl(args.runtime.proxyUrl) : null;
@@ -2831,123 +2568,6 @@ async function fetchRelayMetadataForRuntime(args) {
   }).catch(() => null);
   return extractRelayMetadata(payload);
 }
-async function reconcileOwnerRelayBootstrapRegistrations(args) {
-  const result = {
-    refreshedRegistrations: [],
-    forgottenHashes: [],
-    skippedInstanceHashes: [],
-    errors: []
-  };
-  const liveRegistrationIds = /* @__PURE__ */ new Set();
-  if (args.current?.registrationId) {
-    liveRegistrationIds.add(args.current.registrationId);
-    result.refreshedRegistrations.push(args.current.registrationId);
-  }
-  const instances = await fetchOwnerInstances(args.instanceOwnerAddress, {
-    apiHost: args.apiHost,
-    fetch: args.fetch
-  });
-  const processedInstances = instances.filter((instance) => {
-    const status = String(instance.status ?? "").trim().toLowerCase();
-    return status === "processed";
-  });
-  for (const instance of processedInstances) {
-    if (instance.item_hash === args.current?.itemHash) continue;
-    const registrationId = createRelayBootstrapRegistrationId(
-      args.profile,
-      instance.content?.metadata?.name,
-      instance.item_hash
-    );
-    try {
-      const runtime = await fetchVmRuntime({
-        itemHash: instance.item_hash,
-        fetch: args.fetch,
-        crns: args.crns,
-        crnListUrl: args.crnListUrl
-      });
-      if (!runtime.hostIpv4 || Object.keys(runtime.mappedPorts ?? {}).length === 0) {
-        result.skippedInstanceHashes.push(instance.item_hash);
-        continue;
-      }
-      const relayMetadata = await fetchRelayMetadataForRuntime({
-        runtime,
-        fetch: args.fetch,
-        preferSecureMetadata: args.preferSecureMetadata,
-        attempts: 3,
-        delayMs: 1e3,
-        timeoutMs: 1e4
-      });
-      if (!relayMetadata) {
-        result.skippedInstanceHashes.push(instance.item_hash);
-        continue;
-      }
-      liveRegistrationIds.add(registrationId);
-      await publishRelayBootstrapRegistration({
-        sender: args.sender,
-        signer: args.signer,
-        hasher: args.hasher,
-        fetch: args.fetch,
-        apiHost: args.apiHost,
-        channel: args.channel,
-        ref: args.ref,
-        postType: args.postType,
-        peerId: relayMetadata.peerId,
-        multiaddrs: relayMetadata.probeMultiaddrs,
-        browserMultiaddrs: relayMetadata.browserBootstrapMultiaddrs,
-        registrationId,
-        ownerAddress: args.ownerAddress,
-        publisherAddress: args.publisherAddress,
-        ownerSigner: args.ownerSigner,
-        publisherSigner: args.publisherSigner,
-        forgetPrevious: true,
-        profile: args.profile,
-        version: args.version,
-        instanceItemHash: instance.item_hash,
-        sync: true
-      });
-      result.refreshedRegistrations.push(registrationId);
-    } catch (error) {
-      result.errors.push({
-        phase: "publish",
-        itemHash: instance.item_hash,
-        registrationId,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  try {
-    const bootstrapPosts = await fetchAlephBootstrapPosts({
-      apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST2,
-      channel: args.channel,
-      ref: args.ref,
-      postType: args.postType,
-      fetch: args.fetch
-    });
-    const currentPosts = selectCurrentRelayBootstrapPosts(bootstrapPosts);
-    const staleHashes = currentPosts.filter(
-      (post) => post.address?.toLowerCase() === args.sender.toLowerCase() && post.content?.profile === args.profile && post.content?.registrationId && !liveRegistrationIds.has(post.content.registrationId)
-    ).map((post) => post.itemHash ?? post.hash ?? "").filter(Boolean);
-    if (staleHashes.length > 0) {
-      await forgetAlephMessages({
-        sender: args.sender,
-        hashes: staleHashes,
-        reason: `Forget stale ${args.profile} relay bootstrap registrations after owner reconcile`,
-        signer: args.signer,
-        hasher: args.hasher,
-        fetch: args.fetch,
-        apiHost: args.apiHost ?? DEFAULT_ALEPH_API_HOST2,
-        sync: true
-      });
-      result.forgottenHashes.push(...staleHashes);
-    }
-  } catch (error) {
-    result.errors.push({
-      phase: "forget",
-      message: error instanceof Error ? error.message : String(error)
-    });
-  }
-  return result;
-}
 
 // src/shared/events.ts
 function createDeploymentProgressEmitter() {
@@ -3567,7 +3187,7 @@ var SponsorRelayController = class {
     if (!relayMetadata) {
       throw new Error("Relay metadata did not include a peer ID and public multiaddrs.");
     }
-    const { peerId, probeMultiaddrs, browserBootstrapMultiaddrs } = relayMetadata;
+    const { peerId } = relayMetadata;
     const registrationId = createRelayBootstrapRegistrationId(
       profile,
       this.state.instanceName.trim(),
@@ -3575,57 +3195,30 @@ var SponsorRelayController = class {
     );
     this.emitProgress({
       stage: "publishing-bootstrap",
-      label: "Publishing bootstrap registration",
+      label: "Waiting for guest bootstrap registration",
       progress: 96,
       status: "info",
       itemHash: args.itemHash,
-      detail: "Writing the relay bootstrap registration to Aleph."
+      detail: "Waiting for the relay VM to publish its own bootstrap registration to Aleph."
     });
-    const publication = await publishRelayBootstrapRegistration({
-      sender: this.state.wallet.address,
-      signer: personalSign,
-      hasher: sha256Hex,
+    const visibleRegistration = await waitForRelayBootstrapRegistration({
+      registrationId,
+      peerId,
       fetch: asJsonFetch,
       apiHost: this.client.apiHost,
-      peerId,
-      multiaddrs: probeMultiaddrs,
-      browserMultiaddrs: browserBootstrapMultiaddrs,
-      registrationId,
-      profile,
-      version: this.state.manifest?.version,
-      forgetPrevious: true,
-      sync: true
+      attempts: 24,
+      delayMs: 2500
     });
-    this.trace("deploy:bootstrap-registration", {
+    this.trace("deploy:bootstrap-registration-visible", {
       itemHash: args.itemHash,
+      registrationId,
       peerId,
-      metadata: relayMetadata,
-      publication
+      visibleRegistration
     });
-    const reconcileResult = await reconcileOwnerRelayBootstrapRegistrations({
-      instanceOwnerAddress: this.state.wallet.address,
-      sender: this.state.wallet.address,
-      signer: personalSign,
-      hasher: sha256Hex,
-      fetch: asJsonFetch,
-      profile,
-      apiHost: this.client.apiHost,
-      crns: this.state.crns,
-      crnListUrl: this.props.crnListUrl,
-      preferSecureMetadata: profile === "uc-go-peer",
-      current: {
-        itemHash: args.itemHash,
-        registrationId,
-        peerId,
-        probeMultiaddrs,
-        browserBootstrapMultiaddrs
-      }
-    });
-    if (reconcileResult.errors.length > 0) {
-      this.trace("deploy:owner-bootstrap-reconcile-errors", {
-        itemHash: args.itemHash,
-        errors: reconcileResult.errors
-      });
+    if (!visibleRegistration) {
+      throw new Error(
+        "Relay bootstrap registration did not become visible on Aleph."
+      );
     }
     if (profile === "uc-go-peer" && args.deploymentToken) {
       await deleteVmBootstrapConfig({
@@ -4116,12 +3709,14 @@ var SponsorRelayController = class {
       for (const [candidateIndex, candidateCrn] of orderedCrns.entries()) {
         let attemptItemHash = null;
         let attemptDeploymentToken = null;
+        const crnAttemptLabel = `CRN ${candidateIndex + 1}/${orderedCrns.length}`;
+        const crnDisplayName = candidateCrn.name ?? candidateCrn.hash;
         this.emitProgress({
           stage: "selecting-crn",
-          label: "Selecting CRN",
+          label: `Selecting ${crnAttemptLabel}`,
           progress: 18,
           status: "info",
-          detail: `Trying ${candidateCrn.name ?? candidateCrn.hash} (${candidateIndex + 1}/${orderedCrns.length})`
+          detail: `Trying ${crnDisplayName}`
         });
         try {
           const profile = relayProfileForManifest(this.state.manifest);
@@ -4331,7 +3926,7 @@ var SponsorRelayController = class {
           return;
         } catch (error) {
           lastError = error instanceof Error ? error : new Error(String(error));
-          const attemptLabel = candidateCrn.name ?? candidateCrn.hash;
+          const attemptLabel = crnDisplayName;
           attemptErrors.push(`${attemptLabel}: ${lastError.message}`);
           this.trace("deploy:crn-attempt-error", {
             crnHash: candidateCrn.hash,
@@ -4400,7 +3995,7 @@ var SponsorRelayController = class {
           if (candidateIndex < orderedCrns.length - 1) {
             this.emitProgress({
               stage: "selecting-crn",
-              label: "Retrying another CRN",
+              label: `Retrying after ${crnAttemptLabel}`,
               progress: 20,
               status: "warning",
               itemHash: attemptItemHash,
@@ -4462,29 +4057,6 @@ var SponsorRelayController = class {
           this.emitProgress(event);
         }
       });
-      const profile = relayProfileForManifest(this.state.manifest);
-      if (profile) {
-        await reconcileOwnerRelayBootstrapRegistrations({
-          instanceOwnerAddress: this.state.wallet.address,
-          sender: this.state.wallet.address,
-          signer: personalSign,
-          hasher: sha256Hex,
-          fetch: asJsonFetch,
-          profile,
-          apiHost: this.client.apiHost,
-          crns: this.state.crns,
-          crnListUrl: this.props.crnListUrl,
-          preferSecureMetadata: profile === "uc-go-peer"
-        }).catch(
-          (error) => {
-            this.trace("delete:owner-bootstrap-reconcile-error", {
-              instanceHash,
-              profile,
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-        );
-      }
       this.patch({
         busy: { deletingInstanceHash: null },
         statusText: `Deletion submitted for ${instanceHash}`