@deeeed/metamask-harness 0.34.0 → 0.34.2

package/library/actions/mobile/perps/perps.mjs

@@ -1,11 +1,92 @@
 import { pathToFileURL } from 'node:url';
-import { evalAsync, navigate, runAdapter } from '../platform/bridge.mjs';
+import {
+  bridgeCommand,
+  evalAsync,
+  navigate,
+  runAdapter,
+} from '../platform/bridge.mjs';
 import { ensureUnlocked } from '../wallet/ensure_unlocked.mjs';
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+export async function measureHomepageVisible(input) {
+  const wallet = await ensureUnlocked({
+    ...input,
+    action: 'metamask.wallet.ensure_unlocked',
+  });
+  const timeoutMs = Math.max(1, Number(input.node?.timeout_ms ?? 30_000));
+  const targetTestId = input.node?.target_test_id;
+  const targetText = input.node?.target_text;
+  if (Number(Boolean(targetTestId)) + Number(Boolean(targetText)) !== 1) {
+    throw new Error(
+      'metamask.perps.measure_homepage_visible requires exactly one target_test_id or target_text.',
+    );
+  }
+
+  const options = {
+    animated: input.node?.animated === true,
+    fromTestId: input.node?.from_test_id ?? 'wallet-screen',
+    offset: Number(input.node?.offset ?? 600),
+    pollIntervalMs: Number(input.node?.poll_interval_ms ?? 100),
+    requireWalletReady: true,
+    timeoutMs,
+    scrollTestId: input.node?.scroll_test_id ?? 'wallet-screen',
+    ...(targetTestId ? { targetTestId } : { targetText }),
+    ...(input.node?.required_present_test_id
+      ? { requiredPresentTestId: input.node.required_present_test_id }
+      : {}),
+    ...(input.node?.visible_event_stage
+      ? { visibleEventStage: input.node.visible_event_stage }
+      : {}),
+    ...(input.node?.visible_event_grace_ms !== undefined
+      ? { visibleEventGraceMs: Number(input.node.visible_event_grace_ms) }
+      : {}),
+  };
+  const measurement = await bridgeCommand(
+    {
+      ...input,
+      node: {
+        ...input.node,
+        bridge_timeout_ms: timeoutMs + 15_000,
+        cdp_timeout_ms: timeoutMs + 15_000,
+      },
+    },
+    ['measure-scroll-transition', JSON.stringify(options)],
+  );
+  if (measurement?.ok !== true) {
+    throw new Error(
+      `metamask.perps.measure_homepage_visible failed: ${String(measurement?.error ?? 'unknown measurement error')}; measurement=${JSON.stringify(measurement)}.`,
+    );
+  }
+  return {
+    action: input.action,
+    wallet,
+    measurement,
+    proofPath: 'direct-cdp-wallet-ready-to-visible',
+  };
+}
+
+export async function retryPerpsClientRead(
+  read,
+  { timeoutMs = 20000, intervalMs = 500, sleep: wait = sleep } = {},
+) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      return await read();
+    } catch (error) {
+      if (!/CLIENT_NOT_INITIALIZED/u.test(String(error?.message ?? error))) {
+        throw error;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) throw error;
+      await wait(Math.min(intervalMs, remainingMs));
+    }
+  }
+}
+
 function marketSymbol(input) {
   return normalizeMarketSymbol(input.node?.market ?? input.node?.symbol ?? 'BTC');
 }
@@ -104,54 +185,155 @@ function uniqueSymbols(symbols) {
 }
 
 async function readPositions(input) {
-  const positions = await evalAsync(
-    input,
-    `(function(){
-      var controller = Engine && Engine.context && Engine.context.PerpsController;
-      if (!controller || typeof controller.getPositions !== 'function') {
-        throw new Error('Engine.context.PerpsController.getPositions is unavailable; cannot assert live Perps positions.');
+  return retryPerpsClientRead(
+    async () => {
+      const positions = await evalAsync(
+        input,
+        `(function(){
+          var controller = Engine && Engine.context && Engine.context.PerpsController;
+          if (!controller || typeof controller.getPositions !== 'function') {
+            throw new Error('Engine.context.PerpsController.getPositions is unavailable; cannot assert live Perps positions.');
+          }
+          return controller.getPositions().then(function(r){
+            if (!Array.isArray(r)) throw new Error('PerpsController.getPositions returned a non-array result.');
+            return JSON.stringify(r);
+          });
+        })()`,
+      );
+      if (!Array.isArray(positions)) {
+        throw new Error(
+          'PerpsController.getPositions returned a non-array result.',
+        );
       }
-      return controller.getPositions().then(function(r){
-        if (!Array.isArray(r)) throw new Error('PerpsController.getPositions returned a non-array result.');
-        return JSON.stringify(r);
-      });
-    })()`,
+      return positions;
+    },
   );
