@le-space/ui 0.1.52

package/shared/index.js

@@ -0,0 +1,1695 @@
+// src/shared/constants.ts
+var DEFAULT_INSTANCE_NAME = "sponsor-relay";
+var DEFAULT_MANIFEST_URL = "./rootfs-manifest.json";
+var DEFAULT_TIER_ID = "tier-1";
+var ROOTFS_MISSING_STATE = {
+  tone: "idle",
+  label: "manifest missing",
+  detail: "Provide a manifest URL or paste manifest JSON."
+};
+var RELAY_PING_IDLE_STATE = {
+  tone: "idle",
+  sent: false,
+  received: false,
+  lastPeerId: null,
+  lastLatencyMs: null,
+  lastSentAt: null,
+  lastReceivedAt: null,
+  error: null
+};
+var REFRESH_INTERVAL_MS = 3e4;
+var RELAY_PING_INTERVAL_MS = 2e4;
+
+// src/shared/format.ts
+function shortHash(value, head = 8, tail = 6) {
+  if (!value) return "-";
+  if (value.length <= head + tail + 3) return value;
+  return `${value.slice(0, head)}...${value.slice(-tail)}`;
+}
+function formatNumber(value, digits = 0) {
+  if (value == null || !Number.isFinite(value)) return "-";
+  return new Intl.NumberFormat("en-US", {
+    maximumFractionDigits: digits,
+    minimumFractionDigits: digits === 0 ? 0 : Math.min(2, digits)
+  }).format(value);
+}
+function formatDateTime(value) {
+  if (!value) return "-";
+  const date = typeof value === "number" ? new Date(value) : new Date(value);
+  if (Number.isNaN(date.getTime())) return String(value);
+  return date.toLocaleString();
+}
+function buildSshCommand(hostIpv4, mappedPorts2) {
+  if (!hostIpv4) return null;
+  const sshPort = mappedPorts2.find((entry) => entry.label.startsWith("22/"))?.hostPort ?? 22;
+  return `ssh root@${hostIpv4}${sshPort && sshPort !== 22 ? ` -p ${sshPort}` : ""}`;
+}
+function joinMappedPorts(mappedPorts2) {
+  if (mappedPorts2.length === 0) return "-";
+  return mappedPorts2.map((entry) => `${entry.label}->${entry.hostPort ?? "?"}`).join(" \xB7 ");
+}
+
+// ../browser/src/http.ts
+async function fetchWithTimeout(input, init = {}, timeoutMs = 15e3) {
+  const controller = new AbortController();
+  const timeout = globalThis.setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    if (input instanceof URL) {
+      const url = new URL(input.toString());
+      url.searchParams.set("_ts", String(Date.now()));
+      return await fetch(url, {
+        ...init,
+        cache: init.cache ?? "no-store",
+        signal: init.signal ?? controller.signal
+      });
+    }
+    if (typeof input === "string") {
+      let requestInput = input;
+      try {
+        const url = new URL(input, globalThis.location?.href);
+        url.searchParams.set("_ts", String(Date.now()));
+        requestInput = url;
+      } catch {
+      }
+      return await fetch(requestInput, {
+        ...init,
+        cache: init.cache ?? "no-store",
+        signal: init.signal ?? controller.signal
+      });
+    }
+    return await fetch(input, {
+      ...init,
+      cache: init.cache ?? "no-store",
+      signal: init.signal ?? controller.signal
+    });
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw new Error(`Request timed out after ${timeoutMs / 1e3}s.`);
+    }
+    throw error;
+  } finally {
+    globalThis.clearTimeout(timeout);
+  }
+}
+
+// ../browser/src/aleph-api.ts
+var DEFAULT_ALEPH_API_HOST = "https://api2.aleph.im";
+var DEFAULT_CRN_LIST_URL = "https://crns-list.aleph.sh/crns.json";
+var DEFAULT_ALEPH_SCHEDULER_API_HOST = "https://scheduler.api.aleph.cloud";
+var DEFAULT_2N6_API_HOST = "https://api.2n6.me";
+function normalizeMessageStatus(status) {
+  if (typeof status !== "string") return "unknown";
+  const normalized = status.toLowerCase();
+  if (normalized === "processed" || normalized === "pending" || normalized === "rejected") {
+    return normalized;
+  }
+  return "unknown";
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isUnconfirmedNetworkError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return error instanceof TypeError || message.includes("Failed to fetch") || message.includes("Request timed out");
+}
+function normalizeProxyUrl(value) {
+  const stringValue = asString(value);
+  if (!stringValue) return null;
+  if (/^https?:\/\//i.test(stringValue)) return stringValue;
+  return `https://${stringValue}`;
+}
+function extractProxyUrl(value, networking) {
+  const networkingCandidates = [
+    networking?.proxy_url,
+    networking?.proxyUrl,
+    networking?.web_access_url,
+    networking?.webAccessUrl,
+    networking?.proxy_hostname,
+    networking?.proxyHostname,
+    networking?.domain,
+    networking?.hostname
+  ];
+  for (const candidate of networkingCandidates) {
+    const normalized = normalizeProxyUrl(candidate);
+    if (normalized) return normalized;
+  }
+  for (const entry of [value.web_access, value.webAccess]) {
+    const normalized = normalizeProxyUrl(entry?.url) ?? normalizeProxyUrl(entry?.proxy_url) ?? normalizeProxyUrl(entry?.hostname) ?? normalizeProxyUrl(entry?.domain);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+async function fetchBalance(address, apiHost = DEFAULT_ALEPH_API_HOST) {
+  const response = await fetchWithTimeout(`${apiHost}/api/v0/addresses/${address}/balance`, {
+    cache: "no-cache"
+  });
+  if (!response.ok) throw new Error(`Balance request failed: ${response.status}`);
+  return await response.json();
+}
+async function fetchCrns(url = DEFAULT_CRN_LIST_URL) {
+  const requestUrl = new URL(url);
+  requestUrl.searchParams.set("filter_inactive", "true");
+  const response = await fetchWithTimeout(requestUrl, { cache: "no-cache" });
+  if (!response.ok) throw new Error(`CRN list request failed: ${response.status}`);
+  const payload = await response.json();
+  return payload.crns ?? [];
+}
+async function fetchInstances(address, apiHost = DEFAULT_ALEPH_API_HOST) {
+  const url = new URL("/api/v0/messages.json", apiHost);
+  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 fetchWithTimeout(url, { 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" : message.status
+  }));
+}
+async function fetch2n6WebAccessUrl(itemHash, twoN6ApiHost = DEFAULT_2N6_API_HOST) {
+  const requestUrl = new URL(`/api/hash/${itemHash}`, twoN6ApiHost).toString();
+  try {
+    const response = await fetchWithTimeout(requestUrl, { cache: "no-cache" });
+    if (response.status === 404 || !response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    return normalizeProxyUrl(payload.url ?? payload.subdomain);
+  } catch {
+    return null;
+  }
+}
+async function fetchSchedulerAllocation(itemHash, schedulerApiHost = DEFAULT_ALEPH_SCHEDULER_API_HOST) {
+  const response = await fetchWithTimeout(`${schedulerApiHost}/api/v0/allocation/${itemHash}`, {
+    cache: "no-cache"
+  });
+  if (response.status === 404) return null;
+  if (!response.ok) throw new Error(`Scheduler allocation request failed: ${response.status}`);
+  const payload = await response.json();
+  const node = payload.node;
+  return {
+    source: "scheduler",
+    crnUrl: asString(node?.url),
+    node: node ? {
+      node_id: asString(node.node_id) ?? void 0,
+      url: asString(node.url) ?? void 0,
+      ipv6: asString(node.ipv6),
+      supports_ipv6: typeof node.supports_ipv6 === "boolean" ? node.supports_ipv6 : void 0
+    } : null,
+    vmIpv6: asString(payload.vm_ipv6),
+    period: payload.period ? {
+      start_timestamp: asString(payload.period.start_timestamp) ?? void 0,
+      duration_seconds: asNumber(payload.period.duration_seconds) ?? void 0
+    } : null
+  };
+}
+async function fetchCrnExecutionMap(crnUrl) {
+  const normalizedCrnUrl = crnUrl.replace(/\/+$/, "");
+  const v2Url = `${normalizedCrnUrl}/v2/about/executions/list`;
+  const v1Url = `${normalizedCrnUrl}/about/executions/list`;
+  try {
+    const v2Response = await fetchWithTimeout(v2Url, { cache: "no-cache" });
+    if (v2Response.ok) {
+      const payload = await v2Response.json();
+      return {
+        payload,
+        blocked: false,
+        requestUrl: v2Url,
+        version: "v2"
+      };
+    }
+    if (v2Response.status !== 404) {
+      return { payload: null, blocked: false, requestUrl: v2Url, version: "v2" };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof TypeError || message.includes("Failed to fetch")) {
+      return { payload: null, blocked: true, requestUrl: v2Url, version: "v2" };
+    }
+    return { payload: null, blocked: false, requestUrl: v2Url, version: "v2" };
+  }
+  try {
+    const v1Response = await fetchWithTimeout(v1Url, { cache: "no-cache" });
+    if (!v1Response.ok) {
+      return { payload: null, blocked: false, requestUrl: v1Url, version: "v1" };
+    }
+    const payload = await v1Response.json();
+    return {
+      payload,
+      blocked: false,
+      requestUrl: v1Url,
+      version: "v1"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof TypeError || message.includes("Failed to fetch")) {
+      return { payload: null, blocked: true, requestUrl: v1Url, version: "v1" };
+    }
+    return { payload: null, blocked: false, requestUrl: v1Url, version: "v1" };
+  }
+}
+function normalizeExecution(item, crnUrl) {
+  const networking = item.networking ?? null;
+  const mappedPorts2 = networking && "mapped_ports" in networking && networking.mapped_ports && typeof networking.mapped_ports === "object" ? Object.fromEntries(
+    Object.entries(networking.mapped_ports).map(([port, mapping]) => [
+      port,
+      {
+        host: asNumber(mapping?.host) ?? void 0,
+        tcp: typeof mapping?.tcp === "boolean" ? mapping.tcp : void 0,
+        udp: typeof mapping?.udp === "boolean" ? mapping.udp : void 0
+      }
+    ])
+  ) : void 0;
+  if (networking && ("host_ipv4" in networking || "ipv6_ip" in networking || "ipv4_network" in networking)) {
+    const v2Item = item;
+    return {
+      crnUrl,
+      version: "v2",
+      running: typeof v2Item.running === "boolean" ? v2Item.running : void 0,
+      networking: {
+        ipv4_network: asString(networking.ipv4_network),
+        host_ipv4: asString(networking.host_ipv4),
+        ipv6_network: asString(networking.ipv6_network),
+        ipv6_ip: asString(networking.ipv6_ip),
+        ipv4_ip: asString(networking.ipv4_ip),
+        proxy_url: extractProxyUrl(v2Item, networking),
+        mapped_ports: mappedPorts2
+      },
+      status: v2Item.status ? {
+        defined_at: asString(v2Item.status.defined_at),
+        preparing_at: asString(v2Item.status.preparing_at),
+        prepared_at: asString(v2Item.status.prepared_at),
+        starting_at: asString(v2Item.status.starting_at),
+        started_at: asString(v2Item.status.started_at),
+        stopping_at: asString(v2Item.status.stopping_at),
+        stopped_at: asString(v2Item.status.stopped_at)
+      } : null
+    };
+  }
+  return {
+    crnUrl,
+    version: "v1",
+    networking: {
+      ipv4: networking && "ipv4" in networking ? asString(networking.ipv4) : null,
+      ipv6: networking && "ipv6" in networking ? asString(networking.ipv6) : null
+    },
+    status: null
+  };
+}
+async function notifyCrnAllocation(crnUrl, itemHash) {
+  const normalizedCrnUrl = crnUrl.replace(/\/+$/, "");
+  try {
+    const response = await fetchWithTimeout(`${normalizedCrnUrl}/control/allocation/notify`, {
+      method: "POST",
+      headers: {
+        "content-type": "text/plain;charset=UTF-8"
+      },
+      body: JSON.stringify({ instance: itemHash }),
+      mode: "cors"
+    });
+    if (!response.ok) {
+      const responseText = await response.text().catch(() => "");
+      throw new Error(`CRN allocation notify failed: ${response.status}${responseText ? ` ${responseText}` : ""}`);
+    }
+    return { status: "confirmed" };
+  } catch (error) {
+    if (isUnconfirmedNetworkError(error)) {
+      return { status: "unconfirmed" };
+    }
+    throw error;
+  }
+}
+async function configureOrbitdbRelaySetup(args) {
+  const targetUrl = `http://${args.hostIpv4}:${args.setupPort}/configure`;
+  try {
+    const response = await fetchWithTimeout(
+      targetUrl,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "text/plain;charset=UTF-8"
+        },
+        body: JSON.stringify({
+          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
+        }),
+        mode: "cors"
+      },
+      3e4
+    );
+    if (!response.ok) {
+      const responseText = await response.text().catch(() => "");
+      throw new Error(`Relay setup request failed: ${response.status}${responseText ? ` ${responseText}` : ""}`);
+    }
+    return { status: "configured" };
+  } catch (error) {
+    if (isUnconfirmedNetworkError(error)) {
+      return { status: "unconfirmed" };
+    }
+    throw error;
+  }
+}
+function messageTypeFromEnvelope(payload) {
+  if (!payload) return null;
+  const type = payload.type ?? payload.message?.type ?? (Array.isArray(payload.messages) ? payload.messages[0]?.type : void 0);
+  return typeof type === "string" ? type.toUpperCase() : null;
+}
+function extractReferenceHashes(details) {
+  if (!details || typeof details !== "object" || !("errors" in details)) return [];
+  const errors = details.errors;
+  if (!Array.isArray(errors)) return [];
+  return errors.filter((value) => typeof value === "string");
+}
+function describeRejectedDeployment(payload, references, rootfsRef) {
+  const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
+  const pendingReferences = references.filter((reference) => reference.status === "pending");
+  const missingReferences = references.filter((reference) => reference.status === "missing");
+  const rootfsReference = references.find((reference) => reference.itemHash === rootfsRef);
+  if (rootfsReference?.status === "pending") {
+    return `Aleph rejected this deployment because the referenced rootfs STORE message ${rootfsReference.itemHash} is still pending and cannot yet be used by an instance. Wait for that STORE message to process, then deploy again.`;
+  }
+  if (pendingReferences.length > 0) {
+    return `Aleph rejected this deployment because referenced message(s) are still pending: ${pendingReferences.map((reference) => reference.itemHash).join(", ")}.`;
+  }
+  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 referencedHashes = extractReferenceHashes(payload.details);
+  if (referencedHashes.length > 0) {
+    return `Aleph rejected this deployment${errorCode ? ` (error ${errorCode})` : ""}. Referenced message(s): ${referencedHashes.join(", ")}.`;
+  }
+  return `Aleph rejected this deployment${errorCode ? ` (error ${errorCode})` : ""}.`;
+}
+async function fetchMessageEnvelope(itemHash, apiHost = DEFAULT_ALEPH_API_HOST) {
+  const response = await fetchWithTimeout(`${apiHost}/api/v0/messages/${itemHash}`, {
+    cache: "no-cache"
+  });
+  if (response.status === 404) return null;
+  if (!response.ok) throw new Error(`Message lookup failed: ${response.status}`);
+  return await response.json();
+}
+async function fetchReference(itemHash, apiHost) {
+  const payload = await fetchMessageEnvelope(itemHash, apiHost);
+  if (!payload) {
+    return {
+      itemHash,
+      status: "missing",
+      type: null
+    };
+  }
+  return {
+    itemHash,
+    status: normalizeMessageStatus(payload.status),
+    type: messageTypeFromEnvelope(payload)
+  };
+}
+async function inspectDeploymentResult(itemHash, rootfsRef, apiHost = DEFAULT_ALEPH_API_HOST) {
+  const payload = await fetchMessageEnvelope(itemHash, apiHost);
+  if (!payload) {
+    return {
+      status: "unknown",
+      errorCode: null,
+      details: null,
+      rejectionReason: `Deployment message ${itemHash} was not found on Aleph.`,
+      references: []
+    };
+  }
+  const relatedHashes = new Set(rootfsRef ? [rootfsRef] : []);
+  for (const referenceHash of extractReferenceHashes(payload.details)) {
+    relatedHashes.add(referenceHash);
+  }
+  const references = await Promise.all(Array.from(relatedHashes).map((hash) => fetchReference(hash, apiHost)));
+  const status = normalizeMessageStatus(payload.status);
+  const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
+  const details = payload.details && typeof payload.details === "object" ? payload.details : null;
+  return {
+    status,
+    errorCode,
+    details,
+    rejectionReason: status === "rejected" ? describeRejectedDeployment(payload, references, rootfsRef) : null,
+    references
+  };
+}
+async function waitForDeploymentResult(itemHash, rootfsRef, apiHost = DEFAULT_ALEPH_API_HOST, attempts = 15, delayMs = 2e3) {
+  let lastResult = await inspectDeploymentResult(itemHash, rootfsRef, apiHost);
+  for (let attempt = 1; attempt < attempts; attempt += 1) {
+    if (lastResult.status === "processed" || lastResult.status === "rejected") {
+      return lastResult;
+    }
+    await new Promise((resolve) => globalThis.setTimeout(resolve, delayMs));
+    lastResult = await inspectDeploymentResult(itemHash, rootfsRef, apiHost);
+  }
+  return lastResult;
+}
+function isInvalidMessageFormatResponse(response, payload) {
+  if (response.status !== 422) return false;
+  const details = payload.details;
+  if (typeof details === "string" && details.includes("InvalidMessageFormat")) return true;
+  if (details && typeof details === "object") {
+    const detailMessage = details.message;
+    if (typeof detailMessage === "string" && detailMessage.includes("InvalidMessageFormat")) return true;
+  }
+  return false;
+}
+async function postBroadcastPayload(body, apiHost) {
+  const rawResponse = await fetchWithTimeout(`${apiHost}/api/v0/messages`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const response = await rawResponse.json().catch(() => ({}));
+  return {
+    response,
+    httpStatus: rawResponse.status,
+    rawResponse
+  };
+}
+async function broadcastInstanceMessage(message, apiHost = DEFAULT_ALEPH_API_HOST, sync = false) {
+  const attempts = [{ sync, message }, { ...message, sync }, { ...message }];
+  for (let index = 0; index < attempts.length; index += 1) {
+    const result = await postBroadcastPayload(attempts[index], apiHost);
+    if (result.rawResponse.ok || result.httpStatus === 202) {
+      return {
+        response: result.response,
+        httpStatus: result.httpStatus
+      };
+    }
+    const canRetry = index < attempts.length - 1 && isInvalidMessageFormatResponse(result.rawResponse, result.response);
+    if (!canRetry) {
+      throw new Error(`Broadcast failed: ${result.httpStatus} ${JSON.stringify(result.response)}`);
+    }
+  }
+  throw new Error("Broadcast failed: no compatible request format was accepted");
+}
+async function broadcastAlephMessage(message, apiHost = DEFAULT_ALEPH_API_HOST, sync = false) {
+  return broadcastInstanceMessage(message, apiHost, sync);
+}
+
+// ../browser/src/rootfs.ts
+var ITEM_HASH_RE = /^[a-fA-F0-9]{64}$/u;
+var DEFAULT_ROOTFS_MANIFEST_URL = "./rootfs-manifest.json";
+var DEFAULT_IPFS_GATEWAY_BASE_URL = "https://ipfs.aleph.cloud/ipfs/";
+function resolveManifestUrl(input, baseUrl) {
+  if (input instanceof URL) return input;
+  try {
+    return new URL(input, baseUrl ? String(baseUrl) : globalThis.location?.href);
+  } catch {
+    return input;
+  }
+}
+function validateRootfsManifest(manifest) {
+  const errors = [];
+  if (!manifest) {
+    return { manifest, valid: false, errors: ["Rootfs manifest is missing."] };
+  }
+  if (!manifest.version) errors.push("Rootfs manifest version is missing.");
+  if (manifest.rootfsInstallStrategy != null && manifest.rootfsInstallStrategy !== "thin" && manifest.rootfsInstallStrategy !== "prebaked") {
+    errors.push('Rootfs install strategy must be "thin" or "prebaked" when provided.');
+  }
+  if (manifest.requiresBootstrapNetwork != null && typeof manifest.requiresBootstrapNetwork !== "boolean") {
+    errors.push("Rootfs bootstrap network flag must be a boolean when provided.");
+  }
+  if (manifest.bootstrapSummary != null && !manifest.bootstrapSummary.trim()) {
+    errors.push("Rootfs bootstrap summary must be non-empty when provided.");
+  }
+  if (manifest.requiredPortForwards != null) {
+    if (!Array.isArray(manifest.requiredPortForwards)) {
+      errors.push("Rootfs required port forwards must be an array when provided.");
+    } else {
+      manifest.requiredPortForwards.forEach((entry, index) => {
+        if (!entry || typeof entry !== "object") {
+          errors.push(`Rootfs required port forward #${index + 1} must be an object.`);
+          return;
+        }
+        if (!Number.isInteger(entry.port) || entry.port < 1 || entry.port > 65535) {
+          errors.push(`Rootfs required port forward #${index + 1} must use a TCP/UDP port between 1 and 65535.`);
+        }
+        if (entry.tcp !== true && entry.udp !== true) {
+          errors.push(`Rootfs required port forward #${index + 1} must enable TCP or UDP.`);
+        }
+        if (entry.purpose != null && (typeof entry.purpose !== "string" || !entry.purpose.trim())) {
+          errors.push(`Rootfs required port forward #${index + 1} purpose must be non-empty when provided.`);
+        }
+      });
+    }
+  }
+  if (!ITEM_HASH_RE.test(manifest.rootfsItemHash || "")) {
+    errors.push("Rootfs ItemHash must be a 64 character hex value.");
+  }
+  if (!Number.isInteger(manifest.rootfsSizeMiB) || manifest.rootfsSizeMiB <= 0) {
+    errors.push("Rootfs size must be a positive MiB integer.");
+  }
+  if (manifest.rootfsSourceSizeBytes != null && (!Number.isInteger(manifest.rootfsSourceSizeBytes) || manifest.rootfsSourceSizeBytes <= 0)) {
+    errors.push("Rootfs source size must be a positive byte integer when provided.");
+  }
+  if (!manifest.createdAt || Number.isNaN(new Date(manifest.createdAt).getTime())) {
+    errors.push("Rootfs creation date is missing or invalid.");
+  }
+  return { manifest, valid: errors.length === 0, errors };
+}
+async function loadRootfsManifest(url = DEFAULT_ROOTFS_MANIFEST_URL, options = {}) {
+  const response = await fetchWithTimeout(resolveManifestUrl(url, options.baseUrl), { cache: "no-cache" });
+  if (!response.ok) {
+    throw new Error(`Rootfs manifest request failed: ${response.status}`);
+  }
+  return validateRootfsManifest(await response.json());
+}
+async function verifyRootfsExists(itemHash, apiHost = DEFAULT_ALEPH_API_HOST) {
+  if (!ITEM_HASH_RE.test(itemHash)) return false;
+  const response = await fetchWithTimeout(`${apiHost}/api/v0/messages/${itemHash}`, {
+    method: "GET",
+    cache: "no-cache"
+  });
+  if (response.status === 404) return false;
+  if (!response.ok) throw new Error(`Rootfs lookup failed: ${response.status}`);
+  const payload = await response.json();
+  const firstMessage = Array.isArray(payload.messages) ? payload.messages[0] : void 0;
+  const type = String(payload.type || payload.message?.type || firstMessage?.type || "").toUpperCase();
+  return type === "STORE";
+}
+function normalizeStatus(status) {
+  if (typeof status !== "string") return "unknown";
+  const normalized = status.toLowerCase();
+  if (normalized === "processed" || normalized === "pending" || normalized === "rejected") {
+    return normalized;
+  }
+  return "unknown";
+}
+function parseCidFromPayload(payload) {
+  const firstMessage = Array.isArray(payload.messages) && payload.messages[0] && typeof payload.messages[0] === "object" ? payload.messages[0] : null;
+  const directContent = firstMessage?.content && typeof firstMessage.content === "object" ? firstMessage.content : null;
+  if (typeof directContent?.item_hash === "string") {
+    return directContent.item_hash;
+  }
+  if (typeof firstMessage?.item_content === "string") {
+    try {
+      const itemContent = JSON.parse(firstMessage.item_content);
+      if (typeof itemContent.item_hash === "string") {
+        return itemContent.item_hash;
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseRejectionReason(payload) {
+  const errorCode = typeof payload.error_code === "number" ? payload.error_code : null;
+  const details = payload.details && typeof payload.details === "object" ? payload.details : null;
+  const rawErrors = Array.isArray(details?.errors) ? details.errors : [];
+  const firstError = rawErrors[0] && typeof rawErrors[0] === "object" ? rawErrors[0] : null;
+  if (firstError) {
+    const accountBalance = Number(firstError.account_balance);
+    const requiredBalance = Number(firstError.required_balance);
+    if (Number.isFinite(accountBalance) && Number.isFinite(requiredBalance)) {
+      const shortfall = requiredBalance - accountBalance;
+      return {
+        rejectionErrorCode: errorCode,
+        rejectionReason: shortfall > 0 ? `Rejected by Aleph for insufficient hold balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required, ${shortfall.toFixed(3)} short.` : `Rejected by Aleph for insufficient hold balance: ${accountBalance.toFixed(3)} available, ${requiredBalance.toFixed(3)} required.`
+      };
+    }
+  }
+  return {
+    rejectionErrorCode: errorCode,
+    rejectionReason: errorCode != null ? `Rejected by Aleph (error code ${errorCode}).` : null
+  };
+}
+async function probeGateway(cid, gatewayBaseUrl = DEFAULT_IPFS_GATEWAY_BASE_URL) {
+  const gatewayUrl = new URL(cid, gatewayBaseUrl).toString();
+  try {
+    const response = await fetchWithTimeout(gatewayUrl, { method: "HEAD", cache: "no-store" }, 5e3);
+    return {
+      gatewayUrl,
+      gatewayStatus: response.ok ? "reachable" : "error",
+      gatewayError: response.ok ? null : `Gateway responded with ${response.status}.`
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("timed out")) {
+      return {
+        gatewayUrl,
+        gatewayStatus: "timeout",
+        gatewayError: error.message
+      };
+    }
+    return {
+      gatewayUrl,
+      gatewayStatus: "unavailable",
+      gatewayError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function resolveRootfsReference(itemHash, apiHost = DEFAULT_ALEPH_API_HOST, gatewayBaseUrl = DEFAULT_IPFS_GATEWAY_BASE_URL) {
+  if (!ITEM_HASH_RE.test(itemHash)) return null;
+  const response = await fetchWithTimeout(`${apiHost}/api/v0/messages/${itemHash}`, {
+    method: "GET",
+    cache: "no-cache"
+  });
+  if (response.status === 404) return null;
+  if (!response.ok) throw new Error(`Rootfs lookup failed: ${response.status}`);
+  const payload = await response.json();
+  const firstMessage = Array.isArray(payload.messages) && payload.messages[0] && typeof payload.messages[0] === "object" ? payload.messages[0] : null;
+  const messageObject = payload.message && typeof payload.message === "object" ? payload.message : null;
+  const cid = parseCidFromPayload(payload);
+  const rejection = normalizeStatus(payload.status) === "rejected" ? parseRejectionReason(payload) : { rejectionErrorCode: null, rejectionReason: null };
+  const gateway = cid ? await probeGateway(cid, gatewayBaseUrl) : { gatewayUrl: null, gatewayStatus: "unknown", gatewayError: null };
+  return {
+    itemHash,
+    messageStatus: normalizeStatus(payload.status),
+    messageType: String(payload.type || messageObject?.type || firstMessage?.type || "").toUpperCase() || null,
+    cid,
+    receptionTime: typeof payload.reception_time === "string" ? payload.reception_time : null,
+    rejectionErrorCode: rejection.rejectionErrorCode,
+    rejectionReason: rejection.rejectionReason,
+    gatewayUrl: gateway.gatewayUrl,
+    gatewayStatus: gateway.gatewayStatus,
+    gatewayError: gateway.gatewayError
+  };
+}
+
+// src/shared/manifest-source.ts
+function resolveManifestSource(args) {
+  const trimmed = args.manifestJson.trim();
+  if (!trimmed) return null;
+  try {
+    return validateRootfsManifest(JSON.parse(trimmed));
+  } catch (error) {
+    return {
+      manifest: null,
+      valid: false,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+
+// src/shared/wallet-controller.ts
+function getEthereumProvider() {
+  return globalThis.window?.ethereum ?? null;
+}
+async function connectWallet(provider = getEthereumProvider()) {
+  if (!provider) {
+    throw new Error("MetaMask provider not found.");
+  }
+  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const chainId = await provider.request({ method: "eth_chainId" });
+  return {
+    connected: Boolean(accounts[0]),
+    address: accounts[0] ?? null,
+    chainId,
+    isMetaMask: Boolean(provider.isMetaMask)
+  };
+}
+async function personalSign(address, message, provider = getEthereumProvider()) {
+  if (!provider) {
+    throw new Error("MetaMask provider not found.");
+  }
+  const payload = `0x${Array.from(new TextEncoder().encode(message)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  return provider.request({
+    method: "personal_sign",
+    params: [payload, address]
+  });
+}
+function watchWallet(onChange, provider = getEthereumProvider()) {
+  if (!provider?.on || !provider?.removeListener) {
+    return () => {
+    };
+  }
+  provider.on("accountsChanged", onChange);
+  provider.on("chainChanged", onChange);
+  return () => {
+    provider.removeListener?.("accountsChanged", onChange);
+    provider.removeListener?.("chainChanged", onChange);
+  };
+}
+
+// ../browser/src/client.ts
+function createAlephBrowserClient(options = {}) {
+  const apiHost = options.apiHost ?? DEFAULT_ALEPH_API_HOST;
+  const crnListUrl = options.crnListUrl ?? DEFAULT_CRN_LIST_URL;
+  const schedulerApiHost = options.schedulerApiHost ?? DEFAULT_ALEPH_SCHEDULER_API_HOST;
+  const twoN6ApiHost = options.twoN6ApiHost ?? DEFAULT_2N6_API_HOST;
+  return {
+    apiHost,
+    crnListUrl,
+    schedulerApiHost,
+    fetchBalance(address) {
+      return fetchBalance(address, apiHost);
+    },
+    fetchCrns() {
+      return fetchCrns(crnListUrl);
+    },
+    fetchInstances(address) {
+      return fetchInstances(address, apiHost);
+    },
+    fetch2n6WebAccessUrl(itemHash) {
+      return fetch2n6WebAccessUrl(itemHash, twoN6ApiHost);
+    },
+    fetchMessageEnvelope(itemHash) {
+      return fetchMessageEnvelope(itemHash, apiHost);
+    },
+    fetchSchedulerAllocation(itemHash) {
+      return fetchSchedulerAllocation(itemHash, schedulerApiHost);
+    },
+    fetchCrnExecutionMap(crnUrl) {
+      return fetchCrnExecutionMap(crnUrl);
+    },
+    notifyCrnAllocation(crnUrl, itemHash) {
+      return notifyCrnAllocation(crnUrl, itemHash);
+    },
+    configureOrbitdbRelaySetup(args) {
+      return configureOrbitdbRelaySetup(args);
+    },
+    inspectDeploymentResult(itemHash, rootfsRef) {
+      return inspectDeploymentResult(itemHash, rootfsRef, apiHost);
+    },
+    waitForDeploymentResult(itemHash, rootfsRef, attempts, delayMs) {
+      return waitForDeploymentResult(itemHash, rootfsRef, apiHost, attempts, delayMs);
+    },
+    broadcastInstanceMessage(message, sync) {
+      return broadcastInstanceMessage(message, apiHost, sync);
+    },
+    broadcastAlephMessage(message, sync) {
+      return broadcastAlephMessage(message, apiHost, sync);
+    }
+  };
+}
+
+// ../browser/src/pricing.ts
+var DEFAULT_ALEPH_AGGREGATE_ADDRESS = "0xFba561a84A537fCaa567bb7A2257e7142701ae2A";
+function parseInstancePricing(payload) {
+  const data = payload;
+  const pricing = data.data?.pricing ?? data.pricing;
+  const instance = pricing?.instance;
+  if (!instance?.price?.compute_unit || !instance.compute_unit || !Array.isArray(instance.tiers)) {
+    throw new Error("Aleph pricing aggregate does not contain instance pricing.");
+  }
+  return instance;
+}
+async function fetchInstancePricing(apiHost = DEFAULT_ALEPH_API_HOST, aggregateAddress = DEFAULT_ALEPH_AGGREGATE_ADDRESS) {
+  const response = await fetchWithTimeout(`${apiHost}/api/v0/aggregates/${aggregateAddress}.json?keys=pricing`, {
+    cache: "no-cache"
+  });
+  if (!response.ok) {
+    throw new Error(`Pricing aggregate request failed: ${response.status}`);
+  }
+  const payload = await response.json();
+  const pricingAggregate = payload.data?.pricing;
+  if (!pricingAggregate) {
+    throw new Error("Pricing aggregate response did not include a pricing key.");
+  }
+  return {
+    pricing: parseInstancePricing({ pricing: pricingAggregate }),
+    fetchedAt: Date.now()
+  };
+}
+
+// ../core/src/constants.ts
+var DEFAULT_ALEPH_CHANNEL = "TEST";
+
+// ../core/src/manifests.ts
+var DEFAULT_ALEPH_API_HOST2 = "https://api2.aleph.im";
+
+// ../core/src/crns.ts
+function compatibleCrns(crns, excludedHashes = []) {
+  const excluded = new Set(excludedHashes.filter(Boolean));
+  return [...crns].filter((crn) => {
+    if (!crn?.hash || excluded.has(crn.hash)) return false;
+    if (crn.qemu_support === false) return false;
+    if (crn.system_usage?.active === false) return false;
+    return true;
+  });
+}
+function hasCrnCapacity(crn, spec) {
+  if (!spec) return true;
+  const usage = crn.system_usage;
+  if (!usage) return true;
+  const cpuOk = usage.cpu?.count == null || usage.cpu.count >= spec.vcpus;
+  const memoryOk = usage.mem?.available_kB == null || usage.mem.available_kB >= spec.memoryMiB * 1024;
+  const diskOk = usage.disk?.available_kB == null || usage.disk.available_kB >= spec.diskMiB * 1024;
+  return cpuOk && memoryOk && diskOk;
+}
+function scoreSortedCrns(crns) {
+  return [...crns].sort((left, right) => {
+    const rightScore = typeof right.score === "number" ? right.score : Number(right.score ?? Number.NEGATIVE_INFINITY);
+    const leftScore = typeof left.score === "number" ? left.score : Number(left.score ?? Number.NEGATIVE_INFINITY);
+    if (rightScore !== leftScore) return rightScore - leftScore;
+    const leftName = (left.name || left.address || left.hash).toLowerCase();
+    const rightName = (right.name || right.address || right.hash).toLowerCase();
+    return leftName.localeCompare(rightName);
+  });
+}
+function filterDeployableCrns(crns, options = {}) {
+  return scoreSortedCrns(
+    compatibleCrns(crns, options.excludedHashes).filter((crn) => hasCrnCapacity(crn, options.spec))
+  );
+}
+
+// ../core/src/aleph-normalizers.ts
+function normalizeMessageStatus2(status) {
+  if (typeof status !== "string") return "unknown";
+  const normalized = status.toLowerCase();
+  if (normalized === "processed" || normalized === "pending" || normalized === "rejected") {
+    return normalized;
+  }
+  return "unknown";
+}
+
+// ../core/src/broadcast.ts
+function signaturePayload(message) {
+  return [message.chain, message.sender, message.type, message.item_hash].join("\n");
+}
+async function signAlephMessage(unsignedMessage, signer) {
+  const signature = await signer(unsignedMessage.sender, signaturePayload(unsignedMessage));
+  return {
+    ...unsignedMessage,
+    signature: signature.startsWith("0x") ? signature : `0x${signature}`
+  };
+}
+function normalizeBroadcastStatus(httpStatus, responseStatus) {
+  if (httpStatus === 202) return "pending";
+  return normalizeMessageStatus2(responseStatus);
+}
+function isInvalidMessageFormatResponse2(response, payload) {
+  if (response.status !== 422) return false;
+  const details = payload?.details;
+  if (typeof details === "string" && details.includes("InvalidMessageFormat")) return true;
+  if (details && typeof details === "object") {
+    const detailMessage = details.message;
+    if (typeof detailMessage === "string" && detailMessage.includes("InvalidMessageFormat")) return true;
+  }
+  return false;
+}
+function isRetryableBroadcastFailure(response, payload) {
+  if (response.status >= 500) return true;
+  const publicationStatus = payload?.publication_status?.status;
+  if (typeof publicationStatus === "string" && publicationStatus.toLowerCase() === "error") {
+    return true;
+  }
+  return false;
+}
+async function postBroadcastPayload2(body, options) {
+  const rawResponse = await options.fetch(`${options.apiHost ?? DEFAULT_ALEPH_API_HOST2}/api/v0/messages`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const response = await rawResponse.json().catch(() => ({}));
+  return {
+    response,
+    httpStatus: rawResponse.status
+  };
+}
+async function broadcastAlephMessage2(message, options) {
+  const attempts = [
+    { sync: options.sync ?? false, message },
+    { ...message, sync: options.sync ?? false },
+    { ...message }
+  ];
+  for (let index = 0; index < attempts.length; index += 1) {
+    const result = await postBroadcastPayload2(attempts[index], {
+      apiHost: options.apiHost,
+      fetch: options.fetch
+    });
+    if (result.httpStatus === 202 || normalizeBroadcastStatus(result.httpStatus, result.response?.message_status) !== "unknown" || result.httpStatus >= 200 && result.httpStatus < 300) {
+      return result;
+    }
+    const canRetry = index < attempts.length - 1 && (isInvalidMessageFormatResponse2({ status: result.httpStatus }, result.response) || isRetryableBroadcastFailure({ status: result.httpStatus }, result.response));
+    if (!canRetry) {
+      throw new Error(`Broadcast failed: ${result.httpStatus} ${JSON.stringify(result.response ?? {})}`);
+    }
+  }
+  throw new Error("Broadcast failed: no compatible request format was accepted");
+}
+
+// ../core/src/forget.ts
+function asOptionalReason(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+async function createUnsignedForgetMessage(args) {
+  const content = {
+    address: args.sender,
+    time: args.now ?? Date.now() / 1e3,
+    hashes: [...new Set((args.hashes ?? []).filter(Boolean))],
+    aggregates: [...new Set((args.aggregates ?? []).filter(Boolean))],
+    reason: asOptionalReason(args.reason)
+  };
+  if (content.hashes.length === 0 && content.aggregates.length === 0) {
+    throw new Error("FORGET message requires at least one hash or aggregate key.");
+  }
+  const itemContent = JSON.stringify(content);
+  const itemHash = await args.hasher(itemContent);
+  return {
+    sender: args.sender,
+    chain: "ETH",
+    type: "FORGET",
+    item_hash: itemHash,
+    item_type: "inline",
+    item_content: itemContent,
+    time: args.now ?? Date.now() / 1e3,
+    channel: args.channel ?? DEFAULT_ALEPH_CHANNEL
+  };
+}
+async function forgetAlephMessages(args) {
+  const unsignedMessage = await createUnsignedForgetMessage({
+    sender: args.sender,
+    hashes: args.hashes,
+    aggregates: args.aggregates,
+    reason: args.reason,
+    hasher: args.hasher,
+    channel: args.channel,
+    now: args.now
+  });
+  const message = await signAlephMessage(unsignedMessage, args.signer);
+  const { response, httpStatus } = await broadcastAlephMessage2(message, {
+    apiHost: args.apiHost,
+    sync: args.sync,
+    fetch: args.fetch
+  });
+  return {
+    sender: args.sender,
+    itemHash: message.item_hash,
+    response,
+    httpStatus,
+    status: normalizeBroadcastStatus(httpStatus, response?.message_status)
+  };
+}
+
+// ../core/src/instance-deployment.ts
+var SSH_PUBLIC_KEY_PATTERN = /^(ssh-rsa|ssh-ed25519|ecdsa-sha2-nistp256|ecdsa-sha2-nistp384|ecdsa-sha2-nistp521|sk-ssh-ed25519@openssh\.com|sk-ecdsa-sha2-nistp256@openssh\.com)\s+[A-Za-z0-9+/]+={0,3}(?:\s+.+)?$/;
+function toFiniteNumber(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.trim()) return Number(value);
+  return Number.NaN;
+}
+function normalizeSshPublicKey(value) {
+  return value.split(/\r?\n/g).map((line) => line.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+}
+function isValidSshPublicKey(value) {
+  return SSH_PUBLIC_KEY_PATTERN.test(normalizeSshPublicKey(value));
+}
+function createReleaseMetadata(name, rootfsVersion, deployer = "shared-aleph-tooling") {
+  return {
+    name,
+    rootfs_version: rootfsVersion,
+    deployer
+  };
+}
+function tierSpec(pricing, tier) {
+  return {
+    vcpus: pricing.compute_unit.vcpus * tier.compute_units,
+    memoryMiB: pricing.compute_unit.memory_mib * tier.compute_units,
+    diskMiB: pricing.compute_unit.disk_mib * tier.compute_units
+  };
+}
+function buildPaymentQuote(tier, pricing, balance) {
+  const computeUnitPrice = pricing.price.compute_unit;
+  if (!computeUnitPrice) return null;
+  const unitPrice = toFiniteNumber(computeUnitPrice.credit);
+  if (!Number.isFinite(unitPrice)) return null;
+  return {
+    required: unitPrice * tier.compute_units,
+    available: Number(balance.credit_balance ?? 0),
+    computeUnits: tier.compute_units,
+    unitPrice,
+    label: "credits"
+  };
+}
+function createInstanceContent(args) {
+  const sshKey = normalizeSshPublicKey(args.sshPublicKey);
+  if (!sshKey) {
+    throw new Error("An SSH public key is required.");
+  }
+  if (!isValidSshPublicKey(sshKey)) {
+    throw new Error("SSH public key must be a single valid .pub line.");
+  }
+  if (!args.rootfsItemHash || !/^[a-fA-F0-9]{64}$/.test(args.rootfsItemHash)) {
+    throw new Error("rootfsItemHash must be a 64-character Aleph item hash.");
+  }
+  return {
+    address: args.address,
+    time: args.now ?? Date.now() / 1e3,
+    allow_amend: false,
+    metadata: createReleaseMetadata(args.name.trim(), args.rootfsVersion ?? "custom-rootfs", args.deployer),
+    authorized_keys: [sshKey],
+    environment: {
+      internet: true,
+      aleph_api: true,
+      hypervisor: "qemu",
+      reproducible: false,
+      shared_cache: false
+    },
+    resources: {
+      vcpus: Number(args.vcpus),
+      memory: Number(args.memoryMiB),
+      seconds: Number(args.seconds ?? 30)
+    },
+    payment: {
+      type: "credit"
+    },
+    requirements: args.crnHash ? {
+      node: {
+        node_hash: args.crnHash
+      }
+    } : void 0,
+    volumes: [],
+    rootfs: {
+      parent: {
+        ref: args.rootfsItemHash,
+        use_latest: true
+      },
+      persistence: "host",
+      size_mib: Number(args.rootfsSizeMiB)
+    }
+  };
+}
+async function createUnsignedInstanceMessage(args) {
+  const itemContent = JSON.stringify(args.content);
+  const itemHash = await args.hasher(itemContent);
+  return {
+    sender: args.sender,
+    chain: "ETH",
+    type: "INSTANCE",
+    item_hash: itemHash,
+    item_type: "inline",
+    item_content: itemContent,
+    time: args.now ?? Date.now() / 1e3,
+    channel: args.channel ?? DEFAULT_ALEPH_CHANNEL
+  };
+}
+async function deployInstance(args) {
+  const unsignedMessage = await createUnsignedInstanceMessage({
+    sender: args.sender,
+    content: args.content,
+    hasher: args.hasher,
+    channel: args.channel,
+    now: args.now
+  });
+  const signature = await args.signer(unsignedMessage.sender, [unsignedMessage.chain, unsignedMessage.sender, unsignedMessage.type, unsignedMessage.item_hash].join("\n"));
+  const message = {
+    ...unsignedMessage,
+    signature: signature.startsWith("0x") ? signature : `0x${signature}`
+  };
+  const { response, httpStatus } = await broadcastAlephMessage2(message, {
+    apiHost: args.apiHost,
+    sync: args.sync,
+    fetch: args.fetch
+  });
+  const status = httpStatus === 202 ? "pending" : typeof response.message_status === "string" ? response.message_status : "unknown";
+  return {
+    itemHash: message.item_hash,
+    httpStatus,
+    status,
+    message,
+    response,
+    rejectionReason: status === "rejected" ? String(response.details ?? "Aleph rejected this deployment.") : null
+  };
+}
+
+// src/shared/controller.ts
+function defaultState(props = {}) {
+  return {
+    ready: false,
+    open: Boolean(props.openByDefault),
+    wallet: {
+      connected: false,
+      address: null,
+      chainId: null,
+      isMetaMask: false
+    },
+    manifestUrl: props.manifestUrl ?? DEFAULT_MANIFEST_URL,
+    manifestJson: props.manifestJson ?? "",
+    sshPublicKey: props.sshPublicKey ?? "",
+    instanceName: props.instanceName ?? DEFAULT_INSTANCE_NAME,
+    tierId: DEFAULT_TIER_ID,
+    showInstances: props.showInstances ?? true,
+    showPasteManifest: false,
+    busy: {
+      connectingWallet: false,
+      refreshing: false,
+      deploying: false,
+      deletingInstanceHash: null
+    },
+    statusText: "Ready",
+    errorText: null,
+    manifestState: {
+      manifest: null,
+      valid: false,
+      errors: ["Manifest not loaded yet."]
+    },
+    manifest: null,
+    rootfsResolution: null,
+    rootfsVerified: false,
+    rootfsHealth: ROOTFS_MISSING_STATE,
+    pricingSummary: {
+      pricing: null,
+      tier: null,
+      requiredCredits: null,
+      availableCredits: null,
+      vcpus: null,
+      memoryMiB: null,
+      diskMiB: null
+    },
+    balance: null,
+    crns: [],
+    selectedCrn: null,
+    instances: [],
+    relayPing: RELAY_PING_IDLE_STATE,
+    lastDeploymentHash: null
+  };
+}
+async function sha256Hex(payload) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function mappedPorts(execution) {
+  return Object.entries(execution?.networking?.mapped_ports ?? {}).map(([port, mapping]) => ({
+    label: `${port}/${mapping.udp ? "udp" : "tcp"}`,
+    hostPort: mapping.host ?? null
+  }));
+}
+function rootfsHealth(args) {
+  if (!args.manifestState.valid || !args.manifestState.manifest) {
+    return {
+      tone: "error",
+      label: "manifest invalid",
+      detail: args.manifestState.errors[0] ?? "Manifest could not be parsed."
+    };
+  }
+  if (!args.rootfsVerified) {
+    return {
+      tone: "error",
+      label: "not found on Aleph",
+      detail: "The referenced rootfs STORE message is not available yet."
+    };
+  }
+  if (!args.resolution) {
+    return {
+      tone: "caution",
+      label: "verifying rootfs",
+      detail: "The rootfs reference is still being resolved."
+    };
+  }
+  if (args.resolution.messageStatus === "processed") {
+    return {
+      tone: "ok",
+      label: "deployable",
+      detail: args.resolution.gatewayUrl
+    };
+  }
+  if (args.resolution.messageStatus === "pending" && args.resolution.gatewayStatus === "reachable") {
+    return {
+      tone: "caution",
+      label: "pending but reachable",
+      detail: "Gateway probe succeeded even though Aleph still reports pending."
+    };
+  }
+  if (args.resolution.messageStatus === "pending") {
+    return {
+      tone: "caution",
+      label: "pending on Aleph",
+      detail: "Wait until the STORE message is processed."
+    };
+  }
+  return {
+    tone: "error",
+    label: "not deployable",
+    detail: args.resolution.rejectionReason ?? "Aleph rejected the rootfs reference."
+  };
+}
+async function resolveManifest(args) {
+  const pasted = resolveManifestSource({ manifestJson: args.manifestJson });
+  if (pasted) return pasted;
+  return loadRootfsManifest(args.manifestUrl);
+}
+async function inspectInstanceRuntime(args) {
+  const details = {
+    messageStatus: String(args.instance.status ?? (args.instance.confirmed ? "processed" : "unknown")).toLowerCase(),
+    allocationSource: null,
+    crnUrl: null,
+    hostIpv4: null,
+    ipv6: null,
+    vmIpv4: null,
+    webUrl: null,
+    sshCommand: null,
+    mappedPorts: [],
+    execution: null,
+    error: null
+  };
+  if (details.messageStatus !== "processed") {
+    return details;
+  }
+  try {
+    const allocation = await args.client.fetchSchedulerAllocation(args.instance.item_hash) ?? (() => {
+      const nodeHash = args.instance.content?.requirements?.node?.node_hash;
+      const crn = args.crns.find((candidate) => candidate.hash === nodeHash);
+      return nodeHash ? {
+        source: "manual",
+        crnHash: nodeHash,
+        crnUrl: crn?.address ?? null,
+        node: crn ? { url: crn.address } : null,
+        vmIpv6: null,
+        period: null
+      } : null;
+    })();
+    details.allocationSource = allocation?.source ?? null;
+    details.crnUrl = allocation?.crnUrl ?? null;
+    details.ipv6 = allocation?.vmIpv6 ?? null;
+    details.webUrl = await args.client.fetch2n6WebAccessUrl(args.instance.item_hash);
+    if (!allocation?.crnUrl) {
+      return details;
+    }
+    const executionLookup = await args.client.fetchCrnExecutionMap(allocation.crnUrl);
+    const executionPayload = executionLookup.payload?.[args.instance.item_hash];
+    if (!executionPayload) {
+      return details;
+    }
+    const execution = normalizeExecution(executionPayload, allocation.crnUrl);
+    if (!execution.networking.proxy_url && details.webUrl) {
+      execution.networking.proxy_url = details.webUrl;
+    }
+    details.execution = execution;
+    details.hostIpv4 = execution.networking.host_ipv4 ?? execution.networking.ipv4 ?? null;
+    details.ipv6 = execution.networking.ipv6_ip ?? execution.networking.ipv6 ?? details.ipv6;
+    details.vmIpv4 = execution.networking.ipv4_ip ?? null;
+    details.webUrl = execution.networking.proxy_url ?? details.webUrl;
+    details.mappedPorts = mappedPorts(execution);
+    details.sshCommand = buildSshCommand(details.hostIpv4, details.mappedPorts);
+    return details;
+  } catch (error) {
+    return {
+      ...details,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function compatibleCrnsForTier(crns, state) {
+  if (!state.pricingSummary.pricing || !state.pricingSummary.tier) {
+    return [];
+  }
+  const spec = tierSpec(state.pricingSummary.pricing, state.pricingSummary.tier);
+  return filterDeployableCrns(crns, { spec });
+}
+async function pingPeer(libp2p) {
+  if (!libp2p || typeof libp2p !== "object") {
+    return RELAY_PING_IDLE_STATE;
+  }
+  const candidate = libp2p;
+  const peers = candidate.getPeers?.() ?? [];
+  const firstPeer = peers[0];
+  if (!firstPeer) {
+    return {
+      ...RELAY_PING_IDLE_STATE,
+      tone: "caution",
+      error: "No connected relay peers available."
+    };
+  }
+  const sentAt = Date.now();
+  try {
+    const pingFn = candidate.services?.ping?.ping?.bind(candidate.services.ping) ?? candidate.ping?.bind(candidate);
+    if (!pingFn) {
+      return {
+        ...RELAY_PING_IDLE_STATE,
+        tone: "caution",
+        sent: true,
+        lastPeerId: String(firstPeer),
+        lastSentAt: sentAt,
+        error: "libp2p ping service not available."
+      };
+    }
+    const latency = await pingFn(firstPeer);
+    return {
+      tone: "ok",
+      sent: true,
+      received: true,
+      lastPeerId: String(firstPeer),
+      lastLatencyMs: Number(latency),
+      lastSentAt: sentAt,
+      lastReceivedAt: Date.now(),
+      error: null
+    };
+  } catch (error) {
+    return {
+      tone: "error",
+      sent: true,
+      received: false,
+      lastPeerId: String(firstPeer),
+      lastLatencyMs: null,
+      lastSentAt: sentAt,
+      lastReceivedAt: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var SponsorRelayController = class {
+  state;
+  subscribers = /* @__PURE__ */ new Set();
+  client;
+  refreshTimer = null;
+  pingTimer = null;
+  stopWalletWatch = null;
+  props;
+  constructor(props = {}) {
+    this.props = props;
+    this.state = defaultState(props);
+    this.client = createAlephBrowserClient({
+      apiHost: props.apiHost,
+      crnListUrl: props.crnListUrl,
+      schedulerApiHost: props.schedulerApiHost,
+      twoN6ApiHost: props.twoN6ApiHost
+    });
+  }
+  subscribe(subscriber) {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.subscribers.delete(subscriber);
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  emit() {
+    const next = this.state;
+    this.subscribers.forEach((subscriber) => subscriber(next));
+  }
+  patch(patch) {
+    this.state = {
+      ...this.state,
+      ...patch,
+      busy: patch.busy ? { ...this.state.busy, ...patch.busy } : this.state.busy,
+      wallet: patch.wallet ? { ...this.state.wallet, ...patch.wallet } : this.state.wallet,
+      pricingSummary: patch.pricingSummary ? { ...this.state.pricingSummary, ...patch.pricingSummary } : this.state.pricingSummary,
+      relayPing: patch.relayPing ? { ...this.state.relayPing, ...patch.relayPing } : this.state.relayPing
+    };
+    this.emit();
+  }
+  async init() {
+    this.stopWalletWatch = watchWallet(() => {
+      void this.refreshWalletDerivedState();
+    });
+    await this.refresh();
+    this.refreshTimer = setInterval(() => {
+      void this.refresh();
+    }, REFRESH_INTERVAL_MS);
+    this.pingTimer = setInterval(() => {
+      void this.refreshRelayPing();
+    }, RELAY_PING_INTERVAL_MS);
+    await this.refreshRelayPing();
+    this.patch({ ready: true });
+  }
+  destroy() {
+    if (this.refreshTimer) clearInterval(this.refreshTimer);
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    this.stopWalletWatch?.();
+  }
+  setOpen(open) {
+    this.patch({ open });
+  }
+  toggleOpen() {
+    this.patch({ open: !this.state.open });
+  }
+  setManifestUrl(manifestUrl) {
+    this.patch({ manifestUrl });
+  }
+  setManifestJson(manifestJson) {
+    this.patch({ manifestJson });
+  }
+  setShowPasteManifest(showPasteManifest) {
+    this.patch({ showPasteManifest });
+  }
+  setSshPublicKey(sshPublicKey) {
+    this.patch({ sshPublicKey });
+  }
+  setInstanceName(instanceName) {
+    this.patch({ instanceName });
+  }
+  setTierId(tierId) {
+    this.patch({ tierId });
+    this.recomputePricingSummary();
+  }
+  recomputePricingSummary() {
+    const pricing = this.state.pricingSummary.pricing;
+    const tier = pricing?.tiers.find((entry) => entry.id === this.state.tierId) ?? pricing?.tiers[0] ?? null;
+    const balance = this.state.balance;
+    const quote = pricing && tier && balance ? buildPaymentQuote(tier, pricing, balance) : null;
+    const spec = pricing && tier ? tierSpec(pricing, tier) : null;
+    const selectedCrn = compatibleCrnsForTier(this.state.crns, {
+      ...this.state,
+      pricingSummary: {
+        ...this.state.pricingSummary,
+        pricing,
+        tier
+      }
+    })[0] ?? null;
+    this.patch({
+      pricingSummary: {
+        pricing,
+        tier,
+        requiredCredits: quote?.required ?? null,
+        availableCredits: quote?.available ?? balance?.credit_balance ?? null,
+        vcpus: spec?.vcpus ?? null,
+        memoryMiB: spec?.memoryMiB ?? null,
+        diskMiB: spec?.diskMiB ?? null
+      },
+      selectedCrn
+    });
+  }
+  async connectWallet() {
+    this.patch({
+      busy: { connectingWallet: true },
+      errorText: null,
+      statusText: "Connecting MetaMask"
+    });
+    try {
+      const wallet = await connectWallet();
+      this.patch({
+        wallet,
+        busy: { connectingWallet: false },
+        statusText: "Wallet connected"
+      });
+      await this.refresh();
+    } catch (error) {
+      this.patch({
+        busy: { connectingWallet: false },
+        errorText: error instanceof Error ? error.message : String(error),
+        statusText: "Wallet connection failed"
+      });
+    }
+  }
+  async refreshWalletDerivedState() {
+    if (!this.state.wallet.connected) {
+      return;
+    }
+    try {
+      const wallet = await connectWallet();
+      this.patch({ wallet });
+      await this.refresh();
+    } catch {
+      this.patch({
+        wallet: {
+          connected: false,
+          address: null,
+          chainId: null,
+          isMetaMask: false
+        }
+      });
+    }
+  }
+  async refresh() {
+    this.patch({
+      busy: { refreshing: true },
+      errorText: null,
+      statusText: "Refreshing relay sponsor data"
+    });
+    try {
+      const manifestState = await resolveManifest({
+        manifestUrl: this.state.manifestUrl,
+        manifestJson: this.state.manifestJson
+      });
+      const manifest = manifestState.manifest;
+      const [pricingSummary, crns] = await Promise.all([
+        fetchInstancePricing(this.client.apiHost),
+        this.client.fetchCrns()
+      ]);
+      let balance = this.state.balance;
+      let instances = [];
+      if (this.state.wallet.address) {
+        const [nextBalance, rawInstances] = await Promise.all([
+          this.client.fetchBalance(this.state.wallet.address),
+          this.state.showInstances ? this.client.fetchInstances(this.state.wallet.address) : Promise.resolve([])
+        ]);
+        balance = nextBalance;
+        instances = await Promise.all(
+          rawInstances.map(async (instance) => ({
+            instance,
+            details: await inspectInstanceRuntime({
+              client: this.client,
+              instance,
+              crns
+            })
+          }))
+        );
+      }
+      let rootfsVerified = false;
+      let rootfsResolution = null;
+      if (manifestState.valid && manifest) {
+        rootfsVerified = await verifyRootfsExists(manifest.rootfsItemHash, this.client.apiHost);
+        rootfsResolution = await resolveRootfsReference(manifest.rootfsItemHash, this.client.apiHost);
+      }
+      this.patch({
+        manifestState,
+        manifest,
+        rootfsVerified,
+        rootfsResolution,
+        rootfsHealth: rootfsHealth({
+          manifestState,
+          rootfsVerified,
+          resolution: rootfsResolution
+        }),
+        pricingSummary: {
+          ...this.state.pricingSummary,
+          pricing: pricingSummary.pricing
+        },
+        balance,
+        crns,
+        instances,
+        busy: { refreshing: false },
+        statusText: "Relay sponsor data ready"
+      });
+      this.recomputePricingSummary();
+    } catch (error) {
+      this.patch({
+        busy: { refreshing: false },
+        errorText: error instanceof Error ? error.message : String(error),
+        statusText: "Refresh failed"
+      });
+    }
+  }
+  async refreshRelayPing() {
+    const relayPing = await pingPeer(this.props.libp2p);
+    this.patch({ relayPing });
+  }
+  async deploy() {
+    if (!this.state.wallet.address) {
+      this.patch({ errorText: "Connect MetaMask before deploying." });
+      return;
+    }
+    if (!this.state.manifest || !this.state.rootfsVerified || !this.state.pricingSummary.pricing || !this.state.pricingSummary.tier) {
+      this.patch({ errorText: "Manifest, rootfs, and pricing must be ready before deploying." });
+      return;
+    }
+    this.patch({
+      busy: { deploying: true },
+      errorText: null,
+      statusText: "Broadcasting deployment"
+    });
+    try {
+      const spec = tierSpec(this.state.pricingSummary.pricing, this.state.pricingSummary.tier);
+      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
+      });
+      this.patch({
+        busy: { deploying: false },
+        statusText: `Deployment submitted: ${result.itemHash}`,
+        lastDeploymentHash: result.itemHash
+      });
+      await this.refresh();
+    } catch (error) {
+      this.patch({
+        busy: { deploying: false },
+        errorText: error instanceof Error ? error.message : String(error),
+        statusText: "Deployment failed"
+      });
+    }
+  }
+  async deleteInstance(instanceHash) {
+    if (!this.state.wallet.address) {
+      this.patch({ errorText: "Connect MetaMask before deleting instances." });
+      return;
+    }
+    this.patch({
+      busy: { deletingInstanceHash: instanceHash },
+      errorText: null,
+      statusText: `Deleting ${instanceHash}`
+    });
+    try {
+      await forgetAlephMessages({
+        sender: this.state.wallet.address,
+        hashes: [instanceHash],
+        reason: "Deleted from Sponsor Relay panel",
+        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
+      });
+      this.patch({
+        busy: { deletingInstanceHash: null },
+        statusText: `Deletion submitted for ${instanceHash}`
+      });
+      await this.refresh();
+    } catch (error) {
+      this.patch({
+        busy: { deletingInstanceHash: null },
+        errorText: error instanceof Error ? error.message : String(error),
+        statusText: "Delete failed"
+      });
+    }
+  }
+};
+function createSponsorRelayController(props = {}) {
+  return new SponsorRelayController(props);
+}
+export {
+  DEFAULT_INSTANCE_NAME,
+  DEFAULT_MANIFEST_URL,
+  DEFAULT_TIER_ID,
+  REFRESH_INTERVAL_MS,
+  RELAY_PING_IDLE_STATE,
+  RELAY_PING_INTERVAL_MS,
+  ROOTFS_MISSING_STATE,
+  SponsorRelayController,
+  buildSshCommand,
+  connectWallet,
+  createSponsorRelayController,
+  formatDateTime,
+  formatNumber,
+  getEthereumProvider,
+  joinMappedPorts,
+  personalSign,
+  resolveManifestSource,
+  shortHash,
+  watchWallet
+};