@le-space/playwright 0.6.28 → 0.6.30

package/README.md

@@ -17,3 +17,29 @@ import {
 
 `@playwright/test` is a peer dependency. Use a compatible 1.61.x client; remote
 Playwright servers must use the exact same client/server version.
+
+## Aleph remote Chromium
+
+`connectAlephChromium()` is the thin consumer-facing adapter for the dedicated
+Aleph runner. It authenticates the `/version` probe and websocket with the same
+per-run bearer secret, requires HTTPS/WSS, checks the guest is exactly
+Playwright `1.61.1`, and only then calls `chromium.connect()`.
+
+```ts
+const browser = await connectAlephChromium({
+  chromium,
+  wsEndpoint,
+  versionUrl,
+  secret,
+})
+```
+
+`buildAlephCostEvidence()` and `formatAlephCostGithubSummary()` keep required
+credit capacity separate from the authoritative before/after account balance
+delta. A balance delta is attributable to one run only when that deployment
+account is not being used concurrently.
+
+`selectExpiredAlephPlaywrightRunners()` is the safety boundary used by the
+retention janitor. The repository script requires an explicit repository scope
+and owner key, then erases, owner-signs FORGET for, and verifies each selected
+exact INSTANCE hash. It never cleans by display name alone.

package/index.d.ts

@@ -1,8 +1,9 @@
 import * as _playwright_test from '@playwright/test';
-import { Page, Locator, BrowserContext } from '@playwright/test';
+import { Browser, Page, Locator, BrowserContext } from '@playwright/test';
 import { RelayBootstrapPostRecord, RelayBootstrapContent, fetchAlephBootstrapPosts } from '@le-space/aleph-bootstrap';
 import { eraseInstanceOnCrn, forgetAlephMessages } from '@le-space/core';
 
+declare const PLAYWRIGHT_RUNNER_VERSION = "1.61.1";
 declare const SUPPORTED_ALEPH_API_HOSTS: readonly ["https://api2.aleph.im", "https://api.aleph.im"];
 declare const DEFAULT_ALEPH_SCHEDULER_URL = "https://scheduler.api.aleph.cloud";
 interface RelayWalletAccount {
@@ -28,6 +29,63 @@ interface RelayEvidence {
     error?: string;
     [key: string]: unknown;
 }
+interface AlephChromiumConnector {
+    connect(wsEndpoint: string, options?: {
+        headers?: Record<string, string>;
+        timeout?: number;
+    }): Promise<Browser>;
+}
+interface AlephRemoteBrowserOptions {
+    chromium: AlephChromiumConnector;
+    wsEndpoint: string;
+    versionUrl: string;
+    secret: string;
+    expectedVersion?: string;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+}
+interface AlephCreditBalanceSnapshot {
+    capturedAt: string;
+    apiHost: string;
+    creditBalance: number;
+    lockedAmount: number;
+}
+interface AlephPricingSnapshot {
+    capturedAt: string;
+    apiHost: string;
+    unitCredit: number;
+    computeUnits: number;
+    vcpus: number;
+    memoryMiB: number;
+    diskMiB: number;
+}
+interface AlephCostEvidence {
+    paymentType: 'credit';
+    startedAt: string;
+    finishedAt: string;
+    runtimeSeconds: number;
+    pricing: AlephPricingSnapshot;
+    before: AlephCreditBalanceSnapshot;
+    after: AlephCreditBalanceSnapshot;
+    requiredCredits: number;
+    netAccountCreditDelta: number;
+    creditsConsumed: number;
+    creditsReturned: number;
+    accountingNote: string;
+}
+interface AlephRunnerInstanceCandidate {
+    itemHash: string;
+    ownerAddress: string;
+    instanceName: string;
+    createdAt: string;
+    status: string;
+}
+interface AlephRunnerJanitorSelection {
+    expired: AlephRunnerInstanceCandidate[];
+    retained: Array<AlephRunnerInstanceCandidate & {
+        reason: string;
+    }>;
+}
 interface RelayAddressPolicy {
     allowWebTransport?: boolean;
     allowWebRtcDirect?: boolean;
@@ -81,6 +139,8 @@ interface CleanupRelayOptions {
     account: RelayWalletAccount;
     instanceName: string;
     instanceHash: string;
+    /** Guest-published relay-bootstrap POST to verify after graceful VM shutdown. */
+    registrationHash?: string;
     driver?: RelayButtonDriver;
     apiHosts?: readonly string[];
     schedulerUrl?: string;
@@ -99,6 +159,7 @@ interface CleanupRelayResult {
     eraseSummary: string;
     forgetSummary: string;
     verificationSummary: string;
+    registrationVerificationSummary?: string;
 }
 interface CleanupRelayHooks {
     erase?: typeof eraseInstanceOnCrn;
@@ -116,6 +177,22 @@ interface CreateRelayTestOptions {
     cleanup?: Omit<CleanupRelayOptions, 'page' | 'account' | 'instanceName' | 'instanceHash'>;
 }
 declare function resolveAlephApiHosts(candidates?: readonly string[]): string[];
+declare function connectAlephChromium(options: AlephRemoteBrowserOptions): Promise<Browser>;
+declare function buildAlephCostEvidence(options: {
+    startedAt: string;
+    finishedAt: string;
+    pricing: AlephPricingSnapshot;
+    before: AlephCreditBalanceSnapshot;
+    after: AlephCreditBalanceSnapshot;
+}): AlephCostEvidence;
+declare function formatAlephCostGithubSummary(cost: AlephCostEvidence): string;
+declare function selectExpiredAlephPlaywrightRunners(options: {
+    candidates: readonly AlephRunnerInstanceCandidate[];
+    ownerAddress: string;
+    repository: string;
+    now?: number;
+    ttlMs?: number;
+}): AlephRunnerJanitorSelection;
 declare function waitForPubsubSubscriber(page: Page, options: WaitForPubsubSubscriberOptions): Promise<string[]>;
 declare function installEip1193WalletMock(context: BrowserContext, account: RelayWalletAccount): Promise<void>;
 declare class RelayButtonDriver {
@@ -163,6 +240,13 @@ declare function waitForAlephInstanceDeletion(options: {
     pollIntervalMs?: number;
     fetch?: typeof fetch;
 }): Promise<string>;
+declare function waitForAlephMessageForgotten(options: {
+    messageHash: string;
+    apiHosts?: readonly string[];
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    fetch?: typeof fetch;
+}): Promise<string>;
 declare function cleanupRelay(options: CleanupRelayOptions): Promise<CleanupRelayResult>;
 declare function createRelayEvidence(options: {
     instanceName: string;
@@ -181,4 +265,4 @@ declare function createRelayTest(options: CreateRelayTestOptions): _playwright_t
     relayLifecycle: RelayLifecycleFixture;
 }, _playwright_test.PlaywrightWorkerArgs & _playwright_test.PlaywrightWorkerOptions>;
 
-export { type CleanupRelayHooks, type CleanupRelayOptions, type CleanupRelayResult, type CreateRelayTestOptions, DEFAULT_ALEPH_SCHEDULER_URL, type ProvisionRelayOptions, type ProvisionedRelay, type RelayAddressPolicy, RelayButtonDriver, type RelayButtonDriverOptions, type RelayEvidence, type RelayEvidenceStep, type RelayLifecycleFixture, type RelayWalletAccount, SUPPORTED_ALEPH_API_HOSTS, type WaitForPubsubSubscriberOptions, appendRelayGithubSummary, cleanupRelay, createRelayEvidence, createRelayTest, findAlephInstanceHash, formatRelayGithubSummary, installEip1193WalletMock, provisionRelay, resolveAlephApiHosts, selectBrowserRelayAddresses, updateRelayEvidenceStep, waitForAlephInstanceDeletion, waitForBootstrapRegistration, waitForDeployableManifest, waitForPubsubSubscriber, writeRelayEvidence };
+export { type AlephChromiumConnector, type AlephCostEvidence, type AlephCreditBalanceSnapshot, type AlephPricingSnapshot, type AlephRemoteBrowserOptions, type AlephRunnerInstanceCandidate, type AlephRunnerJanitorSelection, type CleanupRelayHooks, type CleanupRelayOptions, type CleanupRelayResult, type CreateRelayTestOptions, DEFAULT_ALEPH_SCHEDULER_URL, PLAYWRIGHT_RUNNER_VERSION, type ProvisionRelayOptions, type ProvisionedRelay, type RelayAddressPolicy, RelayButtonDriver, type RelayButtonDriverOptions, type RelayEvidence, type RelayEvidenceStep, type RelayLifecycleFixture, type RelayWalletAccount, SUPPORTED_ALEPH_API_HOSTS, type WaitForPubsubSubscriberOptions, appendRelayGithubSummary, buildAlephCostEvidence, cleanupRelay, connectAlephChromium, createRelayEvidence, createRelayTest, findAlephInstanceHash, formatAlephCostGithubSummary, formatRelayGithubSummary, installEip1193WalletMock, provisionRelay, resolveAlephApiHosts, selectBrowserRelayAddresses, selectExpiredAlephPlaywrightRunners, updateRelayEvidenceStep, waitForAlephInstanceDeletion, waitForAlephMessageForgotten, waitForBootstrapRegistration, waitForDeployableManifest, waitForPubsubSubscriber, writeRelayEvidence };

package/index.js

@@ -2,17 +2,11 @@
 import { createHash } from "crypto";
 import { appendFile, mkdir, writeFile } from "fs/promises";
 import { dirname } from "path";
-import {
-  fetchAlephBootstrapPosts
-} from "@le-space/aleph-bootstrap";
+import { fetchAlephBootstrapPosts } from "@le-space/aleph-bootstrap";
 import { eraseInstanceOnCrn, forgetAlephMessages } from "@le-space/core";
-import {
-  test as playwrightTest
-} from "@playwright/test";
-var SUPPORTED_ALEPH_API_HOSTS = [
-  "https://api2.aleph.im",
-  "https://api.aleph.im"
-];
+import { test as playwrightTest } from "@playwright/test";
+var PLAYWRIGHT_RUNNER_VERSION = "1.61.1";
+var SUPPORTED_ALEPH_API_HOSTS = ["https://api2.aleph.im", "https://api.aleph.im"];
 var DEFAULT_ALEPH_SCHEDULER_URL = "https://scheduler.api.aleph.cloud";
 var API3_HOST_PATTERN = /(^|\.)api3\.aleph\.im$/iu;
 function normalizeApiOrigin(value) {
@@ -25,12 +19,118 @@ function normalizeApiOrigin(value) {
   }
 }
 function resolveAlephApiHosts(candidates) {
-  const allowed = new Set(
-    (candidates ?? SUPPORTED_ALEPH_API_HOSTS).map(normalizeApiOrigin).filter((value) => value != null)
-  );
+  const allowed = new Set((candidates ?? SUPPORTED_ALEPH_API_HOSTS).map(normalizeApiOrigin).filter((value) => value != null));
   const selected = SUPPORTED_ALEPH_API_HOSTS.filter((host) => allowed.has(host));
   return selected.length > 0 ? [...selected] : [...SUPPORTED_ALEPH_API_HOSTS];
 }
+function requireFiniteNumber(value, label) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) throw new Error(`${label} must be a finite number`);
+  return number;
+}
+async function connectAlephChromium(options) {
+  const expectedVersion = options.expectedVersion ?? PLAYWRIGHT_RUNNER_VERSION;
+  const secret = options.secret.trim();
+  if (!secret) throw new Error("Aleph Playwright secret is required");
+  if (!options.wsEndpoint.startsWith("wss://")) {
+    throw new Error("Aleph Playwright endpoint must use authenticated WSS");
+  }
+  if (!options.versionUrl.startsWith("https://")) {
+    throw new Error("Aleph Playwright version endpoint must use HTTPS");
+  }
+  const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchImpl) throw new Error("A fetch implementation is required for version verification");
+  const authorization = `Bearer ${secret}`;
+  const response = await fetchImpl(options.versionUrl, {
+    headers: { Authorization: authorization },
+    cache: "no-store",
+    signal: AbortSignal.timeout(options.timeoutMs ?? 3e4)
+  });
+  if (!response.ok) {
+    throw new Error(`Aleph Playwright version endpoint returned HTTP ${response.status}`);
+  }
+  const payload = await response.json();
+  const actualVersion = String(payload.playwrightVersion ?? "");
+  if (actualVersion !== expectedVersion) {
+    throw new Error(`Playwright client/server version mismatch: client ${expectedVersion}, guest ${actualVersion || "unknown"}`);
+  }
+  return options.chromium.connect(options.wsEndpoint, {
+    headers: { Authorization: authorization },
+    timeout: options.timeoutMs ?? 3e4
+  });
+}
+function buildAlephCostEvidence(options) {
+  const startedAtMs = Date.parse(options.startedAt);
+  const finishedAtMs = Date.parse(options.finishedAt);
+  if (!Number.isFinite(startedAtMs) || !Number.isFinite(finishedAtMs) || finishedAtMs < startedAtMs) {
+    throw new Error("Aleph cost evidence requires ordered ISO start/finish timestamps");
+  }
+  const unitCredit = requireFiniteNumber(options.pricing.unitCredit, "unitCredit");
+  const computeUnits = requireFiniteNumber(options.pricing.computeUnits, "computeUnits");
+  const beforeCredits = requireFiniteNumber(options.before.creditBalance, "before.creditBalance");
+  const afterCredits = requireFiniteNumber(options.after.creditBalance, "after.creditBalance");
+  const netAccountCreditDelta = afterCredits - beforeCredits;
+  return {
+    paymentType: "credit",
+    startedAt: options.startedAt,
+    finishedAt: options.finishedAt,
+    runtimeSeconds: Math.ceil((finishedAtMs - startedAtMs) / 1e3),
+    pricing: options.pricing,
+    before: options.before,
+    after: options.after,
+    requiredCredits: unitCredit * computeUnits,
+    netAccountCreditDelta,
+    creditsConsumed: Math.max(0, -netAccountCreditDelta),
+    creditsReturned: Math.max(0, netAccountCreditDelta),
+    accountingNote: "Required credits are Aleph credit-payment capacity, not a time-pro-rated charge. The balance delta is the authoritative account observation for this interval and is attributable to this test only when the deployment account is not used concurrently."
+  };
+}
+function formatAlephCostGithubSummary(cost) {
+  return `## Aleph remote browser cost
+
+| Field | Value |
+| --- | ---: |
+| Payment type | ${cost.paymentType} |
+| Runtime | ${cost.runtimeSeconds} s |
+| Hardware | ${cost.pricing.vcpus} vCPU \xB7 ${cost.pricing.memoryMiB} MiB RAM \xB7 ${cost.pricing.diskMiB} MiB disk |
+| Compute units | ${cost.pricing.computeUnits} |
+| Unit credit requirement | ${cost.pricing.unitCredit} credits |
+| Required credit capacity | ${cost.requiredCredits} credits |
+| Balance before | ${cost.before.creditBalance} credits |
+| Balance after cleanup | ${cost.after.creditBalance} credits |
+| Net account delta | ${cost.netAccountCreditDelta} credits |
+| Credits consumed | ${cost.creditsConsumed} credits |
+| Credits returned | ${cost.creditsReturned} credits |
+
+Pricing source: \`${cost.pricing.apiHost}\` at ${cost.pricing.capturedAt}. Balance sources: \`${cost.before.apiHost}\` and \`${cost.after.apiHost}\`.
+
+> ${cost.accountingNote}
+`;
+}
+function selectExpiredAlephPlaywrightRunners(options) {
+  const owner = options.ownerAddress.trim().toLowerCase();
+  const repository = options.repository.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-");
+  if (!/^0x[a-f0-9]{40}$/u.test(owner)) throw new Error("Janitor requires an exact EVM owner address");
+  if (!repository) throw new Error("Janitor requires a repository name");
+  const prefix = `playwright-${repository}-`;
+  const now = options.now ?? Date.now();
+  const ttlMs = options.ttlMs ?? 60 * 6e4;
+  if (!Number.isFinite(ttlMs) || ttlMs < 15 * 6e4) throw new Error("Janitor TTL must be at least 15 minutes");
+  const selection = { expired: [], retained: [] };
+  for (const candidate of options.candidates) {
+    let reason = "";
+    const createdAt = Date.parse(candidate.createdAt);
+    if (!/^[a-f0-9]{64}$/iu.test(candidate.itemHash)) reason = "invalid exact INSTANCE hash";
+    else if (candidate.ownerAddress.toLowerCase() !== owner) reason = "different owner";
+    else if (!candidate.instanceName.toLowerCase().startsWith(prefix)) reason = "name outside repository scope";
+    else if (!Number.isFinite(createdAt)) reason = "invalid creation timestamp";
+    else if (now - createdAt < ttlMs) reason = "within TTL";
+    else if (!["processed", "pending"].includes(candidate.status.toLowerCase())) reason = `terminal status ${candidate.status}`;
+    if (reason) selection.retained.push({ ...candidate, reason });
+    else selection.expired.push(candidate);
+  }
+  return selection;
+}
 async function waitForPubsubSubscriber(page, options) {
   const timeoutMs = options.timeoutMs ?? 3e4;
   const pollIntervalMs = options.pollIntervalMs ?? 250;
@@ -72,13 +172,13 @@ async function installEip1193WalletMock(context, account) {
       case "eth_chainId":
         return "0x1";
       case "personal_sign": {
-        const payload = params.find(
-          (value) => typeof value === "string" && value.startsWith("0x") && value.toLowerCase() !== account.address.toLowerCase()
-        );
+        const payload = params.find((value) => typeof value === "string" && value.startsWith("0x") && value.toLowerCase() !== account.address.toLowerCase());
         if (typeof payload !== "string") {
           throw new Error("personal_sign did not contain a payload");
         }
-        return account.signMessage({ message: { raw: payload } });
+        return account.signMessage({
+          message: { raw: payload }
+        });
       }
       default:
         throw new Error(`Unsupported E2E wallet method: ${method ?? "missing"}`);
@@ -119,19 +219,26 @@ var RelayButtonDriver = class {
     };
   }
   deployButton() {
-    return this.page.getByRole("button", { name: this.options.deployButtonName });
+    return this.page.getByRole("button", {
+      name: this.options.deployButtonName
+    });
   }
   instance(instanceName) {
     return this.page.locator("details").filter({ hasText: instanceName }).first();
   }
   async prepare(options) {
-    const launcher = this.page.getByRole("button", { name: this.options.launcherName });
+    const launcher = this.page.getByRole("button", {
+      name: this.options.launcherName
+    });
     await launcher.waitFor({ state: "visible", timeout: 6e4 });
     await launcher.click();
     await this.page.getByPlaceholder(this.options.instanceNamePlaceholder).fill(options.instanceName);
     await this.page.getByText("Advanced", { exact: true }).click();
     await this.page.getByPlaceholder(this.options.sshPublicKeyPlaceholder).fill(options.sshPublicKey);
-    await this.page.getByRole("button", { name: this.options.connectWalletName, exact: true }).click();
+    await this.page.getByRole("button", {
+      name: this.options.connectWalletName,
+      exact: true
+    }).click();
   }
   async requestDelete(instanceName) {
     await this.page.getByRole("button", { name: this.options.refreshButtonName }).click().catch(() => {
@@ -154,9 +261,7 @@ async function waitForDeployableManifest(page, options = {}) {
       const panelText = document.querySelector("aside")?.textContent ?? document.body.textContent ?? "";
       const failure = states.find((state) => panelText.includes(state));
       if (failure) return { status: "error", message: failure };
-      const deployButton = [...document.querySelectorAll("button")].find(
-        (button) => button.textContent?.trim() === "Deploy Relay"
-      );
+      const deployButton = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Deploy Relay");
       return deployButton && !deployButton.disabled ? { status: "ready" } : null;
     },
     { states: terminalStates },
@@ -164,18 +269,14 @@ async function waitForDeployableManifest(page, options = {}) {
   );
   const result = await outcome.jsonValue();
   if (result?.status === "error") {
-    throw new Error(
-      `Relay Button manifest is not deployable: ${result.message}. Republish the rootfs and update the manifest before provisioning.`
-    );
+    throw new Error(`Relay Button manifest is not deployable: ${result.message}. Republish the rootfs and update the manifest before provisioning.`);
   }
 }
 async function waitForDeploymentUi(page, instanceName, timeoutMs) {
   const outcome = await page.waitForFunction(
     (expectedName) => {
       const instance = [...document.querySelectorAll("details")].find(
-        (element) => element.textContent?.includes(expectedName) && [...element.querySelectorAll("button")].some(
-          (button) => button.textContent?.trim() === "Delete"
-        )
+        (element) => element.textContent?.includes(expectedName) && [...element.querySelectorAll("button")].some((button) => button.textContent?.trim() === "Delete")
       );
       if (instance?.textContent?.includes("Aleph bootstrap registered")) {
         return { status: "instance" };
@@ -183,9 +284,7 @@ async function waitForDeploymentUi(page, instanceName, timeoutMs) {
       const error = document.querySelector("aside.panel .alert.error")?.textContent?.trim();
       if (error) return { status: "error", message: error };
       const panelText = document.querySelector("aside")?.textContent ?? "";
-      const deployButton = [...document.querySelectorAll("button")].find(
-        (button) => button.textContent?.includes("Deploy")
-      );
+      const deployButton = [...document.querySelectorAll("button")].find((button) => button.textContent?.includes("Deploy"));
       if (panelText.includes("Deployment failed") && !deployButton?.textContent?.includes("Deploying")) {
         return { status: "error", message: panelText };
       }
@@ -310,7 +409,9 @@ async function provisionRelay(page, options) {
     instanceName: options.instanceName,
     sshPublicKey: options.sshPublicKey
   });
-  await waitForDeployableManifest(page, { timeoutMs: options.manifestTimeoutMs });
+  await waitForDeployableManifest(page, {
+    timeoutMs: options.manifestTimeoutMs
+  });
   options.onPhase?.("wallet-and-manifest-ready");
   await driver.deployButton().click();
   options.onDeploymentSubmitted?.();
@@ -356,20 +457,14 @@ async function waitForAlephInstanceDeletion(options) {
   if (!fetchImpl) throw new Error("A fetch implementation is required for cleanup verification");
   const deadline = Date.now() + (options.timeoutMs ?? 5 * 6e4);
   const hosts = resolveAlephApiHosts(options.apiHosts);
-  const schedulerUrl = new URL(
-    `/api/v0/allocation/${options.instanceHash}`,
-    options.schedulerUrl ?? DEFAULT_ALEPH_SCHEDULER_URL
-  );
+  const schedulerUrl = new URL(`/api/v0/allocation/${options.instanceHash}`, options.schedulerUrl ?? DEFAULT_ALEPH_SCHEDULER_URL);
   let lastSummary = "Deletion has not been observed yet.";
   while (Date.now() < deadline) {
     const observations = [];
     let replicasForgotten = true;
     for (const apiHost of hosts) {
       try {
-        const response = await fetchImpl(
-          new URL(`/api/v0/messages/${options.instanceHash}`, apiHost),
-          { cache: "no-cache" }
-        );
+        const response = await fetchImpl(new URL(`/api/v0/messages/${options.instanceHash}`, apiHost), { cache: "no-cache" });
         const payload = await response.json().catch(() => null);
         const forgotten = payload?.status === "forgotten" || Boolean(payload?.forgotten_by?.length);
         replicasForgotten &&= forgotten;
@@ -392,8 +487,35 @@ async function waitForAlephInstanceDeletion(options) {
     if (replicasForgotten && unallocated) return lastSummary;
     await delay(options.pollIntervalMs ?? 2e3);
   }
+  throw new Error(`Aleph INSTANCE ${options.instanceHash} was not deleted within ${options.timeoutMs ?? 5 * 6e4}ms: ${lastSummary}`);
+}
+async function waitForAlephMessageForgotten(options) {
+  const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+  if (!fetchImpl) throw new Error("A fetch implementation is required for cleanup verification");
+  const hosts = resolveAlephApiHosts(options.apiHosts);
+  const deadline = Date.now() + (options.timeoutMs ?? 2 * 6e4);
+  let lastSummary = "Bootstrap deregistration has not been observed yet.";
+  while (Date.now() < deadline) {
+    let forgottenOnAllReplicas = true;
+    const observations = [];
+    for (const apiHost of hosts) {
+      try {
+        const response = await fetchImpl(new URL(`/api/v0/messages/${options.messageHash}`, apiHost), { cache: "no-cache" });
+        const payload = await response.json().catch(() => null);
+        const forgotten = payload?.status === "forgotten" || Boolean(payload?.forgotten_by?.length);
+        forgottenOnAllReplicas &&= forgotten;
+        observations.push(`${apiHost}: ${forgotten ? "forgotten" : payload?.status ?? `HTTP ${response.status}`}`);
+      } catch (error) {
+        forgottenOnAllReplicas = false;
+        observations.push(`${apiHost}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    lastSummary = observations.join("; ");
+    if (forgottenOnAllReplicas) return lastSummary;
+    await delay(options.pollIntervalMs ?? 2e3);
+  }
   throw new Error(
-    `Aleph INSTANCE ${options.instanceHash} was not deleted within ${options.timeoutMs ?? 5 * 6e4}ms: ${lastSummary}`
+    `Aleph bootstrap registration ${options.messageHash} was not deregistered within ${options.timeoutMs ?? 2 * 6e4}ms: ${lastSummary}`
   );
 }
 async function cleanupRelay(options) {
@@ -423,13 +545,21 @@ async function cleanupRelay(options) {
         pollIntervalMs: options.pollIntervalMs,
         fetch: fetchImpl
       });
+      const registrationVerificationSummary2 = options.registrationHash ? await waitForAlephMessageForgotten({
+        messageHash: options.registrationHash,
+        apiHosts: hosts,
+        timeoutMs: options.timeoutMs,
+        pollIntervalMs: options.pollIntervalMs,
+        fetch: fetchImpl
+      }) : void 0;
       return {
         instanceHash: options.instanceHash,
         uiDeleteRequested,
         fallbackUsed: false,
         eraseSummary: "Relay Button UI requested runtime erase",
         forgetSummary: "Relay Button UI submitted FORGET",
-        verificationSummary: verificationSummary2
+        verificationSummary: verificationSummary2,
+        registrationVerificationSummary: registrationVerificationSummary2
       };
     } catch {
     }
@@ -491,13 +621,21 @@ async function cleanupRelay(options) {
     pollIntervalMs: options.pollIntervalMs,
     fetch: fetchImpl
   });
+  const registrationVerificationSummary = options.registrationHash ? await waitForAlephMessageForgotten({
+    messageHash: options.registrationHash,
+    apiHosts: hosts,
+    timeoutMs: options.timeoutMs,
+    pollIntervalMs: options.pollIntervalMs,
+    fetch: fetchImpl
+  }) : void 0;
   return {
     instanceHash: options.instanceHash,
     uiDeleteRequested,
     fallbackUsed: true,
     eraseSummary,
     forgetSummary,
-    verificationSummary
+    verificationSummary,
+    registrationVerificationSummary
   };
 }
 function createRelayEvidence(options) {
@@ -505,12 +643,7 @@ function createRelayEvidence(options) {
     instanceName: options.instanceName,
     ownerAddress: options.ownerAddress,
     startedAt: new Date(options.startedAt ?? Date.now()).toISOString(),
-    steps: Object.fromEntries(
-      Object.entries(options.steps).map(([key, label]) => [
-        key,
-        { label, status: "pending" }
-      ])
-    )
+    steps: Object.fromEntries(Object.entries(options.steps).map(([key, label]) => [key, { label, status: "pending" }]))
   };
 }
 function updateRelayEvidenceStep(evidence, step, status, detail = "") {
@@ -617,6 +750,7 @@ function createRelayTest(options) {
                   account: options.account,
                   instanceName: relay.instanceName,
                   instanceHash: relay.instanceHash,
+                  registrationHash: relay.registration.itemHash ?? relay.registration.hash ?? void 0,
                   driver: relay.driver
                 })
               );
@@ -638,20 +772,26 @@ function createRelayTest(options) {
 }
 export {
   DEFAULT_ALEPH_SCHEDULER_URL,
+  PLAYWRIGHT_RUNNER_VERSION,
   RelayButtonDriver,
   SUPPORTED_ALEPH_API_HOSTS,
   appendRelayGithubSummary,
+  buildAlephCostEvidence,
   cleanupRelay,
+  connectAlephChromium,
   createRelayEvidence,
   createRelayTest,
   findAlephInstanceHash,
+  formatAlephCostGithubSummary,
   formatRelayGithubSummary,
   installEip1193WalletMock,
   provisionRelay,
   resolveAlephApiHosts,
   selectBrowserRelayAddresses,
+  selectExpiredAlephPlaywrightRunners,
   updateRelayEvidenceStep,
   waitForAlephInstanceDeletion,
+  waitForAlephMessageForgotten,
   waitForBootstrapRegistration,
   waitForDeployableManifest,
   waitForPubsubSubscriber,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/playwright",
-  "version": "0.6.28",
+  "version": "0.6.30",
   "description": "Reusable Playwright fixtures and Relay Button lifecycle helpers.",
   "license": "MIT",
   "type": "module",
@@ -24,8 +24,8 @@
     "url": "https://github.com/NiKrause/relay-button/issues"
   },
   "dependencies": {
-    "@le-space/aleph-bootstrap": "0.6.28",
-    "@le-space/core": "0.6.28"
+    "@le-space/aleph-bootstrap": "0.6.30",
+    "@le-space/core": "0.6.30"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.61.1 <1.62.0"