-  if (!Array.isArray(positions)) throw new Error('PerpsController.getPositions returned a non-array result.');
-  return positions;
 }
 
 async function readOpenOrders(input) {
-  const orders = await evalAsync(
-    input,
-    `(function(){
-      var controller = Engine && Engine.context && Engine.context.PerpsController;
-      if (!controller || typeof controller.getOpenOrders !== 'function') {
-        throw new Error('Engine.context.PerpsController.getOpenOrders is unavailable; cannot assert live Perps orders.');
+  return retryPerpsClientRead(
+    async () => {
+      const orders = await evalAsync(
+        input,
+        `(function(){
+          var controller = Engine && Engine.context && Engine.context.PerpsController;
+          if (!controller || typeof controller.getOpenOrders !== 'function') {
+            throw new Error('Engine.context.PerpsController.getOpenOrders is unavailable; cannot assert live Perps orders.');
+          }
+          return controller.getOpenOrders().then(function(r){
+            if (!Array.isArray(r)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
+            return JSON.stringify(r);
+          });
+        })()`,
+      );
+      if (!Array.isArray(orders)) {
+        throw new Error(
+          'PerpsController.getOpenOrders returned a non-array result.',
+        );
       }
-      return controller.getOpenOrders().then(function(r){
-        if (!Array.isArray(r)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
-        return JSON.stringify(r);
-      });
-    })()`,
+      return orders;
+    },
   );
-  if (!Array.isArray(orders)) throw new Error('PerpsController.getOpenOrders returned a non-array result.');
-  return orders;
 }
 
