zeno-mobile-runner 0.2.12 → 0.2.14

package/src/runner_waits.zig

@@ -9,6 +9,7 @@ const trace = @import("trace.zig");
 
 const RunOptions = runner_config.RunOptions;
 const native_health_probe_timeout_ms: u64 = 1000;
+const native_selector_transient_retry_limit: usize = 1;
 
 pub fn waitUntilVisible(
     device: anytype,
@@ -39,23 +40,36 @@ fn untilVisibleKind(
     kind: []const u8,
 ) !bool {
     const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
+    var native_query_failures: usize = 0;
     while (true) {
-        if (nativeSelectorQueryTimeoutMs(deadline)) |query_timeout_ms| {
-            const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| {
-                if (try retryTransientObservation(err, kind, writer, deadline, options)) continue;
+        if (nativeSelectorQueryTimeoutMs(deadline, options)) |query_timeout_ms| {
+            var native_query_failed = false;
+            const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| blk: {
+                if (try recordTransientNativeSelectorObservation(err, kind, writer)) {
+                    native_query_failures += 1;
+                    if (native_query_failures <= native_selector_transient_retry_limit and stdio.nowMs() < deadline) {
+                        try sleepMs(options.poll_ms);
+                        continue;
+                    }
+                    native_query_failed = true;
+                    break :blk null;
+                }
                 return err;
             };
-            if (native_result) |visible| {
-                if (visible) {
-                    if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
-                    return true;
-                }
-                if (stdio.nowMs() >= deadline) {
-                    if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
-                    return false;
+            if (!native_query_failed) native_query_failures = 0;
+            if (!native_query_failed) {
+                if (native_result) |visible| {
+                    if (visible) {
+                        if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
+                        return true;
+                    }
+                    if (stdio.nowMs() >= deadline) {
+                        if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
+                        return false;
+                    }
+                    try sleepMs(options.poll_ms);
+                    continue;
                 }
-                try sleepMs(options.poll_ms);
-                continue;
             }
         } else if (hasNativeSelectorQuery(device)) {
             if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
@@ -119,23 +133,36 @@ fn untilNotVisibleKind(
     kind: []const u8,
 ) !bool {
     const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
+    var native_query_failures: usize = 0;
     while (true) {
-        if (nativeSelectorQueryTimeoutMs(deadline)) |query_timeout_ms| {
-            const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| {
-                if (try retryTransientObservation(err, kind, writer, deadline, options)) continue;
+        if (nativeSelectorQueryTimeoutMs(deadline, options)) |query_timeout_ms| {
+            var native_query_failed = false;
+            const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| blk: {
+                if (try recordTransientNativeSelectorObservation(err, kind, writer)) {
+                    native_query_failures += 1;
+                    if (native_query_failures <= native_selector_transient_retry_limit and stdio.nowMs() < deadline) {
+                        try sleepMs(options.poll_ms);
+                        continue;
+                    }
+                    native_query_failed = true;
+                    break :blk null;
+                }
                 return err;
             };
-            if (native_result) |visible| {
-                if (!visible) {
-                    if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
-                    return true;
-                }
-                if (stdio.nowMs() >= deadline) {
-                    if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
-                    return false;
+            if (!native_query_failed) native_query_failures = 0;
+            if (!native_query_failed) {
+                if (native_result) |visible| {
+                    if (!visible) {
+                        if (writer) |tw| try runner_events.recordNativeWait(tw, kind, wanted, null, timeout_ms);
+                        return true;
+                    }
+                    if (stdio.nowMs() >= deadline) {
+                        if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
+                        return false;
+                    }
+                    try sleepMs(options.poll_ms);
+                    continue;
                 }
-                try sleepMs(options.poll_ms);
-                continue;
             }
         } else if (hasNativeSelectorQuery(device)) {
             if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, kind, &[_]selector.Selector{wanted}, timeout_ms);
@@ -178,10 +205,11 @@ pub fn waitUntilAnyVisible(
     options: RunOptions,
 ) !?usize {
     const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
-    while (true) {
+    var native_query_failures: usize = 0;
+    native_poll: while (true) {
         var all_native = true;
         for (selectors, 0..) |wanted, index| {
-            const query_timeout_ms = nativeSelectorQueryTimeoutMs(deadline) orelse {
+            const query_timeout_ms = nativeSelectorQueryTimeoutMs(deadline, options) orelse {
                 if (hasNativeSelectorQuery(device)) {
                     if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, "wait.any", selectors, timeout_ms);
                     return null;
@@ -190,9 +218,18 @@ pub fn waitUntilAnyVisible(
                 break;
             };
             const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| {
-                if (try retryTransientObservation(err, "wait.any", writer, deadline, options)) continue;
+                if (try recordTransientNativeSelectorObservation(err, "wait.any", writer)) {
+                    native_query_failures += 1;
+                    if (native_query_failures <= native_selector_transient_retry_limit and stdio.nowMs() < deadline) {
+                        try sleepMs(options.poll_ms);
+                        continue :native_poll;
+                    }
+                    all_native = false;
+                    break;
+                }
                 return err;
             };
+            native_query_failures = 0;
             if (native_result) |visible| {
                 if (visible) {
                     if (writer) |tw| try runner_events.recordNativeWait(tw, "wait.any", wanted, index, timeout_ms);
@@ -322,7 +359,7 @@ fn nativeAssertHealthy(
 
     const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
     native_probe: while (true) {
-        const remaining_ms = nativeSelectorQueryTimeoutMs(deadline) orelse return null;
+        const remaining_ms = nativeSelectorRemainingTimeoutMs(deadline) orelse return null;
         const query_timeout_ms = @min(remaining_ms, nativeHealthProbeTimeoutMs(timeout_ms, options));
 
         for (health_selectors, 0..) |wanted, index| {
@@ -356,7 +393,47 @@ pub fn scrollUntilVisible(
     options: RunOptions,
 ) !bool {
     const deadline = stdio.nowMs() + @as(i64, @intCast(timeout_ms));
+    var native_query_failures: usize = 0;
     while (true) {
+        if (nativeSelectorQueryTimeoutMs(deadline, options)) |query_timeout_ms| {
+            var native_query_failed = false;
+            const native_result = nativeVisibleBySelector(device, wanted, query_timeout_ms) catch |err| blk: {
+                if (try recordTransientNativeSelectorObservation(err, "ui.scrollUntilVisible", writer)) {
+                    native_query_failures += 1;
+                    if (native_query_failures <= native_selector_transient_retry_limit and stdio.nowMs() < deadline) {
+                        try sleepMs(options.poll_ms);
+                        continue;
+                    }
+                    native_query_failed = true;
+                    break :blk null;
+                }
+                return err;
+            };
+            if (!native_query_failed) native_query_failures = 0;
+            if (!native_query_failed) {
+                if (native_result) |visible| {
+                    if (visible) {
+                        if (writer) |tw| try runner_events.recordNativeScrollUntilVisible(
+                            tw,
+                            wanted,
+                            if (direction == .down) "down" else "up",
+                            timeout_ms,
+                        );
+                        return true;
+                    }
+                    if (stdio.nowMs() >= deadline) {
+                        if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, "ui.scrollUntilVisible", &[_]selector.Selector{wanted}, timeout_ms);
+                        return false;
+                    }
+                    try scrollDevice(device, direction, writer, options);
+                    continue;
+                }
+            }
+        } else if (hasNativeSelectorQuery(device)) {
+            if (writer) |tw| try runner_events.recordNativeWaitTimeoutWithDiagnostics(device, tw, "ui.scrollUntilVisible", &[_]selector.Selector{wanted}, timeout_ms);
+            return false;
+        }
+
         var snap = device.snapshot(writer) catch |err| {
             if (try retryTransientObservation(err, "ui.scrollUntilVisible", writer, deadline, options)) continue;
             return err;
@@ -385,29 +462,7 @@ pub fn scrollUntilVisible(
             return false;
         }
 
-        const width = if (snap.viewport.width == 0) @as(i32, 720) else @as(i32, @intCast(snap.viewport.width));
-        const height = if (snap.viewport.height == 0) @as(i32, 1280) else @as(i32, @intCast(snap.viewport.height));
-        const x = @divTrunc(width, 2);
-        const start_y = switch (direction) {
-            .down => @divTrunc(height * 4, 5),
-            .up => @divTrunc(height * 3, 10),
-        };
-        const end_y = switch (direction) {
-            .down => @divTrunc(height * 3, 10),
-            .up => @divTrunc(height * 4, 5),
-        };
-        try device.swipe(x, start_y, x, end_y, 350);
-        if (writer) |tw| {
-            const payload = try std.fmt.allocPrint(tw.allocator, "{{\"direction\":\"{s}\",\"x\":{d},\"y1\":{d},\"y2\":{d}}}", .{
-                if (direction == .down) "down" else "up",
-                x,
-                start_y,
-                end_y,
-            });
-            defer tw.allocator.free(payload);
-            try tw.recordEvent("ui.scroll", payload);
-        }
-        try settleDevice(device, options);
+        try scrollDeviceWithViewport(device, direction, writer, options, snap.viewport);
     }
 }
 
@@ -421,7 +476,13 @@ fn nativeVisibleBySelector(device: anytype, wanted: selector.Selector, timeout_m
     return try device.visibleBySelector(wanted);
 }
 
-fn nativeSelectorQueryTimeoutMs(deadline: i64) ?u64 {
+fn nativeSelectorQueryTimeoutMs(deadline: i64, options: RunOptions) ?u64 {
+    const remaining_ms = nativeSelectorRemainingTimeoutMs(deadline) orelse return null;
+    if (options.action_timeout_ms == 0) return remaining_ms;
+    return @max(@as(u64, 1), @min(remaining_ms, options.action_timeout_ms));
+}
+
+fn nativeSelectorRemainingTimeoutMs(deadline: i64) ?u64 {
     const now = stdio.nowMs();
     if (now >= deadline) return null;
     return @as(u64, @intCast(deadline - now));
@@ -434,6 +495,16 @@ fn nativeHealthProbeTimeoutMs(timeout_ms: u64, options: RunOptions) u64 {
     return @max(probe_timeout_ms, 1);
 }
 
+fn recordTransientNativeSelectorObservation(
+    err: anyerror,
+    kind: []const u8,
+    writer: ?*trace.TraceWriter,
+) !bool {
+    if (err != error.CommandTimedOut and err != error.CommandFailed) return false;
+    if (writer) |tw| try runner_events.recordObservationRetry(tw, kind, err);
+    return true;
+}
+
 fn retryTransientObservation(
     err: anyerror,
     kind: []const u8,
@@ -448,6 +519,54 @@ fn retryTransientObservation(
     return true;
 }
 
+fn scrollDevice(
+    device: anytype,
+    direction: scenario.ScrollDirection,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+) !void {
+    try scrollDeviceWithViewport(device, direction, writer, options, try scrollViewport(device));
+}
+
+fn scrollViewport(device: anytype) !@import("types.zig").Viewport {
+    if (@hasDecl(@TypeOf(device.*), "scrollViewport")) {
+        return try device.scrollViewport();
+    }
+    return .{};
+}
+
+fn scrollDeviceWithViewport(
+    device: anytype,
+    direction: scenario.ScrollDirection,
+    writer: ?*trace.TraceWriter,
+    options: RunOptions,
+    viewport: @import("types.zig").Viewport,
+) !void {
+    const width = if (viewport.width == 0) @as(i32, 720) else @as(i32, @intCast(viewport.width));
+    const height = if (viewport.height == 0) @as(i32, 1280) else @as(i32, @intCast(viewport.height));
+    const x = @divTrunc(width, 2);
+    const start_y = switch (direction) {
+        .down => @divTrunc(height * 4, 5),
+        .up => @divTrunc(height * 3, 10),
+    };
+    const end_y = switch (direction) {
+        .down => @divTrunc(height * 3, 10),
+        .up => @divTrunc(height * 4, 5),
+    };
+    try device.swipe(x, start_y, x, end_y, 350);
+    if (writer) |tw| {
+        const payload = try std.fmt.allocPrint(tw.allocator, "{{\"direction\":\"{s}\",\"x\":{d},\"y1\":{d},\"y2\":{d}}}", .{
+            if (direction == .down) "down" else "up",
+            x,
+            start_y,
+            end_y,
+        });
+        defer tw.allocator.free(payload);
+        try tw.recordEvent("ui.scroll", payload);
+    }
+    try settleDevice(device, options);
+}
+
 fn settleDevice(device: anytype, options: RunOptions) !void {
     try device.settle(options.settle_ms);
 }

package/src/scenario.zig

@@ -11,6 +11,11 @@ pub const Swipe = struct {
     duration_ms: u32 = 300,
 };
 
+pub const Location = struct {
+    latitude: f64,
+    longitude: f64,
+};
+
 pub const WaitVisible = struct {
     selector: selector.Selector,
     timeout_ms: u64 = 5000,
@@ -106,6 +111,7 @@ pub const Step = union(enum) {
     clear_state,
     snapshot,
     open_link: []const u8,
+    set_location: Location,
     tap: selector.Selector,
     type_text: TypeText,
     press_back,
@@ -224,6 +230,10 @@ fn parseRawStep(allocator: std.mem.Allocator, object: std.json.ObjectMap) anyerr
     if (std.mem.eql(u8, action, "hideKeyboard")) return .hide_keyboard;
     if (std.mem.eql(u8, action, "sleep")) return .{ .sleep_ms = try fields.optionalU64(object, "ms", 500) };
     if (std.mem.eql(u8, action, "openLink")) return .{ .open_link = try fields.requiredStringOrError(allocator, object, "url", error.StepMissingUrl) };
+    if (std.mem.eql(u8, action, "setLocation")) return .{ .set_location = .{
+        .latitude = try parseLatitude(object),
+        .longitude = try parseLongitude(object),
+    } };
     if (std.mem.eql(u8, action, "tap")) return .{ .tap = try fields.parseSelectorField(allocator, object) };
     if (std.mem.eql(u8, action, "typeText")) {
         const wanted = if (object.get("selector")) |selector_value| try selector.parseFromJson(allocator, selector_value) else null;
@@ -342,6 +352,18 @@ fn parseRawStep(allocator: std.mem.Allocator, object: std.json.ObjectMap) anyerr
     return error.unknownScenarioAction;
 }
 
+fn parseLatitude(object: std.json.ObjectMap) !f64 {
+    const latitude = try fields.requiredF64OrError(object, "latitude", error.StepMissingLatitude, error.StepLatitudeMustBeNumber);
+    if (latitude < -90.0 or latitude > 90.0) return error.StepLatitudeOutOfRange;
+    return latitude;
+}
+
+fn parseLongitude(object: std.json.ObjectMap) !f64 {
+    const longitude = try fields.requiredF64OrError(object, "longitude", error.StepMissingLongitude, error.StepLongitudeMustBeNumber);
+    if (longitude < -180.0 or longitude > 180.0) return error.StepLongitudeOutOfRange;
+    return longitude;
+}
+
 fn appendParsedSteps(allocator: std.mem.Allocator, steps: *std.ArrayList(Step), value: std.json.Value) anyerror!void {
     if (value != .array) return error.ScenarioStepsMustBeArray;
     for (value.array.items) |step_value| {
@@ -373,3 +395,27 @@ fn optionalTimeoutMs(object: std.json.ObjectMap) !?u64 {
     if (object.get("timeoutMs") == null) return null;
     return try fields.optionalU64(object, "timeoutMs", 0);
 }
+
+test "parses setLocation with latitude and longitude" {
+    const allocator = std.testing.allocator;
+    const script_json =
+        \\{
+        \\  "name": "set location smoke",
+        \\  "steps": [
+        \\    {"action": "setLocation", "latitude": 51.5074, "longitude": -0.1278}
+        \\  ]
+        \\}
+    ;
+
+    const script = try parseSlice(allocator, script_json);
+    defer script.deinit(allocator);
+
+    try std.testing.expectEqual(@as(usize, 1), script.steps.len);
+    switch (script.steps[0]) {
+        .set_location => |location| {
+            try std.testing.expectApproxEqAbs(@as(f64, 51.5074), location.latitude, 0.000001);
+            try std.testing.expectApproxEqAbs(@as(f64, -0.1278), location.longitude, 0.000001);
+        },
+        else => return error.ExpectedSetLocationStep,
+    }
+}

package/src/scenario_fields.zig

@@ -21,6 +21,10 @@ pub fn requiredI32OrError(object: std.json.ObjectMap, key: []const u8, missing_e
     return try json_fields.requiredI32FromObject(object, key, missing_error, error.RequiredFieldMustBeInteger);
 }
 
+pub fn requiredF64OrError(object: std.json.ObjectMap, key: []const u8, missing_error: anyerror, type_error: anyerror) !f64 {
+    return try json_fields.requiredF64FromObject(object, key, missing_error, type_error);
+}
+
 pub fn optionalU64(object: std.json.ObjectMap, key: []const u8, default_value: u64) !u64 {
     return try json_fields.optionalU64FromObject(object, key, default_value, error.OptionalFieldMustBeInteger);
 }

package/src/validation.zig

@@ -109,6 +109,14 @@ fn diagnoseFailure(allocator: std.mem.Allocator, content: []const u8, err: anyer
         => try pathDiagnostic(allocator, content, "$.steps[].x2", "x2"),
         error.StepMissingY2,
         => try pathDiagnostic(allocator, content, "$.steps[].y2", "y2"),
+        error.StepMissingLatitude,
+        error.StepLatitudeMustBeNumber,
+        error.StepLatitudeOutOfRange,
+        => try pathDiagnostic(allocator, content, "$.steps[].latitude", "latitude"),
+        error.StepMissingLongitude,
+        error.StepLongitudeMustBeNumber,
+        error.StepLongitudeOutOfRange,
+        => try pathDiagnostic(allocator, content, "$.steps[].longitude", "longitude"),
         error.MissingSelector,
         error.StepMissingSelector,
         error.SelectorMustNotBeEmpty,

package/src/version.zig

@@ -1,4 +1,4 @@
-pub const runner_version = "0.2.12";
+pub const runner_version = "0.2.14";
 pub const protocol_version = "2026-04-28";
 pub const protocol_min_compatible_version = "2026-04-28";
 pub const protocol_stability = "dev-preview";