verikun 0.25.0 → 0.25.1

package/.claude/skills/verikun/SKILL.md

@@ -141,7 +141,10 @@ banner, the retry path, dark theme, a layout that breaks at accessibility text s
   you reset it, so don't leave someone's phone in airplane mode.
 
 - `vk device prep [--dry-run] [--revert]` — set a **test** device up once, stickily:
-  `animations=off stay-awake=on screen-timeout=max dnd=on doze=off`.
+  `animations=off stay-awake=off screen-timeout=1m dnd=on doze=off`. The display then sleeps by
+  itself a minute after the last command and is woken by the next one; `--no-sleep-when-idle`
+  keeps it lit for good (`stay-awake=on screen-timeout=max`), which is what a device with a
+  PIN/pattern lock needs, since verikun can only clear a *swipe* lock.
 
   Unlike `device set`, prep **survives the run** and is undone only by `--revert`. A physical
   device must be named (`--device <serial>`) — that requirement is deliberate, so prep can
@@ -549,6 +552,8 @@ owns the redaction and the review-first flow.
   verikun detects this, wakes the device and clears a *swipe* lock automatically; on a
   PIN/pattern/password it exits **3** naming the lock rather than returning that dump.
   Tell the user to remove the lock in Settings > Security — verikun never asks for a PIN.
+  Taps, swipes, typing and screenshots wake it the same way: a prepped display sleeps after a
+  minute idle, and an injected tap on a sleeping screen would otherwise do nothing and exit `0`.
 - **Ambiguous selector → exit 2**, never a random tap. `vk` prints the candidate
   matches; add `--index N` or use a more specific selector.
 - **Indexes are per-snapshot.** `vk tap 3` taps `[3]` from the *latest* dump;

package/CHANGELOG.md

