@le-space/ui 0.2.0 → 0.3.2

package/shared/index.js

@@ -29,6 +29,7 @@ var IDLE_DEPLOYMENT_PROGRESS = {
 };
 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;
 var INSTANCE_RUNTIME_STALE_REFRESH_MS = 5 * 6e4;
@@ -56,6 +57,12 @@ function formatDateTime(value) {
   if (Number.isNaN(date.getTime())) return String(value);
   return date.toLocaleString();
 }
+function formatTierSpecLabel(vcpus, memoryMiB, diskMiB) {
+  if (vcpus == null || !Number.isFinite(vcpus) || memoryMiB == null || !Number.isFinite(memoryMiB) || diskMiB == null || !Number.isFinite(diskMiB)) {
+    return "-";
+  }
+  return `(${formatNumber(vcpus, 0)} vCPU \xB7 ${formatNumber(memoryMiB / 1024, 1)} GiB RAM \xB7 ${formatNumber(diskMiB / 1024, 0)} GiB disk)`;
+}
 function buildSshCommand(hostIpv4, mappedPorts2) {
   if (!hostIpv4) return null;
   const sshPort = mappedPorts2.find((entry) => entry.label.startsWith("22/"))?.hostPort ?? 22;
@@ -401,6 +408,18 @@ function extractReferenceHashes(details) {
   if (!Array.isArray(errors)) return [];
   return errors.filter((value) => typeof value === "string");
 }
+function extractInsufficientBalanceMessage(details) {
+  if (!details || typeof details !== "object" || !("errors" in details)) return null;
+  const errors = details.errors;
+  const firstError = Array.isArray(errors) && errors[0] && typeof errors[0] === "object" ? errors[0] : null;
+  const accountBalance = typeof firstError?.account_balance === "number" || typeof firstError?.account_balance === "string" ? Number(firstError.account_balance) : Number.NaN;
+  const requiredBalance = typeof firstError?.required_balance === "number" || typeof firstError?.required_balance === "string" ? Number(firstError.required_balance) : Number.NaN;
+  if (!Number.isFinite(accountBalance) || !Number.isFinite(requiredBalance)) {
+    return null;
+  }
+  const shortfall = requiredBalance - accountBalance;
+  return shortfall > 0 ? `insufficient Aleph balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required, ${shortfall.toFixed(3)} short` : `insufficient Aleph balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required`;
+}
 function describeRejectedDeployment(payload, references, rootfsRef) {
   const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
   const pendingReferences = references.filter((reference) => reference.status === "pending");
@@ -415,6 +434,10 @@ function describeRejectedDeployment(payload, references, rootfsRef) {
   if (missingReferences.length > 0) {
     return `Aleph rejected this deployment because referenced message(s) were not found on Aleph: ${missingReferences.map((reference) => reference.itemHash).join(", ")}.`;
   }
+  const insufficientBalanceMessage = extractInsufficientBalanceMessage(payload.details);
+  if (insufficientBalanceMessage) {
+    return `Aleph rejected this deployment due to ${insufficientBalanceMessage}.`;
+  }
   const referencedHashes = extractReferenceHashes(payload.details);
   if (referencedHashes.length > 0) {
     return `Aleph rejected this deployment${errorCode ? ` (error ${errorCode})` : ""}. Referenced message(s): ${referencedHashes.join(", ")}.`;
@@ -1027,6 +1050,20 @@ function extractReferenceHashes2(details) {
   if (!Array.isArray(errors)) return [];
   return errors.filter((value) => typeof value === "string");
 }
+function extractInsufficientBalanceMessage2(details) {
+  if (!details || typeof details !== "object" || !("errors" in details)) {
+    return null;
+  }
+  const errors = details.errors;
+  const firstError = Array.isArray(errors) && errors[0] && typeof errors[0] === "object" ? errors[0] : null;
+  const accountBalance = typeof firstError?.account_balance === "number" || typeof firstError?.account_balance === "string" ? Number(firstError.account_balance) : Number.NaN;
+  const requiredBalance = typeof firstError?.required_balance === "number" || typeof firstError?.required_balance === "string" ? Number(firstError.required_balance) : Number.NaN;
+  if (!Number.isFinite(accountBalance) || !Number.isFinite(requiredBalance)) {
+    return null;
+  }
+  const shortfall = requiredBalance - accountBalance;
+  return shortfall > 0 ? `insufficient Aleph balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required, ${shortfall.toFixed(3)} short` : `insufficient Aleph balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required`;
+}
 function describeRejectedDeployment2(payload, references, rootfsRef) {
   const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
   const pendingReferences = references.filter((reference) => reference.status === "pending");
@@ -1041,6 +1078,10 @@ function describeRejectedDeployment2(payload, references, rootfsRef) {
   if (missingReferences.length > 0) {
     return `Aleph rejected this deployment because referenced message(s) were not found on Aleph: ${missingReferences.map((reference) => reference.itemHash).join(", ")}.`;
   }
+  const insufficientBalanceMessage = extractInsufficientBalanceMessage2(payload.details);
+  if (insufficientBalanceMessage) {
+    return `Aleph rejected this deployment due to ${insufficientBalanceMessage}.`;
+  }
   const referencedHashes = extractReferenceHashes2(payload.details);
   if (referencedHashes.length > 0) {
     return `Aleph rejected this deployment${errorCode ? ` (error ${errorCode})` : ""}. Referenced message(s): ${referencedHashes.join(", ")}.`;
@@ -1453,6 +1494,14 @@ function buildPaymentQuote(tier, pricing, balance) {
     label: "credits"
   };
 }
+function describeRejectedInstanceBroadcast(response) {
+  const balanceMessage = extractInsufficientBalanceMessage2(response.details);
+  if (balanceMessage) {
+    return `Aleph rejected this deployment due to ${balanceMessage}.`;
+  }
+  const errorCode = typeof response.error_code === "number" ? response.error_code : null;
+  return `Aleph rejected this deployment${errorCode ? ` (error ${errorCode})` : ""}.`;
+}
 function createInstanceContent(args) {
   const sshKey = normalizeSshPublicKey(args.sshPublicKey);
   if (!sshKey) {
@@ -1569,9 +1618,9 @@ async function deployInstance(args) {
     label: status === "processed" ? "Deployment accepted by Aleph" : status === "rejected" ? "Deployment rejected by Aleph" : "Deployment submitted to Aleph",
     progress: status === "processed" ? 88 : status === "rejected" ? 100 : 78,
     status: status === "processed" ? "success" : status === "rejected" ? "error" : "warning",
-    detail: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null,
+    detail: status === "rejected" ? describeRejectedInstanceBroadcast(response) : null,
     itemHash: message.item_hash,
-    error: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null,
+    error: status === "rejected" ? describeRejectedInstanceBroadcast(response) : null,
     timestamp: Date.now()
   });
   return {
@@ -1580,7 +1629,7 @@ async function deployInstance(args) {
     status,
     message,
     response,
-    rejectionReason: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null
+    rejectionReason: status === "rejected" ? describeRejectedInstanceBroadcast(response) : null
   };
 }
 
@@ -1831,6 +1880,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 +1982,621 @@ 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,
+    bootstrap_publisher_private_key: args.bootstrapPublisherPrivateKey ?? void 0,
+    bootstrap_publisher_libp2p_identity_b64: args.bootstrapPublisherLibp2pIdentityBase64 ?? void 0,
+    bootstrap_owner_private_key: args.bootstrapOwnerPrivateKey ?? void 0,
+    bootstrap_owner_authorization_b64: args.bootstrapOwnerAuthorizationBase64 ?? void 0,
+    bootstrap_registration_id: args.bootstrapRegistrationId ?? void 0,
+    no_start: args.noStart === true ? true : 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,
+    bootstrap_publisher_private_key: args.bootstrapPublisherPrivateKey ?? void 0,
+    bootstrap_publisher_libp2p_identity_hex: args.bootstrapPublisherLibp2pIdentityHex ?? void 0,
+    bootstrap_owner_private_key: args.bootstrapOwnerPrivateKey ?? void 0,
+    bootstrap_owner_authorization_b64: args.bootstrapOwnerAuthorizationBase64 ?? void 0,
+    bootstrap_registration_id: args.bootstrapRegistrationId ?? void 0,
+    no_start: args.noStart === true ? true : 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
+import { recoverMessageAddress } from "viem";
+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;
+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;
+}
+function asNumber4(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function normalizeHost(host) {
+  return host.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 = [];
+  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 normalizeRelayBootstrapContent(value) {
+  if (!value || typeof value !== "object") return null;
+  const content = value;
+  const peerId = asTrimmedString(content.peerId);
+  const updatedAt = asNumber4(content.updatedAt);
+  if (!peerId || updatedAt == null) return null;
+  const multiaddrs = Array.isArray(content.multiaddrs) ? content.multiaddrs.filter((entry) => typeof entry === "string") : [];
+  const browserMultiaddrs = Array.isArray(content.browserMultiaddrs) ? content.browserMultiaddrs.filter((entry) => typeof entry === "string") : void 0;
+  return {
+    peerId,
+    multiaddrs: dedupeMultiaddrs(multiaddrs),
+    browserMultiaddrs: browserMultiaddrs ? dedupeMultiaddrs(browserMultiaddrs) : void 0,
+    registrationId: asTrimmedString(content.registrationId) ?? void 0,
+    profile: asTrimmedString(content.profile) ?? void 0,
+    version: asTrimmedString(content.version) ?? void 0,
+    ownerAddress: asTrimmedString(content.ownerAddress) ?? void 0,
+    publisherAddress: asTrimmedString(content.publisherAddress) ?? void 0,
+    authorization: normalizeRelayBootstrapAuthorizationRecord(content.authorization) ?? void 0,
+    relayProof: normalizeRelayBootstrapProofRecord(content.relayProof) ?? void 0,
+    updatedAt
+  };
+}
+function normalizeRelayBootstrapAuthorizationPayload(value) {
+  if (!value || typeof value !== "object") return null;
+  const payload = value;
+  const ownerAddress = asTrimmedString(payload.ownerAddress);
+  const publisherAddress = asTrimmedString(payload.publisherAddress);
+  const peerId = asTrimmedString(payload.peerId);
+  const issuedAt = asNumber4(payload.issuedAt);
+  const expiresAt = asNumber4(payload.expiresAt) ?? void 0;
+  if (!ownerAddress || !publisherAddress || !peerId || issuedAt == null) {
+    return null;
+  }
+  return {
+    ownerAddress,
+    publisherAddress,
+    peerId,
+    registrationId: asTrimmedString(payload.registrationId) ?? void 0,
+    profile: asTrimmedString(payload.profile) ?? void 0,
+    version: asTrimmedString(payload.version) ?? void 0,
+    instanceItemHash: asTrimmedString(payload.instanceItemHash) ?? void 0,
+    issuedAt,
+    expiresAt
+  };
+}
+function normalizeRelayBootstrapAuthorizationRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const scheme = asTrimmedString(record.scheme);
+  const signature = asTrimmedString(record.signature);
+  const payload = normalizeRelayBootstrapAuthorizationPayload(record.payload);
+  if (!scheme || !signature || !payload) return null;
+  return { scheme, signature, payload };
+}
+function normalizeRelayBootstrapProofPayload(value) {
+  if (!value || typeof value !== "object") return null;
+  const payload = value;
+  const peerId = asTrimmedString(payload.peerId);
+  const updatedAt = asNumber4(payload.updatedAt);
+  if (!peerId || updatedAt == null) return null;
+  const multiaddrs = Array.isArray(payload.multiaddrs) ? payload.multiaddrs.filter((entry) => typeof entry === "string") : [];
+  const browserMultiaddrs = Array.isArray(payload.browserMultiaddrs) ? payload.browserMultiaddrs.filter((entry) => typeof entry === "string") : void 0;
+  return {
+    peerId,
+    multiaddrs: dedupeMultiaddrs(multiaddrs),
+    browserMultiaddrs: browserMultiaddrs ? dedupeMultiaddrs(browserMultiaddrs) : void 0,
+    registrationId: asTrimmedString(payload.registrationId) ?? void 0,
+    profile: asTrimmedString(payload.profile) ?? void 0,
+    version: asTrimmedString(payload.version) ?? void 0,
+    updatedAt
+  };
+}
+function normalizeRelayBootstrapProofRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const scheme = asTrimmedString(record.scheme);
+  const signature = asTrimmedString(record.signature);
+  const payload = normalizeRelayBootstrapProofPayload(record.payload);
+  if (!scheme || !signature || !payload) return null;
+  return { scheme, signature, payload };
+}
+function normalizeRelayBootstrapPostRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const entry = value;
+  return {
+    hash: asTrimmedString(entry.hash),
+    itemHash: asTrimmedString(entry.item_hash),
+    address: asTrimmedString(entry.address),
+    ref: asTrimmedString(entry.ref),
+    type: asTrimmedString(entry.type),
+    time: asNumber4(entry.time),
+    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") {
+    throw new Error(
+      "A fetch implementation is required to query Aleph bootstrap posts."
+    );
+  }
+  const url = new URL(
+    "/api/v0/posts.json",
+    options.apiHost ?? DEFAULT_ALEPH_API_HOST3
+  );
+  url.searchParams.set(
+    "channels",
+    options.channel ?? DEFAULT_ALEPH_BOOTSTRAP_CHANNEL
+  );
+  url.searchParams.set("refs", options.ref ?? DEFAULT_ALEPH_BOOTSTRAP_REF);
+  url.searchParams.set(
+    "types",
+    options.postType ?? DEFAULT_ALEPH_BOOTSTRAP_POST_TYPE
+  );
+  url.searchParams.set(
+    "pagination",
+    String(options.pagination ?? DEFAULT_BOOTSTRAP_PAGINATION)
+  );
+  url.searchParams.set("page", String(options.page ?? 1));
+  const response = await fetchImpl(url.toString(), {
+    method: "GET",
+    headers: { accept: "application/json" }
+  });
+  if (!response.ok) {
+    throw new Error(`Aleph bootstrap post lookup failed: ${response.status}`);
+  }
+  const payload = await response.json();
+  return (payload.posts ?? []).map((entry) => normalizeRelayBootstrapPostRecord(entry)).filter((entry) => entry != null);
+}
+
+// ../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({
+      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
+      });
+    }
+  }
+  return {
+    status: "published",
+    itemHash: unsigned.item_hash,
+    message,
+    response,
+    httpStatus,
+    publishedMultiaddrs: content.content?.multiaddrs ?? [],
+    publishedBrowserMultiaddrs: content.content?.browserMultiaddrs ?? [],
+    forgottenHashes,
+    forgetResult
+  };
+}
 
 // src/shared/events.ts
 function createDeploymentProgressEmitter() {
@@ -1947,8 +2633,11 @@ function defaultState(props = {}) {
     sshPublicKey: props.sshPublicKey ?? "",
     instanceName: props.instanceName ?? DEFAULT_INSTANCE_NAME,
     tierId: DEFAULT_TIER_ID,
+    showAdvanced: Boolean(
+      props.manifestUrl && props.manifestUrl !== DEFAULT_MANIFEST_URL || props.manifestJson?.trim() || props.sshPublicKey?.trim()
+    ),
     showInstances: props.showInstances ?? true,
-    showPasteManifest: false,
+    showPasteManifest: Boolean(props.manifestJson?.trim()),
     busy: {
       connectingWallet: false,
       refreshing: false,
@@ -2069,6 +2758,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(
@@ -2259,6 +2955,7 @@ var SponsorRelayController = class {
   client;
   refreshTimer = null;
   pingTimer = null;
+  manifestRefreshTimer = null;
   stopWalletWatch = null;
   props;
   progressEmitter = createDeploymentProgressEmitter();
@@ -2338,6 +3035,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) {
@@ -2492,6 +3328,7 @@ var SponsorRelayController = class {
   destroy() {
     if (this.refreshTimer) clearInterval(this.refreshTimer);
     if (this.pingTimer) clearInterval(this.pingTimer);
+    if (this.manifestRefreshTimer) clearTimeout(this.manifestRefreshTimer);
     this.stopWalletWatch?.();
   }
   setOpen(open) {
@@ -2502,15 +3339,27 @@ var SponsorRelayController = class {
   }
   setManifestUrl(manifestUrl) {
     this.patch({ manifestUrl });
+    this.queueManifestRefresh();
   }
   setManifestJson(manifestJson) {
-    this.patch({ manifestJson });
+    this.patch({
+      manifestJson,
+      showAdvanced: this.state.showAdvanced || Boolean(manifestJson.trim()),
+      showPasteManifest: this.state.showPasteManifest || Boolean(manifestJson.trim())
+    });
+    this.queueManifestRefresh();
+  }
+  setShowAdvanced(showAdvanced) {
+    this.patch({ showAdvanced });
   }
   setShowPasteManifest(showPasteManifest) {
     this.patch({ showPasteManifest });
   }
   setSshPublicKey(sshPublicKey) {
-    this.patch({ sshPublicKey });
+    this.patch({
+      sshPublicKey,
+      showAdvanced: this.state.showAdvanced || Boolean(sshPublicKey.trim())
+    });
   }
   setInstanceName(instanceName) {
     this.patch({ instanceName });
@@ -2546,6 +3395,18 @@ var SponsorRelayController = class {
       selectedCrn
     });
   }
+  queueManifestRefresh() {
+    if (!this.state.ready) {
+      return;
+    }
+    if (this.manifestRefreshTimer) {
+      clearTimeout(this.manifestRefreshTimer);
+    }
+    this.manifestRefreshTimer = setTimeout(() => {
+      this.manifestRefreshTimer = null;
+      void this.refresh();
+    }, MANIFEST_SOURCE_REFRESH_DEBOUNCE_MS);
+  }
   async connectWallet() {
     this.patch({
       busy: { connectingWallet: true },
@@ -2946,6 +3807,10 @@ var SponsorRelayController = class {
         execution: runtime.execution ?? null,
         error: null
       });
+      await this.configureRelayBootstrapRegistration({
+        itemHash: result.itemHash,
+        runtime
+      });
       this.patch({
         busy: { deploying: false }
       });
@@ -3055,6 +3920,7 @@ export {
   INSTANCE_RUNTIME_PENDING_REFRESH_MS,
   INSTANCE_RUNTIME_READY_REFRESH_MS,
   INSTANCE_RUNTIME_STALE_REFRESH_MS,
+  MANIFEST_SOURCE_REFRESH_DEBOUNCE_MS,
   RECENT_INSTANCE_RUNTIME_GRACE_MS,
   REFRESH_INTERVAL_MS,
   RELAY_PING_IDLE_STATE,
@@ -3068,6 +3934,7 @@ export {
   createSponsorRelayController,
   formatDateTime,
   formatNumber,
+  formatTierSpecLabel,
   getEthereumProvider,
   joinMappedPorts,
   joinRequiredPortForwards,