@le-space/ui 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/ui",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Floating Aleph sponsor relay UI components for Svelte and React.",
   "license": "MIT",
   "type": "module",
@@ -36,8 +36,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@le-space/browser": "0.3.6",
-    "@le-space/core": "0.3.6",
+    "@le-space/browser": "0.3.8",
+    "@le-space/core": "0.3.8",
     "viem": "^2.38.5"
   },
   "peerDependencies": {

package/react/index.js

@@ -1,6 +1,37 @@
 // src/react/SponsorRelayFab.tsx
 import React from "react";
 
+// package.json
+var package_default = {
+  name: "@le-space/ui",
+  version: "0.3.8",
+  description: "Floating Aleph sponsor relay UI components for Svelte and React.",
+  license: "MIT",
+  type: "module",
+  main: "./src/shared/index.ts",
+  types: "./src/shared/index.ts",
+  dependencies: {
+    "@le-space/browser": "workspace:*",
+    "@le-space/core": "workspace:*",
+    viem: "^2.38.5"
+  },
+  peerDependencies: {
+    react: ">=18",
+    "react-dom": ">=18",
+    svelte: ">=4"
+  },
+  devDependencies: {
+    "@types/react": "^18.3.27",
+    "@types/react-dom": "^18.3.7"
+  },
+  scripts: {
+    build: 'echo "ui build placeholder"',
+    "build:publish": "tsup src/shared/index.ts --format esm --dts --clean --tsconfig tsconfig.publish.json --out-dir dist/shared && tsup src/react/index.ts --format esm --dts --tsconfig tsconfig.publish.json --out-dir dist/react",
+    test: "pnpm run build:publish && node --test ./test/**/*.test.mjs",
+    lint: 'echo "ui lint placeholder"'
+  }
+};
+
 // src/shared/constants.ts
 var DEFAULT_INSTANCE_NAME = "sponsor-relay";
 var DEFAULT_MANIFEST_URL = "./rootfs-manifest.json";
@@ -3646,158 +3677,156 @@ var SponsorRelayController = class {
         this.state.pricingSummary.pricing,
         this.state.pricingSummary.tier
       );
-      this.emitProgress({
-        stage: "selecting-crn",
-        label: "Selecting CRN",
-        progress: 18,
-        status: "info",
-        detail: this.state.selectedCrn?.name ?? this.state.selectedCrn?.hash ?? "Auto-selected compatible CRN"
-      });
-      const content = createInstanceContent({
-        address: this.state.wallet.address,
-        name: this.state.instanceName.trim(),
-        sshPublicKey: this.state.sshPublicKey.trim(),
-        rootfsItemHash: this.state.manifest.rootfsItemHash,
-        rootfsSizeMiB: Math.max(
-          this.state.manifest.rootfsSizeMiB,
-          spec.diskMiB
-        ),
-        vcpus: spec.vcpus,
-        memoryMiB: spec.memoryMiB,
-        rootfsVersion: this.state.manifest.version,
-        crnHash: this.state.selectedCrn?.hash
-      });
-      const result = await deployInstance({
-        sender: this.state.wallet.address,
-        content,
-        hasher: sha256Hex,
-        signer: personalSign,
-        fetch: (url, init) => fetch(url, init),
-        apiHost: this.client.apiHost,
-        sync: false,
-        onProgress: (event) => {
-          this.emitProgress(event);
-        }
-      });
-      this.patch({
-        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,
-        fetch: (url, init) => fetch(url, init),
-        attempts: UI_DEPLOY_WAIT_ATTEMPTS,
-        delayMs: UI_DEPLOY_WAIT_DELAY_MS,
-        onAttempt: (inspectionResult) => {
-          if (inspectionResult.status === "processed") {
-            this.emitProgress({
-              stage: "deployment-confirmed",
-              label: "Deployment accepted by Aleph",
-              progress: 82,
-              status: "success",
-              itemHash: result.itemHash,
-              detail: "Aleph processed the instance message."
-            });
-            return;
-          }
-          if (inspectionResult.status === "rejected") {
-            this.emitProgress({
-              stage: "deployment-rejected",
-              label: "Deployment rejected",
-              progress: 100,
-              status: "error",
-              itemHash: result.itemHash,
-              detail: inspectionResult.rejectionReason ?? "Aleph rejected the deployment.",
-              error: inspectionResult.rejectionReason ?? "Aleph rejected the deployment."
-            });
-            return;
-          }
-          this.emitProgress({
-            stage: "waiting-for-aleph",
-            label: "Waiting for Aleph",
-            progress: 76,
-            status: "info",
-            itemHash: result.itemHash,
-            detail: "Deployment submitted. Waiting for Aleph to process the instance message."
-          });
+      const compatibleCrns2 = compatibleCrnsForTier(this.state.crns, {
+        ...this.state,
+        pricingSummary: {
+          ...this.state.pricingSummary,
+          pricing: this.state.pricingSummary.pricing,
+          tier: this.state.pricingSummary.tier
         }
       });
-      if (inspection.status !== "processed") {
-        throw new Error(
-          inspection.rejectionReason ?? `Deployment ${result.itemHash} stayed ${inspection.status} on Aleph.`
-        );
+      const preferredCrnHash = this.state.selectedCrn?.hash ?? null;
+      const orderedCrns = [
+        ...compatibleCrns2.filter((crn) => crn.hash === preferredCrnHash),
+        ...compatibleCrns2.filter((crn) => crn.hash !== preferredCrnHash)
+      ].slice(0, 5);
+      if (orderedCrns.length === 0) {
+        throw new Error("No compatible CRN is currently available for this tier.");
       }
-      this.trace("deploy:aleph-processed", inspection);
-      if ((this.state.manifest.requiredPortForwards?.length ?? 0) > 0) {
+      const attemptErrors = [];
+      let lastError = null;
+      for (const [candidateIndex, candidateCrn] of orderedCrns.entries()) {
+        let attemptItemHash = null;
         this.emitProgress({
-          stage: "refreshing-instances",
-          label: "Publishing port forwards",
-          progress: 86,
+          stage: "selecting-crn",
+          label: "Selecting CRN",
+          progress: 18,
           status: "info",
-          itemHash: result.itemHash,
-          detail: "Publishing the required Aleph port-forward aggregate from the manifest."
-        });
-        await ensureInstancePortForwards({
-          sender: this.state.wallet.address,
-          instanceItemHash: result.itemHash,
-          manifest: toSharedRootfsManifest(this.state.manifest),
-          signer: personalSign,
-          hasher: sha256Hex,
-          fetch: (url, init) => fetch(url, init),
-          apiHost: this.client.apiHost,
-          sync: true
-        });
-        this.trace("deploy:port-forwards-published", {
-          itemHash: result.itemHash,
-          requiredPortForwards: this.state.manifest.requiredPortForwards
+          detail: `Trying ${candidateCrn.name ?? candidateCrn.hash} (${candidateIndex + 1}/${orderedCrns.length})`
         });
-      }
-      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,
-          fetch: (url, init) => fetch(url, init),
-          onProgress: (event) => {
-            this.emitProgress(event);
+        try {
+          const content = createInstanceContent({
+            address: this.state.wallet.address,
+            name: this.state.instanceName.trim(),
+            sshPublicKey: this.state.sshPublicKey.trim(),
+            rootfsItemHash: this.state.manifest.rootfsItemHash,
+            rootfsSizeMiB: Math.max(
+              this.state.manifest.rootfsSizeMiB,
+              spec.diskMiB
+            ),
+            vcpus: spec.vcpus,
+            memoryMiB: spec.memoryMiB,
+            rootfsVersion: this.state.manifest.version,
+            crnHash: candidateCrn.hash
+          });
+          const result = await deployInstance({
+            sender: this.state.wallet.address,
+            content,
+            hasher: sha256Hex,
+            signer: personalSign,
+            fetch: (url, init) => fetch(url, init),
+            apiHost: this.client.apiHost,
+            sync: false,
+            onProgress: (event) => {
+              this.emitProgress(event);
+            }
+          });
+          attemptItemHash = result.itemHash;
+          this.patch({
+            statusText: `Deployment submitted: ${result.itemHash}`,
+            lastDeploymentHash: result.itemHash
+          });
+          this.trace("deploy:broadcasted", {
+            ...result,
+            crnHash: candidateCrn.hash,
+            crnName: candidateCrn.name
+          });
+          this.lastRuntimeReadyHash = null;
+          const inspection = await waitForDeploymentResult2(result.itemHash, {
+            rootfsRef: this.state.manifest.rootfsItemHash,
+            apiHost: this.client.apiHost,
+            fetch: (url, init) => fetch(url, init),
+            attempts: UI_DEPLOY_WAIT_ATTEMPTS,
+            delayMs: UI_DEPLOY_WAIT_DELAY_MS,
+            onAttempt: (inspectionResult) => {
+              if (inspectionResult.status === "processed") {
+                this.emitProgress({
+                  stage: "deployment-confirmed",
+                  label: "Deployment accepted by Aleph",
+                  progress: 82,
+                  status: "success",
+                  itemHash: result.itemHash,
+                  detail: "Aleph processed the instance message."
+                });
+                return;
+              }
+              if (inspectionResult.status === "rejected") {
+                this.emitProgress({
+                  stage: "deployment-rejected",
+                  label: "Deployment rejected",
+                  progress: 100,
+                  status: "error",
+                  itemHash: result.itemHash,
+                  detail: inspectionResult.rejectionReason ?? "Aleph rejected the deployment.",
+                  error: inspectionResult.rejectionReason ?? "Aleph rejected the deployment."
+                });
+                return;
+              }
+              this.emitProgress({
+                stage: "waiting-for-aleph",
+                label: "Waiting for Aleph",
+                progress: 76,
+                status: "info",
+                itemHash: result.itemHash,
+                detail: "Deployment submitted. Waiting for Aleph to process the instance message."
+              });
+            }
+          });
+          if (inspection.status !== "processed") {
+            throw new Error(
+              inspection.rejectionReason ?? `Deployment ${result.itemHash} stayed ${inspection.status} on Aleph.`
+            );
           }
-        });
-      }
-      this.emitProgress({
-        stage: "deployment-confirmed",
-        label: "Waiting for runtime",
-        progress: 90,
-        status: "warning",
-        itemHash: result.itemHash,
-        detail: "Aleph accepted the deployment. Waiting for runtime networking and mapped ports."
-      });
-      const runtime = await waitForVmRuntime({
-        itemHash: result.itemHash,
-        fetch: (url, init) => fetch(url, init),
-        crnHash: this.state.selectedCrn?.hash,
-        crns: this.state.crns,
-        crnListUrl: this.props.crnListUrl,
-        attempts: UI_RUNTIME_WAIT_ATTEMPTS,
-        delayMs: UI_RUNTIME_WAIT_DELAY_MS,
-        onAttempt: (runtime2) => {
-          if (runtime2.hostIpv4 && Object.keys(runtime2.mappedPorts ?? {}).length > 0) {
+          this.trace("deploy:aleph-processed", inspection);
+          if ((this.state.manifest.requiredPortForwards?.length ?? 0) > 0) {
             this.emitProgress({
-              stage: "completed",
-              label: "Runtime ready",
-              progress: 100,
-              status: "success",
+              stage: "refreshing-instances",
+              label: "Publishing port forwards",
+              progress: 86,
+              status: "info",
+              itemHash: result.itemHash,
+              detail: "Publishing the required Aleph port-forward aggregate from the manifest."
+            });
+            await ensureInstancePortForwards({
+              sender: this.state.wallet.address,
+              instanceItemHash: result.itemHash,
+              manifest: toSharedRootfsManifest(this.state.manifest),
+              signer: personalSign,
+              hasher: sha256Hex,
+              fetch: (url, init) => fetch(url, init),
+              apiHost: this.client.apiHost,
+              sync: true
+            });
+            this.trace("deploy:port-forwards-published", {
+              itemHash: result.itemHash,
+              requiredPortForwards: this.state.manifest.requiredPortForwards
+            });
+          }
+          if (candidateCrn.address) {
+            this.trace("deploy:notifying-crn", {
               itemHash: result.itemHash,
-              detail: "Runtime networking and mapped ports are now available."
+              crnName: candidateCrn.name,
+              crnHash: candidateCrn.hash,
+              crnUrl: candidateCrn.address
+            });
+            await notifyCrnAllocationWithRetry({
+              crnUrl: candidateCrn.address,
+              itemHash: result.itemHash,
+              fetch: (url, init) => fetch(url, init),
+              onProgress: (event) => {
+                this.emitProgress(event);
+              }
             });
-            return;
           }
           this.emitProgress({
             stage: "deployment-confirmed",
@@ -3805,46 +3834,122 @@ var SponsorRelayController = class {
             progress: 90,
             status: "warning",
             itemHash: result.itemHash,
-            detail: runtime2.diagnostics?.reason ?? "Waiting for CRN runtime networking and mapped ports."
+            detail: "Aleph accepted the deployment. Waiting for runtime networking and mapped ports."
+          });
+          const runtime = await waitForVmRuntime({
+            itemHash: result.itemHash,
+            fetch: (url, init) => fetch(url, init),
+            crnHash: candidateCrn.hash,
+            crns: this.state.crns,
+            crnListUrl: this.props.crnListUrl,
+            attempts: UI_RUNTIME_WAIT_ATTEMPTS,
+            delayMs: UI_RUNTIME_WAIT_DELAY_MS,
+            onAttempt: (runtime2) => {
+              if (runtime2.hostIpv4 && Object.keys(runtime2.mappedPorts ?? {}).length > 0) {
+                this.emitProgress({
+                  stage: "completed",
+                  label: "Runtime ready",
+                  progress: 100,
+                  status: "success",
+                  itemHash: result.itemHash,
+                  detail: "Runtime networking and mapped ports are now available."
+                });
+                return;
+              }
+              this.emitProgress({
+                stage: "deployment-confirmed",
+                label: "Waiting for runtime",
+                progress: 90,
+                status: "warning",
+                itemHash: result.itemHash,
+                detail: runtime2.diagnostics?.reason ?? "Waiting for CRN runtime networking and mapped ports."
+              });
+            }
+          });
+          if (!runtime.hostIpv4 || Object.keys(runtime.mappedPorts ?? {}).length === 0) {
+            throw new Error(
+              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 }
+          });
+          this.emitProgress({
+            stage: "refreshing-instances",
+            label: "Refreshing instances",
+            progress: 96,
+            status: "info",
+            itemHash: result.itemHash,
+            detail: "Reloading deployments and runtime state."
+          });
+          await this.refresh();
+          return;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          const attemptLabel = candidateCrn.name ?? candidateCrn.hash;
+          attemptErrors.push(`${attemptLabel}: ${lastError.message}`);
+          this.trace("deploy:crn-attempt-error", {
+            crnHash: candidateCrn.hash,
+            crnName: candidateCrn.name,
+            itemHash: attemptItemHash,
+            error: lastError.message
           });
+          if (attemptItemHash) {
+            await forgetAlephMessages({
+              sender: this.state.wallet.address,
+              hashes: [attemptItemHash],
+              reason: `Discard failed Sponsor Relay deployment attempt on ${attemptLabel}`,
+              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
+            }).catch((cleanupError) => {
+              this.trace("deploy:cleanup-error", {
+                itemHash: attemptItemHash,
+                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+              });
+            });
+          }
+          if (candidateIndex < orderedCrns.length - 1) {
+            this.emitProgress({
+              stage: "selecting-crn",
+              label: "Retrying another CRN",
+              progress: 20,
+              status: "warning",
+              itemHash: attemptItemHash,
+              detail: `${attemptLabel} failed: ${lastError.message}`,
+              error: lastError.message
+            });
+            continue;
+          }
         }
-      });
-      if (!runtime.hostIpv4 || Object.keys(runtime.mappedPorts ?? {}).length === 0) {
-        throw new Error(
-          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 }
-      });
-      this.emitProgress({
-        stage: "refreshing-instances",
-        label: "Refreshing instances",
-        progress: 96,
-        status: "info",
-        itemHash: result.itemHash,
-        detail: "Reloading deployments and runtime state."
-      });
-      await this.refresh();
+      throw new Error(
+        attemptErrors.length > 0 ? `All compatible CRNs failed. ${attemptErrors.join(" | ")}` : lastError?.message ?? "All compatible CRNs failed."
+      );
     } catch (error) {
       this.trace("deploy:error", error);
       this.patch({
@@ -4103,6 +4208,7 @@ function launcherIndicator(state) {
 }
 function SponsorRelayFab(props) {
   const { controller, state } = useSponsorRelayController(props);
+  const versionLabel = `v${package_default.version}`;
   const launcherMode = props.launcherMode ?? "floating";
   const indicator = launcherIndicator(state);
   const [successFlash, setSuccessFlash] = React.useState(false);
@@ -4333,16 +4439,33 @@ function SponsorRelayFab(props) {
             },
             children: [
               /* @__PURE__ */ jsxs("div", { children: [
-                /* @__PURE__ */ jsx(
+                /* @__PURE__ */ jsxs(
                   "div",
                   {
                     style: {
+                      display: "flex",
+                      alignItems: "center",
+                      gap: "0.45rem",
                       color: "#9fb2ca",
                       fontSize: "0.72rem",
                       textTransform: "uppercase",
                       letterSpacing: "0.08em"
                     },
-                    children: "Aleph VM credit deployer"
+                    children: [
+                      /* @__PURE__ */ jsx("span", { children: "Aleph VM credit deployer" }),
+                      /* @__PURE__ */ jsx(
+                        "span",
+                        {
+                          style: {
+                            fontSize: "0.62rem",
+                            letterSpacing: "0.04em",
+                            textTransform: "none",
+                            color: "rgba(191, 219, 254, 0.82)"
+                          },
+                          children: versionLabel
+                        }
+                      )
+                    ]
                   }
                 ),
                 /* @__PURE__ */ jsx(

package/shared/index.js

@@ -3645,158 +3645,156 @@ var SponsorRelayController = class {
         this.state.pricingSummary.pricing,
         this.state.pricingSummary.tier
       );
-      this.emitProgress({
-        stage: "selecting-crn",
-        label: "Selecting CRN",
-        progress: 18,
-        status: "info",
-        detail: this.state.selectedCrn?.name ?? this.state.selectedCrn?.hash ?? "Auto-selected compatible CRN"
-      });
-      const content = createInstanceContent({
-        address: this.state.wallet.address,
-        name: this.state.instanceName.trim(),
-        sshPublicKey: this.state.sshPublicKey.trim(),
-        rootfsItemHash: this.state.manifest.rootfsItemHash,
-        rootfsSizeMiB: Math.max(
-          this.state.manifest.rootfsSizeMiB,
-          spec.diskMiB
-        ),
-        vcpus: spec.vcpus,
-        memoryMiB: spec.memoryMiB,
-        rootfsVersion: this.state.manifest.version,
-        crnHash: this.state.selectedCrn?.hash
-      });
-      const result = await deployInstance({
-        sender: this.state.wallet.address,
-        content,
-        hasher: sha256Hex,
-        signer: personalSign,
-        fetch: (url, init) => fetch(url, init),
-        apiHost: this.client.apiHost,
-        sync: false,
-        onProgress: (event) => {
-          this.emitProgress(event);
-        }
-      });
-      this.patch({
-        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,
-        fetch: (url, init) => fetch(url, init),
-        attempts: UI_DEPLOY_WAIT_ATTEMPTS,
-        delayMs: UI_DEPLOY_WAIT_DELAY_MS,
-        onAttempt: (inspectionResult) => {
-          if (inspectionResult.status === "processed") {
-            this.emitProgress({
-              stage: "deployment-confirmed",
-              label: "Deployment accepted by Aleph",
-              progress: 82,
-              status: "success",
-              itemHash: result.itemHash,
-              detail: "Aleph processed the instance message."
-            });
-            return;
-          }
-          if (inspectionResult.status === "rejected") {
-            this.emitProgress({
-              stage: "deployment-rejected",
-              label: "Deployment rejected",
-              progress: 100,
-              status: "error",
-              itemHash: result.itemHash,
-              detail: inspectionResult.rejectionReason ?? "Aleph rejected the deployment.",
-              error: inspectionResult.rejectionReason ?? "Aleph rejected the deployment."
-            });
-            return;
-          }
-          this.emitProgress({
-            stage: "waiting-for-aleph",
-            label: "Waiting for Aleph",
-            progress: 76,
-            status: "info",
-            itemHash: result.itemHash,
-            detail: "Deployment submitted. Waiting for Aleph to process the instance message."
-          });
+      const compatibleCrns2 = compatibleCrnsForTier(this.state.crns, {
+        ...this.state,
+        pricingSummary: {
+          ...this.state.pricingSummary,
+          pricing: this.state.pricingSummary.pricing,
+          tier: this.state.pricingSummary.tier
         }
       });
-      if (inspection.status !== "processed") {
-        throw new Error(
-          inspection.rejectionReason ?? `Deployment ${result.itemHash} stayed ${inspection.status} on Aleph.`
-        );
+      const preferredCrnHash = this.state.selectedCrn?.hash ?? null;
+      const orderedCrns = [
+        ...compatibleCrns2.filter((crn) => crn.hash === preferredCrnHash),
+        ...compatibleCrns2.filter((crn) => crn.hash !== preferredCrnHash)
+      ].slice(0, 5);
+      if (orderedCrns.length === 0) {
+        throw new Error("No compatible CRN is currently available for this tier.");
       }
-      this.trace("deploy:aleph-processed", inspection);
-      if ((this.state.manifest.requiredPortForwards?.length ?? 0) > 0) {
+      const attemptErrors = [];
+      let lastError = null;
+      for (const [candidateIndex, candidateCrn] of orderedCrns.entries()) {
+        let attemptItemHash = null;
         this.emitProgress({
-          stage: "refreshing-instances",
-          label: "Publishing port forwards",
-          progress: 86,
+          stage: "selecting-crn",
+          label: "Selecting CRN",
+          progress: 18,
           status: "info",
-          itemHash: result.itemHash,
-          detail: "Publishing the required Aleph port-forward aggregate from the manifest."
-        });
-        await ensureInstancePortForwards({
-          sender: this.state.wallet.address,
-          instanceItemHash: result.itemHash,
-          manifest: toSharedRootfsManifest(this.state.manifest),
-          signer: personalSign,
-          hasher: sha256Hex,
-          fetch: (url, init) => fetch(url, init),
-          apiHost: this.client.apiHost,
-          sync: true
-        });
-        this.trace("deploy:port-forwards-published", {
-          itemHash: result.itemHash,
-          requiredPortForwards: this.state.manifest.requiredPortForwards
+          detail: `Trying ${candidateCrn.name ?? candidateCrn.hash} (${candidateIndex + 1}/${orderedCrns.length})`
         });
-      }
-      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,
-          fetch: (url, init) => fetch(url, init),
-          onProgress: (event) => {
-            this.emitProgress(event);
+        try {
+          const content = createInstanceContent({
+            address: this.state.wallet.address,
+            name: this.state.instanceName.trim(),
+            sshPublicKey: this.state.sshPublicKey.trim(),
+            rootfsItemHash: this.state.manifest.rootfsItemHash,
+            rootfsSizeMiB: Math.max(
+              this.state.manifest.rootfsSizeMiB,
+              spec.diskMiB
+            ),
+            vcpus: spec.vcpus,
+            memoryMiB: spec.memoryMiB,
+            rootfsVersion: this.state.manifest.version,
+            crnHash: candidateCrn.hash
+          });
+          const result = await deployInstance({
+            sender: this.state.wallet.address,
+            content,
+            hasher: sha256Hex,
+            signer: personalSign,
+            fetch: (url, init) => fetch(url, init),
+            apiHost: this.client.apiHost,
+            sync: false,
+            onProgress: (event) => {
+              this.emitProgress(event);
+            }
+          });
+          attemptItemHash = result.itemHash;
+          this.patch({
+            statusText: `Deployment submitted: ${result.itemHash}`,
+            lastDeploymentHash: result.itemHash
+          });
+          this.trace("deploy:broadcasted", {
+            ...result,
+            crnHash: candidateCrn.hash,
+            crnName: candidateCrn.name
+          });
+          this.lastRuntimeReadyHash = null;
+          const inspection = await waitForDeploymentResult2(result.itemHash, {
+            rootfsRef: this.state.manifest.rootfsItemHash,
+            apiHost: this.client.apiHost,
+            fetch: (url, init) => fetch(url, init),
+            attempts: UI_DEPLOY_WAIT_ATTEMPTS,
+            delayMs: UI_DEPLOY_WAIT_DELAY_MS,
+            onAttempt: (inspectionResult) => {
+              if (inspectionResult.status === "processed") {
+                this.emitProgress({
+                  stage: "deployment-confirmed",
+                  label: "Deployment accepted by Aleph",
+                  progress: 82,
+                  status: "success",
+                  itemHash: result.itemHash,
+                  detail: "Aleph processed the instance message."
+                });
+                return;
+              }
+              if (inspectionResult.status === "rejected") {
+                this.emitProgress({
+                  stage: "deployment-rejected",
+                  label: "Deployment rejected",
+                  progress: 100,
+                  status: "error",
+                  itemHash: result.itemHash,
+                  detail: inspectionResult.rejectionReason ?? "Aleph rejected the deployment.",
+                  error: inspectionResult.rejectionReason ?? "Aleph rejected the deployment."
+                });
+                return;
+              }
+              this.emitProgress({
+                stage: "waiting-for-aleph",
+                label: "Waiting for Aleph",
+                progress: 76,
+                status: "info",
+                itemHash: result.itemHash,
+                detail: "Deployment submitted. Waiting for Aleph to process the instance message."
+              });
+            }
+          });
+          if (inspection.status !== "processed") {
+            throw new Error(
+              inspection.rejectionReason ?? `Deployment ${result.itemHash} stayed ${inspection.status} on Aleph.`
+            );
           }
-        });
-      }
-      this.emitProgress({
-        stage: "deployment-confirmed",
-        label: "Waiting for runtime",
-        progress: 90,
-        status: "warning",
-        itemHash: result.itemHash,
-        detail: "Aleph accepted the deployment. Waiting for runtime networking and mapped ports."
-      });
-      const runtime = await waitForVmRuntime({
-        itemHash: result.itemHash,
-        fetch: (url, init) => fetch(url, init),
-        crnHash: this.state.selectedCrn?.hash,
-        crns: this.state.crns,
-        crnListUrl: this.props.crnListUrl,
-        attempts: UI_RUNTIME_WAIT_ATTEMPTS,
-        delayMs: UI_RUNTIME_WAIT_DELAY_MS,
-        onAttempt: (runtime2) => {
-          if (runtime2.hostIpv4 && Object.keys(runtime2.mappedPorts ?? {}).length > 0) {
+          this.trace("deploy:aleph-processed", inspection);
+          if ((this.state.manifest.requiredPortForwards?.length ?? 0) > 0) {
             this.emitProgress({
-              stage: "completed",
-              label: "Runtime ready",
-              progress: 100,
-              status: "success",
+              stage: "refreshing-instances",
+              label: "Publishing port forwards",
+              progress: 86,
+              status: "info",
+              itemHash: result.itemHash,
+              detail: "Publishing the required Aleph port-forward aggregate from the manifest."
+            });
+            await ensureInstancePortForwards({
+              sender: this.state.wallet.address,
+              instanceItemHash: result.itemHash,
+              manifest: toSharedRootfsManifest(this.state.manifest),
+              signer: personalSign,
+              hasher: sha256Hex,
+              fetch: (url, init) => fetch(url, init),
+              apiHost: this.client.apiHost,
+              sync: true
+            });
+            this.trace("deploy:port-forwards-published", {
+              itemHash: result.itemHash,
+              requiredPortForwards: this.state.manifest.requiredPortForwards
+            });
+          }
+          if (candidateCrn.address) {
+            this.trace("deploy:notifying-crn", {
+              itemHash: result.itemHash,
+              crnName: candidateCrn.name,
+              crnHash: candidateCrn.hash,
+              crnUrl: candidateCrn.address
+            });
+            await notifyCrnAllocationWithRetry({
+              crnUrl: candidateCrn.address,
               itemHash: result.itemHash,
-              detail: "Runtime networking and mapped ports are now available."
+              fetch: (url, init) => fetch(url, init),
+              onProgress: (event) => {
+                this.emitProgress(event);
+              }
             });
-            return;
           }
           this.emitProgress({
             stage: "deployment-confirmed",
@@ -3804,46 +3802,122 @@ var SponsorRelayController = class {
             progress: 90,
             status: "warning",
             itemHash: result.itemHash,
-            detail: runtime2.diagnostics?.reason ?? "Waiting for CRN runtime networking and mapped ports."
+            detail: "Aleph accepted the deployment. Waiting for runtime networking and mapped ports."
+          });
+          const runtime = await waitForVmRuntime({
+            itemHash: result.itemHash,
+            fetch: (url, init) => fetch(url, init),
+            crnHash: candidateCrn.hash,
+            crns: this.state.crns,
+            crnListUrl: this.props.crnListUrl,
+            attempts: UI_RUNTIME_WAIT_ATTEMPTS,
+            delayMs: UI_RUNTIME_WAIT_DELAY_MS,
+            onAttempt: (runtime2) => {
+              if (runtime2.hostIpv4 && Object.keys(runtime2.mappedPorts ?? {}).length > 0) {
+                this.emitProgress({
+                  stage: "completed",
+                  label: "Runtime ready",
+                  progress: 100,
+                  status: "success",
+                  itemHash: result.itemHash,
+                  detail: "Runtime networking and mapped ports are now available."
+                });
+                return;
+              }
+              this.emitProgress({
+                stage: "deployment-confirmed",
+                label: "Waiting for runtime",
+                progress: 90,
+                status: "warning",
+                itemHash: result.itemHash,
+                detail: runtime2.diagnostics?.reason ?? "Waiting for CRN runtime networking and mapped ports."
+              });
+            }
+          });
+          if (!runtime.hostIpv4 || Object.keys(runtime.mappedPorts ?? {}).length === 0) {
+            throw new Error(
+              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 }
+          });
+          this.emitProgress({
+            stage: "refreshing-instances",
+            label: "Refreshing instances",
+            progress: 96,
+            status: "info",
+            itemHash: result.itemHash,
+            detail: "Reloading deployments and runtime state."
           });
+          await this.refresh();
+          return;
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          const attemptLabel = candidateCrn.name ?? candidateCrn.hash;
+          attemptErrors.push(`${attemptLabel}: ${lastError.message}`);
+          this.trace("deploy:crn-attempt-error", {
+            crnHash: candidateCrn.hash,
+            crnName: candidateCrn.name,
+            itemHash: attemptItemHash,
+            error: lastError.message
+          });
+          if (attemptItemHash) {
+            await forgetAlephMessages({
+              sender: this.state.wallet.address,
+              hashes: [attemptItemHash],
+              reason: `Discard failed Sponsor Relay deployment attempt on ${attemptLabel}`,
+              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
+            }).catch((cleanupError) => {
+              this.trace("deploy:cleanup-error", {
+                itemHash: attemptItemHash,
+                error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+              });
+            });
+          }
+          if (candidateIndex < orderedCrns.length - 1) {
+            this.emitProgress({
+              stage: "selecting-crn",
+              label: "Retrying another CRN",
+              progress: 20,
+              status: "warning",
+              itemHash: attemptItemHash,
+              detail: `${attemptLabel} failed: ${lastError.message}`,
+              error: lastError.message
+            });
+            continue;
+          }
         }
-      });
-      if (!runtime.hostIpv4 || Object.keys(runtime.mappedPorts ?? {}).length === 0) {
-        throw new Error(
-          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 }
-      });
-      this.emitProgress({
-        stage: "refreshing-instances",
-        label: "Refreshing instances",
-        progress: 96,
-        status: "info",
-        itemHash: result.itemHash,
-        detail: "Reloading deployments and runtime state."
-      });
-      await this.refresh();
+      throw new Error(
+        attemptErrors.length > 0 ? `All compatible CRNs failed. ${attemptErrors.join(" | ")}` : lastError?.message ?? "All compatible CRNs failed."
+      );
     } catch (error) {
       this.trace("deploy:error", error);
       this.patch({

package/svelte/SponsorRelayFab.svelte

@@ -1,5 +1,6 @@
 <script>
   import { onDestroy, onMount } from 'svelte'
+  import packageJson from '../../package.json'
 
   import { createSponsorRelayController, formatDateTime, formatNumber, formatTierSpecLabel, joinMappedPorts, joinRequiredPortForwards, shortHash } from '../shared/index'
   import AccordionSection from './components/AccordionSection.svelte'
@@ -37,6 +38,7 @@ export let apiHost = undefined
   })
 
   let state = controller.getState()
+  const versionLabel = `v${packageJson.version}`
 
   onMount(async () => {
     const unsubscribe = controller.subscribe((next) => {
@@ -62,7 +64,7 @@ export let apiHost = undefined
   <aside class="panel">
     <div class="panel-head">
       <div>
-        <p class="eyebrow">Aleph VM credit deployer</p>
+        <p class="eyebrow">Aleph VM credit deployer <span class="eyebrow-version">{versionLabel}</span></p>
         <h2>Sponsor Relay</h2>
       </div>
       <button class="refresh" type="button" on:click={() => controller.refresh()} disabled={state.busy.refreshing}>
@@ -322,6 +324,13 @@ export let apiHost = undefined
     letter-spacing: 0.08em;
   }
 
+  .eyebrow-version {
+    font-size: 0.62rem;
+    letter-spacing: 0.04em;
+    text-transform: none;
+    color: rgba(191, 219, 254, 0.82);
+  }
+
   h2,
   h3,
   strong {