@@ -6,6 +6,18 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [0.25.1] - 2026-08-21
+
+### Changed
+- **`vk device prep`**: gives the display a 1-minute timeout instead of keeping it lit forever; `--no-sleep-when-idle` keeps the old behaviour. ([#101])
+- **`vk batch|ai|suite`**: no longer switch a prepped device's display off at teardown — it now sleeps by itself.
+- **`vk tap|type|key|swipe|screenshot`**: wake a sleeping display first; an injected tap on a dozing screen did nothing and exited `0`.
+
+### Added
+- **`vk device prep`**: warns when a device that will now sleep is behind a PIN/pattern lock.
+
+[#101]: https://github.com/ddikman/verikun/issues/101
+
 ## [0.25.0] - 2026-08-21
 
 ### Added

package/README.md

@@ -38,7 +38,7 @@ The package also carries the agent [`SKILL.md`](.claude/skills/verikun/SKILL.md)
 
 ```sh
 vk doctor                       # check adb/device (read-only — never changes anything)
-vk device prep --device <id>    # set a TEST device up once: animations off, stays awake
+vk device prep --device <id>    # set a TEST device up once: animations off, sane display timeout
 vk devices                      # list attached devices
 vk ui                           # semantic snapshot of the current screen
 vk tap @login_button            # tap by resource-id

package/dist/cli.js

@@ -1394,10 +1394,12 @@ function devicePrep(ctx) {
     const serial = ctx.driver.resolvedSerial();
     if ((0, args_1.flagBool)(ctx.flags, 'revert'))
         return devicePrepRevert(ctx, serial, dryRun, asJson);
+    // Which display policy: sleeps by itself after PREP_SCREEN_TIMEOUT, or never turns off.
+    const sleepWhenIdle = !(0, args_1.flagBool)(ctx.flags, 'no-sleep-when-idle');
     // Partition by what this platform can actually do, so the gate below counts real writes.
     const skipped = [];
     const applicable = [];
-    for (const knob of prep_1.PREP_KNOBS) {
+    for (const knob of (0, prep_1.prepKnobs)(sleepWhenIdle)) {
         const spec = settings_1.SETTINGS[knob.key];
         const support = spec.support[ctx.platform];
         if (support === 'unsupported') {
@@ -1451,7 +1453,6 @@ function devicePrep(ctx) {
     }
     // Earliest wins across re-preps, or `--revert` would restore the device to prepped.
     const prior = (0, prep_1.readPrep)(serial);
-    const sleepWhenIdle = !(0, args_1.flagBool)(ctx.flags, 'no-sleep-when-idle');
     (0, prep_1.writePrep)((0, prep_1.newPrepRecord)(serial, ctx.platform, (0, prep_1.mergeOriginals)(prior?.original ?? {}, original), sleepWhenIdle));
     const applied = Object.fromEntries(applicable.map((k) => [k.key, k.target]));
     ctx.record?.note({ message: `device prep ${serial} (${changes.length} changed)` });
@@ -1463,11 +1464,32 @@ function devicePrep(ctx) {
         for (const s of skipped)
             (0, output_1.err)(`note: ${s.key} skipped — ${s.reason.replace(/\n/g, ' ')}`);
         if (sleepWhenIdle)
-            (0, output_1.err)('note: this device will be put to sleep when a run using it finishes');
+            (0, output_1.err)(`note: the display sleeps by itself after ${prep_1.PREP_SCREEN_TIMEOUT} idle, and is woken on the next read`);
+        warnSecureLock(ctx.platform, serial, sleepWhenIdle);
         (0, output_1.err)(`undo with: verikun device prep --revert --device ${serial}`);
     }
     return 0;
 }
+/**
+ * Say so, once, when a device that will now sleep is behind a SECURE lock.
+ *
+ * The wake on the read path can only clear a *swipe* keyguard; a PIN/pattern/password one makes
+ * `getElements` exit 3 rather than hand back the lock screen. That is honest, but it is a
+ * failure, and prep — an explicit setup command that already resolved the serial — is where you
+ * want to hear about it, not twenty minutes into a suite. It only warns: refusing would make a
+ * perfectly usable device un-preppable, and `--no-sleep-when-idle` is the way out.
+ */
+function warnSecureLock(platform, serial, sleepWhenIdle) {
+    if (!sleepWhenIdle || platform !== 'android')
+        return;
+    const lock = (0, adb_1.lockKindOf)(serial);
+    if (lock === 'none' || lock === 'unknown')
+        return;
+    (0, output_1.err)(`warning: this device has a screen lock (${lock}), so a read after the display sleeps can land ` +
+        'on the keyguard (verikun can only clear a swipe lock, and never asks for a PIN).\n' +
+        'Remove it in Settings > Security, or keep the display lit with `verikun device prep ' +
+        `--no-sleep-when-idle --device ${serial}\`.`);
+}
 /** Put a prepared device back the way it was found, and forget it. */
 function devicePrepRevert(ctx, serial, dryRun, asJson) {
     const rec = (0, prep_1.readPrep)(serial);
@@ -1557,35 +1579,6 @@ function requireSettingKey(v) {
  * same code. (Remote is a known gap: the overrides live in the *server's* run file, so
  * a locally-empty snapshot means this correctly skips — see the issue's Out of scope.)
  */
-/**
- * Park prepared devices when the flow that used them ends — #97's "in sleep mode when they're
- * not [in use]".
- *
- * Three properties worth keeping:
- *
- *   * It can only ever touch a device you explicitly PREPPED, and only if that prep did not
- *     pass `--no-sleep-when-idle`. A borrowed phone that was never prepped is never slept.
- *   * It goes through the driver rather than the command dispatcher, so it does not appear as
- *     a `key sleep` testcase in the report. Parking is host hygiene, not a test step.
- *   * `ownClaimedSerials()` is empty in `--server` mode (the local process never resolves a
- *     device), so the remote path degrades to doing nothing on its own, with no branch here.
- *     Managing a remote device's power is `--allow-device-control`'s job.
- *
- * Must run BEFORE `releaseOwnClaims()`, which is what it reads its serials from.
- */
-function parkPreparedDevices(platform) {
-    for (const serial of (0, claims_1.ownClaimedSerials)()) {
-        if (!(0, prep_1.readPrep)(serial)?.sleepWhenIdle)
-            continue;
-        try {
-            (0, output_1.err)(`[verikun] parking prepared device ${serial} (sleep)`);
-            (0, drivers_1.getDriver)(platform, serial).pressKey('sleep');
-        }
-        catch {
-            /* teardown must never throw — the device may be exactly why we are unwinding */
-        }
-    }
-}
 async function restoreDeviceOverrides(backend) {
     if (!run_1.Recorder.hasDeviceOverrides())
         return;
@@ -1866,7 +1859,6 @@ async function cmdBatch(positionals, batchFlags) {
                 /* the device may be exactly why we are unwinding — never mask the real error */
             }
         }
-        parkPreparedDevices(platformFromFlags(batchFlags));
         (0, claims_1.releaseOwnClaims)();
     }
 }
@@ -2523,8 +2515,7 @@ async function cmdAi(positionals, flags) {
         // otherwise an unattended run leaves the phone offline or in dark mode.
         await restoreDeviceOverrides(backend);
         await backend.close?.(); // frees a remote server's device lock for the next command
-        parkPreparedDevices(platform); // a prepped device goes back to sleep between runs
-        (0, claims_1.releaseOwnClaims)(); // and the host-level claim, so the next job can have the device
+        (0, claims_1.releaseOwnClaims)(); // the host-level claim, so the next job can have the device
     }
     if ((0, args_1.flagBool)(flags, 'json')) {
         (0, output_1.json)({
@@ -2618,7 +2609,6 @@ async function cmdSuiteEntry(positionals, flags) {
     finally {
         await restoreDeviceOverrides(backend);
         await backend.close?.();
-        parkPreparedDevices(platform);
         (0, claims_1.releaseOwnClaims)();
     }
 }
@@ -2967,11 +2957,11 @@ DEVICE STATE (change the device the app runs on, then put it back)
                                       do this automatically when the flow ends OR fails,
                                       so a dead test can't leave the phone offline.
   device prep [--dry-run] [--json]    Prepare a TEST device once, stickily: animations off,
-                                      display kept awake, Do Not Disturb on, battery idle off.
-                                      Survives the run (unlike \`device set\`), so it is undone
-                                      only by \`--revert\`. A PHYSICAL device must be named with
-                                      --device — prep must never land on a personal phone.
-                                      --no-sleep-when-idle keeps the screen on after a run.
+                                      display timeout ${prep_1.PREP_SCREEN_TIMEOUT}, Do Not Disturb on,
+                                      battery idle off. Survives the run (unlike \`device set\`),
+                                      so it is undone only by \`--revert\`. A PHYSICAL device must
+                                      be named with --device — prep must never land on a personal
+                                      phone. --no-sleep-when-idle keeps the display on for good.
   device prep --revert [--dry-run]    Put a prepared device back the way it was found
   device caps [--json]                What this platform supports, and the manual
                                       equivalent where it doesn't

package/dist/device/claims.js

@@ -31,7 +31,6 @@
 // Platform-agnostic by design, like `device/settings.ts` and `ui/`: it never touches
 // adb/xcrun. The drivers know which devices exist; this knows which are taken.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ownClaimedSerials = ownClaimedSerials;
 exports.releaseOwnClaims = releaseOwnClaims;
 exports.setProcessScoped = setProcessScoped;
 exports.claimsEnabled = claimsEnabled;
@@ -73,11 +72,6 @@ let processScoped = false;
  * store what it took is the only way it can release anything.
  */
 const acquired = new Set();
-/** Which devices this process took. Read by the prep teardown, which has to act on them
- *  BEFORE `releaseOwnClaims` empties this — see `parkPreparedDevices` in cli.ts. */
-function ownClaimedSerials() {
-    return [...acquired];
-}
 /** Give back every device this process claimed. Best-effort; teardown must never throw. */
 function releaseOwnClaims(o = {}) {
     const released = [];

package/dist/device/prep.js

@@ -22,7 +22,8 @@
 // says what a knob is, this says which knobs prep establishes and what they used to be, and
 // the drivers know how.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PREP_KNOBS = void 0;
+exports.PREP_SCREEN_TIMEOUT = void 0;
+exports.prepKnobs = prepKnobs;
 exports.prepDir = prepDir;
 exports.readPrep = readPrep;
 exports.isPrepared = isPrepared;
@@ -39,22 +40,59 @@ const output_1 = require("../output");
 const version_1 = require("../version");
 const claims_1 = require("./claims");
 /**
- * The prep set.
+ * How long a prepped device's display stays on with nothing driving it.
  *
- * Every entry has to name a failure `vk` actually has. This is not "sensible defaults for a
- * phone" — it is the shortest list that makes a hierarchy read trustworthy, and anything that
- * merely feels tidy belongs in the user's own `device set` call instead.
+ * Long enough to span the gap between two commands of the same flow — an agent's turn, a model
+ * repair round-trip — and short enough that a phone nobody is using goes dark. A LONGER gap is
+ * not a failure: `getElements()` probes wakefulness before every read and wakes the device
+ * (clearing a swipe keyguard on the way), which is what makes sleeping safe to allow at all.
  */
-exports.PREP_KNOBS = [
+exports.PREP_SCREEN_TIMEOUT = '1m';
+/** Knobs every prep applies, whatever the display policy is. */
+const CORE_KNOBS = [
     { key: 'animations', value: 'off', why: 'a live animation makes `uiautomator dump` return a stale or empty screen' },
-    // Measured: a slept device does NOT fail the read — it serves the lock screen as a
-    // successful dump. Keeping the display up is what stops that, and it is why these two
-    // knobs are in the set rather than being left to the recovery path in getElements().
-    { key: 'stay-awake', value: 'on', why: 'a slept display reads back as the LOCK SCREEN, not as an error' },
-    { key: 'screen-timeout', value: 'max', why: 'the same, for a device that is not plugged in' },
     { key: 'dnd', value: 'on', why: 'a heads-up notification lands on top of the app and steals the next tap' },
     { key: 'doze', value: 'off', why: 'battery idle suspends the background work a test is waiting on' },
 ];
+/**
+ * The default display policy: the device parks ITSELF once nobody is driving it.
+ *
+ * Both knobs move together, and that is the whole point. `stay-awake=on` is
+ * `stay_on_while_plugged_in`, which keeps the screen up while CHARGING — and a device on USB
+ * adb is always charging — so leaving it on makes `screen-timeout` inert and "never sleeps" the
+ * real policy. That is what verikun used to do, and it is why teardown had to switch the display
+ * off by hand, blanking the screen between every two commands of a burst (#101).
+ */
+const SLEEPY_DISPLAY = [
+    {
+        key: 'stay-awake',
+        value: 'off',
+        why: 'it overrides the display timeout while charging, so a tethered device would never sleep',
+    },
+    {
+        key: 'screen-timeout',
+        value: exports.PREP_SCREEN_TIMEOUT,
+        why: "the stock 15-30s blanks the display between two commands of one flow; a longer gap is woken on the next read",
+    },
+];
+/** `--no-sleep-when-idle`: the display never turns off, which is the older prep behaviour. */
+const AWAKE_DISPLAY = [
+    { key: 'stay-awake', value: 'on', why: 'asked for explicitly — the display must stay lit while the device is charging' },
+    { key: 'screen-timeout', value: 'max', why: 'the same, for a device that is not plugged in' },
+];
+/**
+ * The prep set.
+ *
+ * Every entry has to name a failure `vk` actually has. This is not "sensible defaults for a
+ * phone" — it is the shortest list that makes a hierarchy read trustworthy, and anything that
+ * merely feels tidy belongs in the user's own `device set` call instead.
+ *
+ * The two display sets cover the SAME keys, so `--revert` restores the same surface whichever
+ * policy was applied — including on a device prepped one way and then the other.
+ */
+function prepKnobs(sleepWhenIdle) {
+    return [...CORE_KNOBS, ...(sleepWhenIdle ? SLEEPY_DISPLAY : AWAKE_DISPLAY)];
+}
 function prepDir(o = {}) {
     return (0, node_path_1.join)(o.home ?? (0, node_os_1.homedir)(), '.verikun', 'prepared');
 }

package/dist/drivers/adb.js

@@ -260,6 +260,15 @@ const VERIFY_INTERVAL_MS = 200;
 /** How long to let the screen settle after a wakeup before reading it. Long enough for
  *  the unlock/wake animation, short enough that it is noise next to the dump it precedes. */
 const WAKE_SETTLE_MS = 600;
+/** How long an "it is awake" answer stays good for. Exists so ONE command does not probe
+ *  twice — `vk tap text:X` reads the hierarchy and then taps what it resolved — and is
+ *  deliberately far shorter than any display timeout that could sleep the device in between
+ *  (`device prep` sets a minute). A long `wait` or `vk ai` run therefore keeps re-probing. */
+const AWAKE_FRESH_MS = 2000;
+/** Keys that MOVE the screen's power state. They must never wake the device first: `sleep`
+ *  would be undone, and `wakeup` is what the wake path itself sends — the exclusion is what
+ *  stops that recursing. */
+const SCREEN_POWER_KEYS = new Set(['sleep', 'wakeup', 'power']);
 /** The three `global` scales behind the `animations` setting. All must be zero for it to
  *  read `off` — one live scale is enough to make a dump flaky. */
 const ANIMATION_SCALES = ['window_animation_scale', 'transition_animation_scale', 'animator_duration_scale'];
@@ -530,6 +539,8 @@ class AdbDriver {
     lastRotation;
     /** undefined = not built yet, null = opted out. See companionOrNull(). */
     companion;
+    /** Until when `ensureAwake` may skip its probe. See AWAKE_FRESH_MS. */
+    awakeUntil = 0;
     constructor(serial) {
         this.requested = serial;
     }
@@ -618,10 +629,7 @@ class AdbDriver {
         // `com.motorola.*`), which no package heuristic can tell from an app. The display being
         // off is the only signal that generalises — if it is off, the app is not on screen,
         // whoever drew what is there.
-        if (this.readWakefulness() === false) {
-            (0, output_1.err)('note: the display is off — waking the device before reading the screen');
-            this.wakeAndUnlock();
-        }
+        this.ensureAwake('reading the screen');
         const els = this.captureElements(opts);
         // Second net, for a device that is awake but still behind the keyguard.
         if (!this.keyguardReason(els))
@@ -639,10 +647,11 @@ class AdbDriver {
         throw new errors_1.CliError(`${what}, so this read would return the keyguard rather than the app — which would look ` +
             'like a successful read of the wrong screen.\n' +
             (reason === 'locked'
-                ? 'Remove the screen lock on your test device (Settings > Security), then `verikun device ' +
-                    'prep` to stop the display sleeping in the first place.\n' +
-                    'verikun never asks for or stores a device PIN, so it cannot unlock this for you.'
-                : 'Keep the display awake with `verikun device prep`, or wake it with `verikun key wakeup`.'), 3);
+                ? 'Remove the screen lock on your test device (Settings > Security) — verikun clears a ' +
+                    'swipe lock by itself, and never asks for or stores a device PIN.\n' +
+                    'To keep the display lit instead: `verikun device prep --no-sleep-when-idle`.'
+                : 'Wake it with `verikun key wakeup`, or keep the display lit with `verikun device ' +
+                    'prep --no-sleep-when-idle`.'), 3);
     }
     captureElements(opts) {
         const xml = this.dumpXml();
@@ -777,9 +786,11 @@ class AdbDriver {
                     'Retry, or use a command that waits (`vk wait`, or any selector lookup).');
             }
             if (attempt === 0) {
-                // A sleeping display is the other documented cause of a failed read, so it is checked
-                // here, lazily, where it costs nothing until something has already gone wrong.
-                this.wakeIfAsleep();
+                // A sleeping display is the other documented cause of a failed read. `ensureAwake` ran
+                // before the dump, so reaching here means its answer went stale during a slow read (or
+                // the device could not answer at all) — clear the window and ask again for real.
+                this.awakeUntil = 0;
+                this.ensureAwake('retrying the read');
                 // A companion holds the device's ONE UiAutomation connection and SIGKILLs anything
                 // else that wants it — including this dump. It outlives the process that started it,
                 // so a later command that never opted in would fail for as long as it lives. Ask it
@@ -789,10 +800,11 @@ class AdbDriver {
             }
         }
         throw new errors_1.CliError(`Failed to capture UI hierarchy after 3 attempts. ${lastErr}\n` +
-            'Tip: prepare the device once with `verikun device prep` (disables animations, keeps the ' +
-            'display awake) and ensure the screen is idle.', 3);
+            'Tip: prepare the device once with `verikun device prep` (disables animations, gives the ' +
+            'display a sane timeout) and ensure the screen is idle.', 3);
     }
     screenshot() {
+        this.ensureAwake('taking a screenshot');
         const r = (0, exec_1.runBinary)(ADB, this.withSerial(['exec-out', 'screencap', '-p']));
         if (r.stdout.length < 8 || r.stdout[0] !== 0x89 || r.stdout[1] !== 0x50) {
             throw new errors_1.CliError(`screencap did not return a PNG. ${r.stderr}`.trim(), 3);
@@ -809,6 +821,7 @@ class AdbDriver {
      * path. Getting a wrong-but-plausible image would be far worse than being slow.
      */
     screenshotRaw() {
+        this.ensureAwake('taking a screenshot');
         const r = (0, exec_1.runBinary)(ADB, this.withSerial(['exec-out', 'screencap']));
         const buf = r.stdout;
         if (buf.length < RAW_HEADER_SIZES[0])
@@ -842,9 +855,11 @@ class AdbDriver {
         return { width: +m[1], height: +m[2] };
     }
     tap(x, y) {
+        this.ensureAwake('tapping');
         this.shell(['input', 'tap', String(Math.round(x)), String(Math.round(y))]);
     }
     swipe(x1, y1, x2, y2, durationMs) {
+        this.ensureAwake('swiping');
         this.shell([
             'input',
             'swipe',
@@ -858,6 +873,7 @@ class AdbDriver {
     inputText(text) {
         if (!text)
             return;
+        this.ensureAwake('typing');
         this.shell(['input', 'text', escapeText(text)]);
     }
     pressKey(name) {
@@ -865,6 +881,8 @@ class AdbDriver {
         if (code === undefined) {
             throw new errors_1.CliError(`Unknown key '${name}'. Known: ${Object.keys(KEYCODES).join(', ')}, or a numeric keycode.`, 2);
         }
+        if (!SCREEN_POWER_KEYS.has(name.toLowerCase()))
+            this.ensureAwake(`sending ${name}`);
         this.shell(['input', 'keyevent', String(code)]);
     }
     launch(appId) {
@@ -1215,6 +1233,31 @@ class AdbDriver {
             return 'unknown';
         }
     }
+    /**
+     * Wake a sleeping display before doing something that would otherwise "succeed" against it.
+     *
+     * Every path that touches the screen needs this, not just the hierarchy read: `screencap` on
+     * a dozing device returns the ambient/lock frame into the report, and an injected tap does
+     * NOTHING AT ALL while exiting 0 (measured on a Pixel 3a: `input tap` leaves
+     * `mWakefulness=Dozing` untouched). A false green is the one failure a testing tool may not
+     * have, which is why this sits on the action path even though the probe is not free.
+     *
+     * `null` from the probe means "could not tell" and does nothing — the same posture as the
+     * dump path: pressing wakeup at random is not a fix.
+     */
+    ensureAwake(what) {
+        if (Date.now() < this.awakeUntil)
+            return;
+        // Set the window BEFORE waking: wakeAndUnlock presses `wakeup` through pressKey, which
+        // asks this method again. SCREEN_POWER_KEYS already excludes that key; this is the belt
+        // to its braces, and it costs nothing.
+        this.awakeUntil = Date.now() + AWAKE_FRESH_MS;
+        if (this.readWakefulness() !== false)
+            return;
+        (0, output_1.err)(`note: the display is off — waking the device before ${what}`);
+        this.wakeAndUnlock();
+        this.awakeUntil = Date.now() + AWAKE_FRESH_MS;
+    }
     /** Wake the display and clear a non-secure keyguard, then let the screen settle. Never
      *  throws — deciding whether the result is good enough is `getElements`' job. */
     wakeAndUnlock() {
@@ -1234,24 +1277,5 @@ class AdbDriver {
             return false;
         }
     }
-    /**
-     * Wake a sleeping display before retrying a dump that already failed.
-     *
-     * Best-effort and never throws: refusing is `getElements`' job, which owns the ONE decision
-     * about whether we are looking at the app or the keyguard. This only handles the narrower
-     * case where the stock dump genuinely could not read a sleeping screen at all.
-     *
-     * Called lazily, after the first attempt has failed, so the happy path pays nothing — an
-     * extra `dumpsys power` on every read would tax every command in the CLI to help the rare one.
-     */
-    wakeIfAsleep() {
-        // `null` means the probe could not tell. Do nothing — the dump may well be failing for an
-        // unrelated reason, and pressing wakeup at random is not a fix.
-        if (this.screenState().awake !== false)
-            return;
-        (0, output_1.err)('note: the display was asleep — waking it before retrying the read');
-        this.pressKey('wakeup');
-        (0, exec_1.sleepSync)(WAKE_SETTLE_MS);
-    }
 }
 exports.AdbDriver = AdbDriver;

package/dist/version.js

@@ -3,4 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // GENERATED by scripts/gen-version.mjs from package.json's "version" at build time
 // (the `prebuild` script). Do NOT edit by hand; bump package.json instead.
-exports.VERSION = '0.25.0';
+exports.VERSION = '0.25.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verikun",
-  "version": "0.25.0",
+  "version": "0.25.1",
   "description": "Drive Android emulators/devices and iOS simulators for AI agents: tap, type, swipe, screenshot, and inspect the UI hierarchy by semantic identifiers — like Puppeteer for native apps.",
   "keywords": [
     "android",