-async function clearPerformanceCaches(input) {
-  return evalAsync(
-    input,
-    `(function(){
-      var bridge = globalThis.__AGENTIC__;
-      if (!bridge || typeof bridge.clearPerpsPerformanceCaches !== 'function') {
-        throw new Error('__AGENTIC__.clearPerpsPerformanceCaches is unavailable; reload the current Mobile development source.');
+export function clearPerformanceCachesExpression() {
+  return `(function(){
+      var metroRequire = globalThis.__r;
+      if (typeof metroRequire !== 'function' || typeof metroRequire.getModules !== 'function') {
+        throw new Error('Metro module registry is unavailable; cannot clear Perps performance caches through CDP.');
       }
-      return Promise.resolve(bridge.clearPerpsPerformanceCaches()).then(function(result){
-        return JSON.stringify(result);
+      var storageModuleId = null;
+      var perpsConfigModuleId = null;
+      var streamManagerModuleId = null;
+      metroRequire.getModules().forEach(function(module, moduleId){
+        var name = String(module && module.verboseName || '');
+        if (name === 'app/store/storage-wrapper.ts' || name.endsWith('/app/store/storage-wrapper.ts')) {
+          storageModuleId = moduleId;
+        }
+        if (name.includes('@metamask/perps-controller') && name.includes('/constants/perpsConfig.')) {
+          perpsConfigModuleId = moduleId;
+        }
+        if (name === 'app/components/UI/Perps/providers/PerpsStreamManager.tsx' || name.endsWith('/app/components/UI/Perps/providers/PerpsStreamManager.tsx')) {
+          streamManagerModuleId = moduleId;
+        }
       });
-    })()`,
-  );
+      if (storageModuleId === null || perpsConfigModuleId === null || streamManagerModuleId === null) {
+        throw new Error('Required Mobile storage, Perps constants, or stream manager module is unavailable in Metro.');
+      }
+      var storageExports = metroRequire(storageModuleId);
+      var storage = storageExports && (storageExports.default || storageExports);
+      var perpsConfig = metroRequire(perpsConfigModuleId);
+      var streamManagerExports = metroRequire(streamManagerModuleId);
+      var getStreamManager = streamManagerExports && streamManagerExports.getStreamManagerInstance;
+      var streamManager = typeof getStreamManager === 'function' ? getStreamManager() : null;
+      var keys = [
+        perpsConfig.PERPS_DISK_CACHE_MARKETS,
+        perpsConfig.PERPS_DISK_CACHE_USER_DATA,
+      ];
+      if (!storage || typeof storage.removeItem !== 'function' || typeof storage.getItem !== 'function' || keys.some(function(key){ return typeof key !== 'string' || key.length === 0; })) {
+        throw new Error('Resolved Mobile storage or Perps cache constants are invalid.');
+      }
+      if (!streamManager) {
+        throw new Error('Resolved Mobile Perps stream manager is invalid.');
+      }
+      var engine = globalThis.Engine;
+      var controller = engine && engine.context && engine.context.PerpsController;
+      if (!controller || typeof controller.update !== 'function' || !controller.state) {
+        throw new Error('Engine.context.PerpsController cache state is unavailable.');
+      }
+      var marketEntries = Object.keys(controller.state.cachedMarketDataByProvider || {}).length;
+      var userEntries = Object.keys(controller.state.cachedUserDataByProvider || {}).length;
+      var channelNames = ['marketData', 'positions', 'orders', 'account'];
+      var quiesceChannels = function(){
+        channelNames.forEach(function(name){
+          var channel = streamManager[name];
+          if (!channel || typeof channel.disconnect !== 'function' || typeof channel.clearCache !== 'function') {
+            throw new Error('Perps stream channel ' + name + ' cannot be quiesced.');
+          }
+          channel.disconnect();
+        });
+      };
+      quiesceChannels();
+      if (typeof controller.stopMarketDataPreload === 'function') {
+        controller.stopMarketDataPreload();
+      }
+      var pendingOperations = [
+        streamManager.marketData && streamManager.marketData.fetchPromise,
+        streamManager.userDataSnapshotPromise,
+      ].filter(function(value){ return value && typeof value.then === 'function'; });
+      return Promise.allSettled(pendingOperations).then(function(){
+        quiesceChannels();
+        channelNames.forEach(function(name){ streamManager[name].clearCache(); });
+        controller.update(function(state){
+          state.cachedMarketDataByProvider = {};
+          state.cachedUserDataByProvider = {};
+        });
+        return Promise.all(keys.map(function(key){ return storage.removeItem(key); }));
+      }).then(function(){
+        return new Promise(function(resolve){ setTimeout(resolve, 250); });
+      }).then(function(){
+        return Promise.all(keys.map(function(key){ return storage.getItem(key); }));
+      }).then(function(values){
+        var remainingKeys = keys.filter(function(_key, index){ return values[index] !== null && values[index] !== undefined; });
+        if (remainingKeys.length > 0) {
+          throw new Error('Perps performance cache repopulated after clear: ' + remainingKeys.join(', '));
+        }
+        return JSON.stringify({
+          ok: true,
+          method: 'metro-cdp',
+          clearedStorageKeys: keys,
+          clearedControllerMarketEntries: marketEntries,
+          clearedControllerUserEntries: userEntries,
+          quiescedChannels: channelNames,
+          awaitedPendingOperations: pendingOperations.length,
+          storageVerifiedAbsent: true,
+        });
+      });
+    })()`;
+}
+
+async function clearPerformanceCaches(input) {
+  return evalAsync(input, clearPerformanceCachesExpression());
 }
 
 async function waitForPositionsAbsent(input, symbols, timeoutMs = 30000) {
@@ -846,6 +1028,7 @@ const DIRECT_ACTIONS = new Map([
   ['metamask.perps.ensure_positions', ensurePositions],
   ['metamask.perps.ensure_orders', ensureOrders],
   ['metamask.perps.clear_performance_caches', clearPerformanceCaches],
+  ['metamask.perps.measure_homepage_visible', measureHomepageVisible],
   ['metamask.perps.start_state', startState],
   ['metamask.perps.teardown_state', teardownState],
 ]);

package/library/actions/mobile/perps/prepare_local_snapshot_endpoint.mjs

@@ -0,0 +1,58 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import { runAdapter } from '../platform/bridge.mjs';
+import { resolveMobileToolPath } from '../platform/tool-paths.mjs';
+
+const execFileAsync = promisify(execFile);
+
+async function prepareLocalSnapshotEndpoint(input) {
+  const port = Number(input.node?.port);
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error(
+      'metamask.perps.prepare_local_snapshot_endpoint requires an integer port between 1 and 65535.',
+    );
+  }
+
+  const serial = process.env.ADB_SERIAL || process.env.ANDROID_SERIAL;
+  if (!serial) {
+    return {
+      action: input.action,
+      applied: false,
+      reason: 'not-required-for-ios-simulator',
+      port,
+      proofPath: 'local-snapshot-endpoint-platform-check',
+    };
+  }
+
+  const adb = resolveMobileToolPath('adb');
+  if (!adb) {
+    throw new Error(
+      'metamask.perps.prepare_local_snapshot_endpoint could not resolve adb.',
+    );
+  }
+  const mapping = `tcp:${port}`;
+  await execFileAsync(adb, ['-s', serial, 'reverse', mapping, mapping], {
+    timeout: 10_000,
+  });
+  const { stdout } = await execFileAsync(adb, ['-s', serial, 'reverse', '--list'], {
+    timeout: 10_000,
+  });
+  const applied = stdout
+    .split(/\r?\n/u)
+    .some((line) => line.includes(`${mapping} ${mapping}`));
+  if (!applied) {
+    throw new Error(
+      `metamask.perps.prepare_local_snapshot_endpoint did not observe ${mapping} after applying it to ${serial}.`,
+    );
+  }
+  return {
+    action: input.action,
+    applied: true,
+    port,
+    redacted: true,
+    proofPath: 'adb-reverse-local-snapshot-endpoint',
+  };
+}
+
+runAdapter(prepareLocalSnapshotEndpoint);

package/library/actions/mobile/platform/bridge.mjs

@@ -23,6 +23,41 @@ export const MOBILE_BRIDGE_ERROR_CODES = BRIDGE_ERROR_CODES;
 
 const execFileAsync = promisify(execFile);
 
+let adapterActionActive = false;
+let actionBridgeLockPath = null;
+
+function resolveBridgeLockPath(input, env) {
+  const configuredRuntime = env.RECIPE_RUNTIME_DIR;
+  const runtime = configuredRuntime
+    ? (path.isAbsolute(configuredRuntime)
+      ? configuredRuntime
+      : path.resolve(input.context.projectRoot, configuredRuntime))
+    : path.join(input.context.projectRoot, 'temp', 'recipe', 'runtime');
+  return path.join(runtime, 'cdp-bridge.lock');
+}
+
+async function acquireActionBridgeLock(input, env) {
+  if (actionBridgeLockPath) return String(process.pid);
+  const lockPath = resolveBridgeLockPath(input, env);
+  await mkdir(path.dirname(lockPath), { recursive: true });
+  await writeFile(lockPath, String(process.pid));
+  actionBridgeLockPath = lockPath;
+  return String(process.pid);
+}
+
+async function releaseActionBridgeLock() {
+  const lockPath = actionBridgeLockPath;
+  actionBridgeLockPath = null;
+  if (!lockPath) return;
+  try {
+    if ((await readFile(lockPath, 'utf8')).trim() === String(process.pid)) {
+      await rm(lockPath, { force: true });
+    }
+  } catch {
+    // The bridge child or a newer owner may already have replaced the lock.
+  }
+}
+
 // Recover the typed code a cdp-bridge child reported: the stderr marker is
 // authoritative (it carries the class the bridge classified at the source), the
 // coded exit status is the fallback for output-less failures, and a raw message
@@ -52,8 +87,14 @@ export async function writeOutput(input, output) {
 
 export async function runAdapter(callback) {
   const input = await loadInput();
-  const output = await callback(input);
-  await writeOutput(input, output);
+  adapterActionActive = true;
+  try {
+    const output = await callback(input);
+    await writeOutput(input, output);
+  } finally {
+    adapterActionActive = false;
+    await releaseActionBridgeLock();
+  }
 }
 
 function bridgeScript(input) {
@@ -127,7 +168,13 @@ export async function bridgeEnv(input) {
   // (e.g. "Pixel 6" matches Metro deviceName "Pixel 6 - 16 - API 36").
   const serialStr = adbSerial != null ? String(adbSerial) : '';
   const deviceStr = androidDevice != null ? String(androidDevice) : '';
-  if (serialStr && deviceStr === serialStr) {
+  if (
+    shouldResolveAndroidTargetModel(
+      serialStr,
+      deviceStr,
+      androidTargetDeviceName,
+    )
+  ) {
     const model = await resolveAndroidModel(serialStr);
     if (model) {
       env.ANDROID_TARGET_DEVICE_NAME = model;
@@ -150,6 +197,17 @@ export async function bridgeEnv(input) {
   return env;
 }
 
+export function shouldResolveAndroidTargetModel(
+  adbSerial,
+  androidDevice,
+  androidTargetDeviceName,
+) {
+  const serial = String(adbSerial ?? '').trim();
+  const device = String(androidDevice ?? '').trim();
+  const targetName = String(androidTargetDeviceName ?? '').trim();
+  return Boolean(serial && !targetName && (!device || device === serial));
+}
+
 function resolveMobileTarget(input) {
   const contextEnv = input.context?.env || {};
   const watcherPort = input.node?.watcher_port ?? input.node?.metro_port ?? input.node?.cdp_port ?? contextEnv.WATCHER_PORT ?? contextEnv.CDP_PORT ?? contextEnv.RECIPE_CDP_PORT ?? process.env.WATCHER_PORT ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
@@ -314,6 +372,9 @@ export async function bridgeCommand(input, args) {
   const script = bridgeScript(input);
   // bridgeEnv is async: it may call `adb getprop` to resolve the Metro device name.
   const env = await bridgeEnv(input);
+  if (adapterActionActive) {
+    env.CDP_BRIDGE_LOCK_OWNER_PID = await acquireActionBridgeLock(input, env);
+  }
   const result = await new Promise((resolve, reject) => {
     const timeoutMs = Number(input.node?.bridge_timeout_ms ?? input.node?.cdp_timeout_ms ?? process.env.CDP_TIMEOUT ?? 30000);
     const child = spawn(process.execPath, [script, ...args], {
@@ -465,14 +526,21 @@ function valueContains(actual, expected) {
   return Object.is(actual, expected);
 }
 
-function routeMatches(route, expectedRoute, expectedParams) {
+export function routeSatisfiesNavigationTarget(
+  route,
+  expectedRoute,
+  expectedParams,
+) {
   return routeName(route) === expectedRoute &&
     (expectedParams === undefined || valueContains(route?.params ?? {}, expectedParams));
 }
 
 function routeTransitionProven(previousRoute, currentRoute, expectedRoute, expectedParams) {
-  if (!previousRoute || !routeMatches(currentRoute, expectedRoute, expectedParams)) return false;
-  if (!routeMatches(previousRoute, expectedRoute, expectedParams)) return true;
+  if (
+    !previousRoute ||
+    !routeSatisfiesNavigationTarget(currentRoute, expectedRoute, expectedParams)
+  ) return false;
+  if (!routeSatisfiesNavigationTarget(previousRoute, expectedRoute, expectedParams)) return true;
   return Boolean(
     previousRoute.key &&
       currentRoute?.key &&
@@ -502,6 +570,23 @@ export async function navigate(input, route, params = {}, expectedRoute) {
     if (!isTargetTransition(error)) throw error;
   }
 
+  if (
+    routeSatisfiesNavigationTarget(
+      previousRoute,
+      requestedRoute,
+      requestedParams,
+    )
+  ) {
+    return {
+      navigated: route,
+      params,
+      previousRoute,
+      currentRoute: previousRoute,
+      verifiedRoute: requestedRoute,
+      alreadyAtRoute: true,
+    };
+  }
+
   while (navigateAttempts < 2 || recoveryPending) {
     if (recoveryPending) {
       const deadline = recoveryDeadline ?? Date.now() + timeoutMs;
@@ -537,7 +622,14 @@ export async function navigate(input, route, params = {}, expectedRoute) {
           },
         };
       }
-      if (!previousRoute && routeMatches(currentRoute, requestedRoute, requestedParams)) {
+      if (
+        !previousRoute &&
+        routeSatisfiesNavigationTarget(
+          currentRoute,
+          requestedRoute,
+          requestedParams,
+        )
+      ) {
         break;
       }
       recoveryPending = false;
@@ -621,7 +713,9 @@ export async function waitForRoute(
       await waitForNextRouteProbe(deadline);
       continue;
     }
-    if (routeMatches(lastRoute, expected, expectedParams)) return lastRoute;
+    if (
+      routeSatisfiesNavigationTarget(lastRoute, expected, expectedParams)
+    ) return lastRoute;
     pollCount += 1;
     await waitForNextRouteProbe(deadline);
   }

package/library/actions/mobile/wallet/ensure_unlocked.mjs

@@ -1,6 +1,10 @@
 import { readFile } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
-import { bridgeCommand, runAdapter, selectBridgeStatusEntry } from '../platform/bridge.mjs';
+import {
+  bridgeCommand,
+  runAdapter,
+  selectBridgeStatusEntry,
+} from '../platform/bridge.mjs';
 import { walletFixturePath } from '../../harness-exports.mjs';
 
 async function fixturePassword(projectRoot) {
@@ -39,7 +43,30 @@ function routeName(status, input) {
 const selectedStatus = selectBridgeStatusEntry;
 
 async function status(input) {
-  return bridgeCommand(input, ['status']);
+  return bridgeCommand(input, ['status-selected']);
+}
+
+async function statusBeforeDeadline(input, deadline) {
+  const remainingMs = Math.max(1, deadline - Date.now());
+  const configuredMs = Number(
+    input.node?.bridge_timeout_ms ??
+      input.node?.cdp_timeout_ms ??
+      process.env.CDP_TIMEOUT ??
+      30000,
+  );
+  const probeTimeoutMs = Math.min(
+    5000,
+    remainingMs,
+    Number.isFinite(configuredMs) && configuredMs > 0 ? configuredMs : 30000,
+  );
+  return status({
+    ...input,
+    node: {
+      ...input.node,
+      bridge_timeout_ms: probeTimeoutMs,
+      cdp_timeout_ms: probeTimeoutMs,
+    },
+  });
 }
 
 async function waitForTargetStatus(input, timeoutMs = 20000) {
@@ -48,7 +75,7 @@ async function waitForTargetStatus(input, timeoutMs = 20000) {
   let lastError = null;
   while (Date.now() < deadline) {
     try {
-      last = await status(input);
+      last = await statusBeforeDeadline(input, deadline);
       const selected = selectedStatus(last, input);
       if (selected?.agenticPresent === true) return last;
     } catch (error) {
@@ -69,7 +96,7 @@ async function waitForWalletState(input, initialStatus, timeoutMs) {
     if (Date.now() >= deadline) break;
     await new Promise((resolve) => setTimeout(resolve, 250));
     try {
-      last = await status(input);
+      last = await statusBeforeDeadline(input, deadline);
     } catch {
       // A rotating Hermes target during startup is transient. The target timeout
       // still bounds this loop and the final error reports the last wallet state.
@@ -80,13 +107,13 @@ async function waitForWalletState(input, initialStatus, timeoutMs) {
   );
 }
 
-async function waitForUnlocked(input, timeoutMs = 15000) {
+async function waitForUnlocked(input, timeoutMs = 30000) {
   const deadline = Date.now() + timeoutMs;
   let last = null;
   let lastError = null;
   while (Date.now() < deadline) {
     try {
-      last = await status(input);
+      last = await statusBeforeDeadline(input, deadline);
       if (selectedAccount(last, input) && routeName(last, input) !== 'Login') return last;
     } catch (error) {
       lastError = error;
@@ -108,7 +135,7 @@ async function waitForStableUnlocked(input, initialStatus, stableMs = 750) {
   while (Date.now() < deadline) {
     await new Promise((resolve) => setTimeout(resolve, 250));
     try {
-      last = await status(input);
+      last = await statusBeforeDeadline(input, deadline);
       if (!isUnlockedStatus(last, input)) {
         if (routeName(last, input) === 'Login') return null;
         transientDrops += 1;
@@ -152,7 +179,7 @@ export async function ensureUnlocked(input) {
   const password = input.node?.password ?? await fixturePassword(input.context.projectRoot);
   try {
     const result = await bridgeCommand(input, ['unlock', String(password)]);
-    const after = await waitForUnlocked(input, Number(input.node?.unlock_timeout_ms ?? 15000));
+    const after = await waitForUnlocked(input, Number(input.node?.unlock_timeout_ms ?? 30000));
     const stableAfter = await waitForStableUnlocked(input, after, Number(input.node?.stable_unlocked_ms ?? 750)) ?? after;
     return {
       action: input.action,