zig-mobile-runner 0.1.0

package/scripts/compare-benchmarks.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import math
+import shlex
+import statistics
+import sys
+import time
+from collections import defaultdict
+from pathlib import Path
+
+CONTEXT_FIELDS = ("platform", "device", "appId", "scenario", "appBuild")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Compare benchmark JSONL rows for two runner labels.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            "--evidence-out requires --min-candidate-pass-rate, "
+            "--max-candidate-failures, --min-mean-speedup, and "
+            "--min-p95-speedup so market-claim evidence includes explicit gates."
+        ),
+    )
+    parser.add_argument("--results", required=True, help="Path to a benchmark results.jsonl file.")
+    parser.add_argument("--candidate", default="zmr", help="Candidate tool label. Default: zmr.")
+    parser.add_argument("--baseline", required=True, help="Baseline tool label to compare against.")
+    parser.add_argument("--format", choices=("markdown", "json"), default="markdown", help="Output format.")
+    parser.add_argument("--out", help="Optional output file. Defaults to stdout.")
+    parser.add_argument("--min-candidate-pass-rate", type=float, help="Minimum candidate pass rate percentage.")
+    parser.add_argument("--max-candidate-failures", type=int, help="Maximum allowed candidate failures.")
+    parser.add_argument("--min-mean-speedup", type=float, help="Minimum required mean speedup versus baseline.")
+    parser.add_argument("--min-p95-speedup", type=float, help="Minimum required p95 speedup versus baseline.")
+    parser.add_argument("--evidence-out", help="Optional JSONL file to append a market-claim readiness evidence row.")
+    args = parser.parse_args()
+    for name in (
+        "min_candidate_pass_rate",
+        "max_candidate_failures",
+        "min_mean_speedup",
+        "min_p95_speedup",
+    ):
+        value = getattr(args, name)
+        if value is not None and value < 0:
+            parser.error(f"--{name.replace('_', '-')} must be non-negative")
+    if args.evidence_out:
+        missing_gate_args = [
+            f"--{name.replace('_', '-')}"
+            for name in (
+                "min_candidate_pass_rate",
+                "max_candidate_failures",
+                "min_mean_speedup",
+                "min_p95_speedup",
+            )
+            if getattr(args, name) is None
+        ]
+        if missing_gate_args:
+            parser.error(
+                "; ".join(f"{name} is required with --evidence-out" for name in missing_gate_args)
+            )
+    return args
+
+
+def is_pass(row):
+    if row.get("status") != "ok":
+        return False
+    trace_status = row.get("traceStatus")
+    return trace_status in (None, "passed")
+
+
+def p95(durations):
+    if not durations:
+        return 0
+    ordered = sorted(durations)
+    index = max(0, math.ceil(len(ordered) * 0.95) - 1)
+    return ordered[index]
+
+
+def read_rows(path):
+    rows = []
+    with Path(path).open(encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise SystemExit(f"{path}:{line_number}: invalid json: {exc}") from exc
+            if not isinstance(row, dict):
+                raise SystemExit(f"{path}:{line_number}: expected object row")
+            rows.append(row)
+    return rows
+
+
+def summarize(tool, rows):
+    durations = [int(row.get("durationMs", 0)) for row in rows]
+    failures = [row for row in rows if not is_pass(row)]
+    passed = len(rows) - len(failures)
+    pass_rate = (passed / len(rows) * 100.0) if rows else 0.0
+    mean_ms = round(statistics.mean(durations)) if durations else 0
+    return {
+        "tool": tool,
+        "runs": len(rows),
+        "passed": passed,
+        "failures": len(failures),
+        "passRate": pass_rate,
+        "meanMs": mean_ms,
+        "p95Ms": p95(durations),
+    }
+
+
+def ratio(baseline_value, candidate_value):
+    if baseline_value <= 0 or candidate_value <= 0:
+        return None
+    return baseline_value / candidate_value
+
+
+def percent_delta(candidate_value, baseline_value):
+    if baseline_value <= 0:
+        return None
+    return ((candidate_value - baseline_value) / baseline_value) * 100.0
+
+
+def comparison(candidate, baseline):
+    return {
+        "candidate": candidate,
+        "baseline": baseline,
+        "meanSpeedup": ratio(baseline["meanMs"], candidate["meanMs"]),
+        "p95Speedup": ratio(baseline["p95Ms"], candidate["p95Ms"]),
+        "meanDeltaPct": percent_delta(candidate["meanMs"], baseline["meanMs"]),
+        "p95DeltaPct": percent_delta(candidate["p95Ms"], baseline["p95Ms"]),
+    }
+
+
+def benchmark_context(candidate_rows, baseline_rows):
+    rows = candidate_rows + baseline_rows
+    context = {}
+    problems = []
+    for field in CONTEXT_FIELDS:
+        values = [str(row.get(field, "")).strip() for row in rows]
+        concrete = [value for value in values if value]
+        unique = sorted(set(concrete))
+        if len(concrete) != len(values):
+            problems.append(f"{field} missing")
+        elif len(unique) != 1:
+            problems.append(f"{field} mismatch: {', '.join(unique)}")
+        else:
+            context[field] = unique[0]
+    return {
+        "sameContext": not problems,
+        "context": context,
+        "contextProblems": problems,
+    }
+
+
+def format_ratio(value):
+    return "n/a" if value is None else f"{value:.2f}x"
+
+
+def format_pct(value):
+    return "n/a" if value is None else f"{value:+.1f}%"
+
+
+def markdown_report(data):
+    candidate = data["candidate"]
+    baseline = data["baseline"]
+    lines = [
+        "# Benchmark Comparison",
+        "",
+        "| Tool | Runs | Pass rate | Failures | Mean ms | P95 ms |",
+        "| --- | ---: | ---: | ---: | ---: | ---: |",
+        f"| {candidate['tool']} | {candidate['runs']} | {candidate['passRate']:.2f}% | {candidate['failures']} | {candidate['meanMs']} | {candidate['p95Ms']} |",
+        f"| {baseline['tool']} | {baseline['runs']} | {baseline['passRate']:.2f}% | {baseline['failures']} | {baseline['meanMs']} | {baseline['p95Ms']} |",
+        "",
+        f"- Mean speedup: {format_ratio(data['meanSpeedup'])} ({format_pct(data['meanDeltaPct'])} candidate vs baseline)",
+        f"- P95 speedup: {format_ratio(data['p95Speedup'])} ({format_pct(data['p95DeltaPct'])} candidate vs baseline)",
+        f"- Same benchmark context: {'yes' if data.get('sameContext') else 'no'}",
+        "",
+        "Interpretation: negative deltas mean the candidate was faster for that metric. Compare only runs collected on the same host, device state, app build, and scenario.",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+def gate_failures(data, args):
+    failures = []
+    candidate = data["candidate"]
+    baseline = data["baseline"]
+    if args.evidence_out and candidate["runs"] < 20:
+        failures.append(f"candidateRuns {candidate['runs']} below minimum 20")
+    if args.evidence_out and baseline["runs"] < 20:
+        failures.append(f"baselineRuns {baseline['runs']} below minimum 20")
+    if args.min_candidate_pass_rate is not None and candidate["passRate"] < args.min_candidate_pass_rate:
+        failures.append(
+            f"candidate passRate {candidate['passRate']:.2f}% below minimum {args.min_candidate_pass_rate:.2f}%"
+        )
+    if args.max_candidate_failures is not None and candidate["failures"] > args.max_candidate_failures:
+        failures.append(
+            f"candidate failures={candidate['failures']} above maximum {args.max_candidate_failures}"
+        )
+    if args.min_mean_speedup is not None:
+        speedup = data["meanSpeedup"]
+        if speedup is None or speedup < args.min_mean_speedup:
+            actual = "n/a" if speedup is None else f"{speedup:.2f}x"
+            failures.append(f"meanSpeedup {actual} below minimum {args.min_mean_speedup:.2f}x")
+    if args.min_p95_speedup is not None:
+        speedup = data["p95Speedup"]
+        if speedup is None or speedup < args.min_p95_speedup:
+            actual = "n/a" if speedup is None else f"{speedup:.2f}x"
+            failures.append(f"p95Speedup {actual} below minimum {args.min_p95_speedup:.2f}x")
+    if args.evidence_out and not data.get("sameContext"):
+        details = "; ".join(data.get("contextProblems", [])) or "missing context"
+        failures.append(f"same benchmark context evidence required ({details})")
+    return failures
+
+
+def write_evidence(args, data, failures, duration_ms):
+    if not args.evidence_out:
+        return
+    path = Path(args.evidence_out)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    row = {
+        "name": "competitive benchmark comparison",
+        "status": "failed" if failures else "passed",
+        "durationMs": duration_ms,
+        "command": " ".join(shlex.quote(part) for part in sys.argv),
+        "candidate": args.candidate,
+        "baseline": args.baseline,
+        "results": args.results,
+        "minCandidatePassRate": args.min_candidate_pass_rate,
+        "maxCandidateFailures": args.max_candidate_failures,
+        "minMeanSpeedup": args.min_mean_speedup,
+        "minP95Speedup": args.min_p95_speedup,
+        "candidateRuns": data["candidate"]["runs"],
+        "baselineRuns": data["baseline"]["runs"],
+        "candidatePassRate": data["candidate"]["passRate"],
+        "candidateFailures": data["candidate"]["failures"],
+        "meanSpeedup": data["meanSpeedup"],
+        "p95Speedup": data["p95Speedup"],
+        "sameContext": data["sameContext"],
+        "context": data["context"],
+    }
+    if failures:
+        row["error"] = "; ".join(failures)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, sort_keys=True, separators=(",", ":")) + "\n")
+
+
+def main():
+    started = time.monotonic()
+    args = parse_args()
+    rows = read_rows(args.results)
+    by_tool = defaultdict(list)
+    for row in rows:
+        by_tool[str(row.get("tool", "unknown"))].append(row)
+
+    missing = [tool for tool in (args.candidate, args.baseline) if tool not in by_tool]
+    if missing:
+        print(f"missing benchmark rows for: {', '.join(missing)}", file=sys.stderr)
+        return 2
+
+    data = comparison(
+        summarize(args.candidate, by_tool[args.candidate]),
+        summarize(args.baseline, by_tool[args.baseline]),
+    )
+    data.update(benchmark_context(by_tool[args.candidate], by_tool[args.baseline]))
+
+    if args.format == "json":
+        output = json.dumps(data, sort_keys=True) + "\n"
+    else:
+        output = markdown_report(data)
+
+    if args.out:
+        Path(args.out).write_text(output, encoding="utf-8")
+    else:
+        sys.stdout.write(output)
+
+    failures = gate_failures(data, args)
+    duration_ms = round((time.monotonic() - started) * 1000)
+    write_evidence(args, data, failures, duration_ms)
+    if failures:
+        for failure in failures:
+            print(f"benchmark comparison gate failed: {failure}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/create-android-demo-app.sh

@@ -0,0 +1,342 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+OUT=""
+APP_ID="com.example.mobiletest"
+API="35"
+BUILD_TOOLS="35.0.1"
+ANDROID_SDK="${ANDROID_HOME:-$HOME/Library/Android/sdk}"
+DRY_RUN=0
+
+usage() {
+  cat <<'USAGE'
+Usage:
+  scripts/create-android-demo-app.sh --out <dir> [options]
+
+Creates a small public native Android demo app and a matching .zmr smoke
+scenario. The generated app is intentionally generic and contains no private
+app references. It uses Android SDK command-line tools directly, so it does not
+need Gradle or network access.
+
+Options:
+  --out <dir>             Output app repository directory. Required.
+  --app-id <id>           Android application id. Default: com.example.mobiletest.
+  --api <level>           Android platform API level. Default: 35.
+  --build-tools <ver>     Android build-tools version. Default: 35.0.1.
+  --android-sdk <path>    Android SDK root. Default: ANDROID_HOME or ~/Library/Android/sdk.
+  --dry-run               Print commands without executing them.
+  -h, --help              Show this help.
+
+After generation:
+  adb install -r <dir>/build/app-debug.apk
+  zmr run <dir>/.zmr/android-smoke.json --device emulator-5554 --app-id com.example.mobiletest --trace-dir <dir>/traces/android-demo
+USAGE
+}
+
+die() {
+  echo "error: $*" >&2
+  exit 2
+}
+
+require_value() {
+  local flag="$1"
+  local value="${2-}"
+  if [[ -z "$value" || "$value" == --* ]]; then
+    die "$flag requires a value"
+  fi
+  printf '%s\n' "$value"
+}
+
+quote_cmd() {
+  local quoted=()
+  local arg
+  for arg in "$@"; do
+    quoted+=("$(printf '%q' "$arg")")
+  done
+  printf '%s\n' "${quoted[*]}"
+}
+
+run() {
+  echo "+ $(quote_cmd "$@")"
+  if [[ "$DRY_RUN" -eq 0 ]]; then
+    "$@"
+  fi
+}
+
+write_file() {
+  local path="$1"
+  local content="$2"
+  echo "+ write $path"
+  if [[ "$DRY_RUN" -eq 0 ]]; then
+    mkdir -p "$(dirname "$path")"
+    printf '%s' "$content" > "$path"
+  fi
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --out)
+      OUT="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --app-id)
+      APP_ID="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --api)
+      API="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --build-tools)
+      BUILD_TOOLS="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --android-sdk)
+      ANDROID_SDK="$(require_value "$1" "${2-}")"
+      shift 2
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+[[ -n "$OUT" ]] || die "--out is required"
+[[ "$APP_ID" =~ ^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z][A-Za-z0-9_]*)+$ ]] || die "--app-id must be a Java-style package id"
+[[ "$API" =~ ^[0-9]+$ ]] || die "--api must be an integer"
+[[ -n "$BUILD_TOOLS" ]] || die "--build-tools must be non-empty"
+
+if [[ "$OUT" != /* ]]; then
+  OUT="$(pwd -P)/$OUT"
+fi
+
+ANDROID_DIR="$OUT/android"
+SRC_DIR="$ANDROID_DIR/src/dev/zmr/demo"
+RES_DIR="$ANDROID_DIR/res"
+BUILD_DIR="$OUT/build"
+GEN_DIR="$BUILD_DIR/generated"
+CLASSES_DIR="$BUILD_DIR/classes"
+DEX_DIR="$BUILD_DIR/dex"
+COMPILED_RES="$BUILD_DIR/compiled-res.zip"
+UNSIGNED_APK="$BUILD_DIR/app-unsigned.apk"
+SIGNED_APK="$BUILD_DIR/app-debug.apk"
+KEYSTORE="$BUILD_DIR/debug.keystore"
+ANDROID_JAR="$ANDROID_SDK/platforms/android-$API/android.jar"
+BUILD_TOOLS_DIR="$ANDROID_SDK/build-tools/$BUILD_TOOLS"
+AAPT2="$BUILD_TOOLS_DIR/aapt2"
+D8="$BUILD_TOOLS_DIR/d8"
+APKSIGNER="$BUILD_TOOLS_DIR/apksigner"
+ZMR_BIN="${ZMR_BIN:-}"
+
+echo "Android demo app: $OUT"
+echo "Android demo APK: $SIGNED_APK"
+if [[ "$DRY_RUN" -eq 1 ]]; then
+  echo "DRY RUN: commands will be printed but not executed"
+fi
+
+if [[ "$DRY_RUN" -eq 0 ]]; then
+  [[ -f "$ANDROID_JAR" ]] || die "android.jar not found: $ANDROID_JAR"
+  [[ -x "$AAPT2" ]] || die "aapt2 not found: $AAPT2"
+  [[ -x "$D8" ]] || die "d8 not found: $D8"
+  [[ -x "$APKSIGNER" ]] || die "apksigner not found: $APKSIGNER"
+  command -v javac >/dev/null 2>&1 || die "javac is required"
+  command -v keytool >/dev/null 2>&1 || die "keytool is required"
+  command -v zip >/dev/null 2>&1 || die "zip is required"
+fi
+
+if [[ "$DRY_RUN" -eq 0 ]]; then
+  rm -rf "$BUILD_DIR"
+fi
+run mkdir -p "$SRC_DIR" "$RES_DIR/values" "$BUILD_DIR" "$GEN_DIR" "$CLASSES_DIR" "$DEX_DIR" "$OUT/.zmr"
+
+write_file "$ANDROID_DIR/AndroidManifest.xml" "$(cat <<EOF
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="$APP_ID">
+  <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="$API" />
+  <application android:theme="@style/AppTheme" android:label="ZMR Android Demo" android:allowBackup="false" android:supportsRtl="true">
+    <activity android:name="dev.zmr.demo.MainActivity" android:exported="true">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+        <data android:scheme="exampleapp" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>
+EOF
+)"
+
+write_file "$RES_DIR/values/styles.xml" "$(cat <<'EOF'
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <style name="AppTheme" parent="android:style/Theme.Material.Light.NoActionBar">
+    <item name="android:fontFamily">sans</item>
+    <item name="android:windowLightStatusBar">true</item>
+    <item name="android:colorAccent">#2563EB</item>
+  </style>
+</resources>
+EOF
+)"
+
+write_file "$RES_DIR/values/ids.xml" "$(cat <<'EOF'
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <item name="demo_title" type="id" />
+  <item name="continue_button" type="id" />
+  <item name="demo_input" type="id" />
+  <item name="demo_status" type="id" />
+</resources>
+EOF
+)"
+
+write_file "$SRC_DIR/MainActivity.java" "$(cat <<EOF
+package dev.zmr.demo;
+
+import android.app.Activity;
+import android.graphics.Color;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+import android.view.Gravity;
+import android.view.inputmethod.InputMethodManager;
+import android.content.Context;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+public class MainActivity extends Activity {
+    private TextView status;
+    private EditText input;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        LinearLayout layout = new LinearLayout(this);
+        layout.setOrientation(LinearLayout.VERTICAL);
+        layout.setGravity(Gravity.CENTER_HORIZONTAL);
+        int padding = dp(24);
+        layout.setPadding(padding, padding, padding, padding);
+
+        TextView title = new TextView(this);
+        title.setId(R.id.demo_title);
+        title.setText("ZMR Android Demo");
+        title.setTextSize(24);
+        title.setTextColor(Color.rgb(17, 24, 39));
+        title.setGravity(Gravity.CENTER);
+        layout.addView(title, new LinearLayout.LayoutParams(-1, -2));
+
+        Button button = new Button(this);
+        button.setId(R.id.continue_button);
+        button.setText("Continue");
+        layout.addView(button, new LinearLayout.LayoutParams(-1, dp(56)));
+
+        input = new EditText(this);
+        input.setId(R.id.demo_input);
+        input.setHint("Type here");
+        input.setSingleLine(true);
+        layout.addView(input, new LinearLayout.LayoutParams(-1, dp(56)));
+
+        status = new TextView(this);
+        status.setId(R.id.demo_status);
+        status.setText("Ready");
+        status.setTextSize(18);
+        status.setGravity(Gravity.CENTER);
+        layout.addView(status, new LinearLayout.LayoutParams(-1, -2));
+
+        button.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                status.setText("Continue tapped");
+                input.requestFocus();
+                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+                if (imm != null) {
+                    imm.showSoftInput(input, InputMethodManager.SHOW_IMPLICIT);
+                }
+            }
+        });
+
+        Uri data = getIntent().getData();
+        if (data != null) {
+            status.setText("Deep link opened");
+        }
+
+        setContentView(layout);
+    }
+
+    private int dp(int value) {
+        return (int) (value * getResources().getDisplayMetrics().density + 0.5f);
+    }
+}
+EOF
+)"
+
+write_file "$OUT/.zmr/android-smoke.json" "$(cat <<EOF
+{
+  "name": "ZMR Android demo smoke",
+  "appId": "$APP_ID",
+  "steps": [
+    { "action": "launch" },
+    { "action": "waitVisible", "selector": { "text": "ZMR Android Demo" }, "timeoutMs": 30000 },
+    { "action": "tap", "selector": { "resourceId": "$APP_ID:id/continue_button" } },
+    { "action": "waitVisible", "selector": { "text": "Continue tapped" }, "timeoutMs": 10000 },
+    { "action": "typeText", "selector": { "resourceId": "$APP_ID:id/demo_input" }, "text": "hello from zmr" },
+    { "action": "snapshot" }
+  ]
+}
+EOF
+)"
+
+run "$AAPT2" compile --dir "$RES_DIR" -o "$COMPILED_RES"
+run "$AAPT2" link -o "$UNSIGNED_APK" -I "$ANDROID_JAR" --manifest "$ANDROID_DIR/AndroidManifest.xml" -R "$COMPILED_RES" --java "$GEN_DIR" --custom-package dev.zmr.demo --auto-add-overlay
+run javac -source 1.8 -target 1.8 -bootclasspath "$ANDROID_JAR" -d "$CLASSES_DIR" "$GEN_DIR/dev/zmr/demo/R.java" "$SRC_DIR/MainActivity.java"
+if [[ "$DRY_RUN" -eq 1 ]]; then
+  CLASS_FILES=(
+    "$CLASSES_DIR/dev/zmr/demo/R.class"
+    "$CLASSES_DIR/dev/zmr/demo/MainActivity.class"
+    "$CLASSES_DIR/dev/zmr/demo/MainActivity\$1.class"
+  )
+else
+  CLASS_FILES=()
+  while IFS= read -r class_file; do
+    CLASS_FILES+=("$class_file")
+  done < <(find "$CLASSES_DIR" -name '*.class' -print | sort)
+  [[ "${#CLASS_FILES[@]}" -gt 0 ]] || die "no compiled Java classes found in $CLASSES_DIR"
+fi
+
+run "$D8" --lib "$ANDROID_JAR" --min-api 23 --output "$DEX_DIR" "${CLASS_FILES[@]}"
+run zip -j "$UNSIGNED_APK" "$DEX_DIR/classes.dex"
+run keytool -genkeypair -keystore "$KEYSTORE" -storepass android -keypass android -alias zmrdebug -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=ZMR Android Demo,O=ZMR,C=US"
+run "$APKSIGNER" sign --ks "$KEYSTORE" --ks-key-alias zmrdebug --ks-pass pass:android --key-pass pass:android --out "$SIGNED_APK" "$UNSIGNED_APK"
+if [[ -z "$ZMR_BIN" ]]; then
+  if [[ -x "$ROOT/zig-out/bin/zmr" ]]; then
+    ZMR_BIN="$ROOT/zig-out/bin/zmr"
+  elif command -v zmr >/dev/null 2>&1; then
+    ZMR_BIN="$(command -v zmr)"
+  fi
+fi
+
+if [[ -n "$ZMR_BIN" ]]; then
+  run "$ZMR_BIN" validate "$OUT/.zmr/android-smoke.json"
+else
+  echo "warning: skipped scenario validation because zmr was not found; run 'zmr validate $OUT/.zmr/android-smoke.json' after installation" >&2
+fi
+
+echo "created Android demo app at $OUT"
+echo "apk: $SIGNED_APK"
+echo "scenario: $OUT/.zmr/android-smoke.json"