zig-mobile-runner 0.1.0

package/npm/package-scripts.mjs

@@ -0,0 +1,72 @@
+export function packageScripts(config) {
+  return {
+    "zmr:doctor": config.scripts.doctor,
+    "zmr:schemas": config.scripts.schemas,
+    "zmr:validate": config.scripts.validate,
+    "zmr:android": config.scripts.android,
+    "zmr:android:report": config.scripts.androidReport,
+    "zmr:android:dev-client": config.scripts.androidDevClient,
+    "zmr:android:dev-client:report": config.scripts.androidDevClientReport,
+    "zmr:android:reliability": config.scripts.androidReliability,
+    "zmr:ios": config.scripts.ios,
+    "zmr:ios:report": config.scripts.iosReport,
+    "zmr:ios:dev-client": config.scripts.iosDevClient,
+    "zmr:ios:dev-client:report": config.scripts.iosDevClientReport,
+    "zmr:ios:reliability": config.scripts.iosReliability,
+    "zmr:matrix": config.scripts.matrix,
+    "zmr:pilot": config.scripts.pilotGate,
+    "zmr:readiness": config.scripts.readiness,
+    "zmr:serve": config.scripts.serve,
+    "zmr:mcp": config.scripts.mcp,
+    "zmr:explain": config.scripts.explain,
+    "zmr:export": config.scripts.exportTrace,
+  };
+}
+
+export function applyPackageScripts(pkg, config, { android = true, ios = true } = {}) {
+  pkg.scripts ??= {};
+  const scripts = packageScripts(config);
+  const setScript = (name, value) => {
+    if (value == null) delete pkg.scripts[name];
+    else pkg.scripts[name] = value;
+  };
+
+  setScript("zmr:doctor", scripts["zmr:doctor"]);
+  setScript("zmr:schemas", scripts["zmr:schemas"]);
+  setScript("zmr:validate", scripts["zmr:validate"]);
+  if (android) {
+    setScript("zmr:android", scripts["zmr:android"]);
+    setScript("zmr:android:report", scripts["zmr:android:report"]);
+    setScript("zmr:android:reliability", scripts["zmr:android:reliability"]);
+    setScript("zmr:android:dev-client", config.scripts.androidDevClient);
+    setScript("zmr:android:dev-client:report", config.scripts.androidDevClientReport);
+  } else {
+    setScript("zmr:android", null);
+    setScript("zmr:android:report", null);
+    setScript("zmr:android:reliability", null);
+    setScript("zmr:android:dev-client", null);
+    setScript("zmr:android:dev-client:report", null);
+  }
+  if (ios) {
+    setScript("zmr:ios", scripts["zmr:ios"]);
+    setScript("zmr:ios:report", scripts["zmr:ios:report"]);
+    setScript("zmr:ios:reliability", scripts["zmr:ios:reliability"]);
+    setScript("zmr:ios:dev-client", config.scripts.iosDevClient);
+    setScript("zmr:ios:dev-client:report", config.scripts.iosDevClientReport);
+  } else {
+    setScript("zmr:ios", null);
+    setScript("zmr:ios:report", null);
+    setScript("zmr:ios:reliability", null);
+    setScript("zmr:ios:dev-client", null);
+    setScript("zmr:ios:dev-client:report", null);
+  }
+  if (android || ios) setScript("zmr:matrix", scripts["zmr:matrix"]);
+  else setScript("zmr:matrix", null);
+  setScript("zmr:pilot", scripts["zmr:pilot"]);
+  setScript("zmr:readiness", config.scripts.readiness ? scripts["zmr:readiness"] : null);
+  setScript("zmr:serve", scripts["zmr:serve"]);
+  setScript("zmr:mcp", scripts["zmr:mcp"]);
+  setScript("zmr:explain", scripts["zmr:explain"]);
+  setScript("zmr:export", scripts["zmr:export"]);
+  return pkg;
+}

package/npm/postinstall.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { resolveBinary } from "./index.mjs";
+
+if (resolveBinary()) process.exit(0);
+if (process.env.ZMR_SKIP_POSTINSTALL_BUILD === "1") process.exit(0);
+
+const hasZig = spawnSync("zig", ["version"], { stdio: "ignore" }).status === 0;
+if (!hasZig) {
+  console.warn("zig-mobile-runner: no prebuilt zmr binary found and Zig is not installed.");
+  console.warn("zig-mobile-runner: install a release package with prebuilds, install Zig and run `npm run build:zmr`, or set ZMR_BIN.");
+  process.exit(0);
+}
+
+const result = spawnSync(process.execPath, [new URL("./build-zmr.mjs", import.meta.url).pathname], {
+  stdio: "inherit",
+});
+
+if (result.status !== 0) {
+  console.warn("zig-mobile-runner: postinstall build failed; set ZMR_BIN or run `npm run build:zmr` after fixing Zig.");
+}

package/npm/scaffold.mjs

@@ -0,0 +1,179 @@
+import {
+  agentInstructions,
+} from "./agents.mjs";
+import { appConfig } from "./app-config.mjs";
+import {
+  shellQuote,
+} from "./commands.mjs";
+import {
+  deviceMatrix,
+  scenarioFiles,
+} from "./scenarios.mjs";
+
+export const appScaffoldFiles = [
+  "config.json",
+  "android-smoke.json",
+  "ios-smoke.json",
+  "device-matrix.json",
+  "AGENTS.md",
+];
+
+export const appScriptNames = [
+  "doctor",
+  "schemas",
+  "validate",
+  "android",
+  "androidReport",
+  "androidDevClient",
+  "androidDevClientReport",
+  "androidReliability",
+  "ios",
+  "iosReport",
+  "iosDevClient",
+  "iosDevClientReport",
+  "iosReliability",
+  "matrix",
+  "pilotGate",
+  "readiness",
+  "serve",
+  "mcp",
+  "explain",
+  "exportTrace",
+];
+
+export {
+  agentInstructions,
+  nextStepCommands,
+} from "./agents.mjs";
+export { appConfig } from "./app-config.mjs";
+export {
+  devClientRunCommand,
+  devClientReportCommand,
+  matrixCommand,
+  pilotGateCommand,
+  readinessCommand,
+  reliabilityCommand,
+  shellJoin,
+  shellQuote,
+  smokeReportCommand,
+  smokeRunCommand,
+  validateCommand,
+} from "./commands.mjs";
+export {
+  devClientScenario,
+  deviceMatrix,
+  scenarioFiles,
+  smokeScenario,
+} from "./scenarios.mjs";
+export {
+  applyPackageScripts,
+  packageScripts,
+} from "./package-scripts.mjs";
+export {
+  ensureTraceIgnore,
+  writeJsonFile,
+  writePackageScripts,
+  writeScaffoldFiles,
+  writeTextFile,
+} from "./generated-files.mjs";
+export {
+  formatWizardCheckResult,
+  parseScaffoldArgs,
+  readOptionValue,
+  wizardChecks,
+} from "./setup.mjs";
+
+export function scaffoldPlan(appId, { android = true, ios = true, androidShim = "", iosShim = "", expoDevClientScheme = "", packageScripts = false } = {}) {
+  const config = appConfig(appId, { android, ios, androidShim, iosShim, expoDevClientScheme });
+  return {
+    config,
+    files: [
+      { kind: "json", path: "config.json", value: config, overwrite: true },
+      ...scenarioFiles(appId, { android, ios, expoDevClientScheme }).map((file) => ({
+        kind: "json",
+        path: file.path,
+        value: file.scenario,
+        overwrite: false,
+      })),
+      {
+        kind: "json",
+        path: "device-matrix.json",
+        value: deviceMatrix(appId, android, ios, androidShim, iosShim),
+        overwrite: true,
+      },
+      {
+        kind: "text",
+        path: "AGENTS.md",
+        value: agentInstructions(appId, { android, ios, packageScripts, scripts: config.scripts }),
+        overwrite: true,
+      },
+    ],
+  };
+}
+
+export function scaffoldFiles(appId, options = {}) {
+  return scaffoldPlan(appId, options).files;
+}
+
+export function appInitOutput(appRoot, appId, plan, { packageScripts = false } = {}) {
+  const filePath = (name) => pathJoin(appRoot, ".zmr", name);
+  const configPath = filePath("config.json");
+  const generatedPath = (name) => plan.files.some((file) => file.path === name) ? filePath(name) : undefined;
+  const androidScenarioPath = generatedPath("android-smoke.json");
+  const iosScenarioPath = generatedPath("ios-smoke.json");
+  const androidDevClientScenarioPath = generatedPath("android-dev-client-smoke.json");
+  const iosDevClientScenarioPath = generatedPath("ios-dev-client-open-link.json");
+  const scenarioPaths = plan.files
+    .filter((file) => file.kind === "json" && file.path !== "config.json" && file.path !== "device-matrix.json")
+    .map((file) => filePath(file.path));
+  const scriptNames = appScriptNames.filter((name) => plan.config.scripts[name] != null);
+  const doctorCommand = packageScripts ? "npm run zmr:doctor" : `zmr doctor --strict --json --config ${shellQuote(configPath)}`;
+  const schemaCommand = packageScripts ? "npm run zmr:schemas" : "zmr schemas --json";
+  const validateCommands = packageScripts
+    ? ["npm run zmr:validate"]
+    : scenarioPaths.map((scenarioPath) => `zmr validate --json ${shellQuote(scenarioPath)}`);
+  const smokeCommands = [];
+  if (packageScripts) {
+    if (androidScenarioPath) smokeCommands.push("npm run zmr:android");
+    if (iosScenarioPath) smokeCommands.push("npm run zmr:ios");
+  } else {
+    if (androidScenarioPath) {
+      smokeCommands.push(
+        `zmr run ${shellQuote(androidScenarioPath)} --device emulator-5554 --trace-dir ${shellQuote(pathJoin(appRoot, "traces", "zmr-android"))}`,
+      );
+    }
+    if (iosScenarioPath) {
+      smokeCommands.push(
+        `zmr run ${shellQuote(iosScenarioPath)} --platform ios --device booted --trace-dir ${shellQuote(pathJoin(appRoot, "traces", "zmr-ios"))}`,
+      );
+    }
+  }
+  const output = {
+    ok: true,
+    mode: "app",
+    dir: appRoot,
+    appId,
+    created: plan.files.map((file) => filePath(file.path)),
+    configPath,
+    deviceMatrixPath: filePath("device-matrix.json"),
+    agentInstructionsPath: filePath("AGENTS.md"),
+    next: doctorCommand,
+    nextCommands: [
+      doctorCommand,
+      schemaCommand,
+      ...validateCommands,
+    ],
+    smokeCommands,
+    scriptCount: scriptNames.length,
+    scriptNames,
+  };
+  if (androidScenarioPath) output.androidScenarioPath = androidScenarioPath;
+  if (iosScenarioPath) output.iosScenarioPath = iosScenarioPath;
+  if (androidDevClientScenarioPath) output.androidDevClientScenarioPath = androidDevClientScenarioPath;
+  if (iosDevClientScenarioPath) output.iosDevClientScenarioPath = iosDevClientScenarioPath;
+  return output;
+}
+
+function pathJoin(...parts) {
+  return parts.join("/").replace(/\/+/g, "/");
+}

package/npm/scenarios.mjs

@@ -0,0 +1,93 @@
+export function deviceMatrix(appId, android = true, ios = true, androidShim = "", iosShim = "") {
+  const devices = [];
+  if (android) {
+    const androidDevice = {
+      name: "android-emulator",
+      platform: "android",
+      serial: "emulator-5554",
+      scenario: ".zmr/android-smoke.json",
+      adb: "adb",
+    };
+    if (androidShim) androidDevice.androidShim = androidShim;
+    devices.push(androidDevice);
+  }
+  if (ios) {
+    const iosDevice = {
+      name: "ios-simulator",
+      platform: "ios",
+      iosDeviceType: "simulator",
+      serial: "booted",
+      scenario: ".zmr/ios-smoke.json",
+      xcrun: "xcrun",
+    };
+    if (iosShim) iosDevice.iosShim = iosShim;
+    devices.push(iosDevice);
+  }
+  return {
+    runs: 1,
+    appId,
+    devices,
+  };
+}
+
+export function smokeScenario(name, appId) {
+  return {
+    name,
+    appId,
+    steps: [
+      { action: "launch" },
+      { action: "assertHealthy" },
+      { action: "snapshot" },
+    ],
+  };
+}
+
+export function scenarioFiles(appId, { android = true, ios = true, expoDevClientScheme = "" } = {}) {
+  const files = [];
+  if (android) files.push({ path: "android-smoke.json", scenario: smokeScenario("Android smoke", appId) });
+  if (ios) files.push({ path: "ios-smoke.json", scenario: smokeScenario("iOS smoke", appId) });
+  if (expoDevClientScheme) {
+    if (android) {
+      files.push({
+        path: "android-dev-client-smoke.json",
+        scenario: devClientScenario("Android Expo dev-client smoke", appId, expoDevClientScheme, "http://10.0.2.2:8081"),
+      });
+    }
+    if (ios) {
+      files.push({
+        path: "ios-dev-client-open-link.json",
+        scenario: devClientScenario("iOS Expo dev-client open-link smoke", appId, expoDevClientScheme, "http://127.0.0.1:8081"),
+      });
+    }
+  }
+  return files;
+}
+
+export function devClientScenario(name, appId, scheme, metroUrl) {
+  return {
+    name,
+    appId,
+    steps: [
+      { action: "stop" },
+      {
+        action: "openLink",
+        url: `exp+${scheme}://expo-development-client/?url=${encodeURIComponent(metroUrl)}`,
+      },
+      {
+        action: "waitAny",
+        selectors: [
+          { textContains: "Downloading" },
+          { textContains: "Connected to:" },
+          { textContains: "Reload" },
+          { textContains: "Continue" },
+          { textContains: "Sign in" },
+          { textContains: "Home" },
+          { textContains: "Unable to load" },
+        ],
+        timeoutMs: 120000,
+      },
+      { action: "assertHealthy" },
+      { action: "snapshot" },
+    ],
+  };
+}

package/npm/setup.mjs

@@ -0,0 +1,69 @@
+export function readOptionValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value`);
+  }
+  return value;
+}
+
+export function parseScaffoldArgs(args, { packageJson = false, wizard = false } = {}) {
+  const parsed = {
+    dir: process.cwd(),
+    appId: "com.example.mobiletest",
+    android: false,
+    androidShim: "",
+    ios: false,
+    iosShim: "",
+    expoDevClientScheme: "",
+  };
+  if (packageJson || wizard) {
+    parsed.packageJson = false;
+  }
+  if (wizard) {
+    parsed.yes = false;
+  }
+  parsed.json = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") return { help: true };
+    if (arg === "--dir") parsed.dir = readOptionValue(args, ++i, arg);
+    else if (arg === "--app-id") parsed.appId = readOptionValue(args, ++i, arg);
+    else if (arg === "--android") parsed.android = true;
+    else if (arg === "--android-shim") parsed.androidShim = readOptionValue(args, ++i, arg);
+    else if (arg === "--ios") parsed.ios = true;
+    else if (arg === "--ios-shim") parsed.iosShim = readOptionValue(args, ++i, arg);
+    else if (arg === "--expo-dev-client-scheme") parsed.expoDevClientScheme = readOptionValue(args, ++i, arg);
+    else if (arg === "--json") parsed.json = true;
+    else if ((packageJson || wizard) && arg === "--package-json") parsed.packageJson = true;
+    else if (wizard && (arg === "--yes" || arg === "-y")) parsed.yes = true;
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+
+  if (!parsed.android && !parsed.ios) {
+    parsed.android = true;
+    parsed.ios = true;
+  }
+  return parsed;
+}
+
+export function wizardChecks({ android = true, ios = true, nodePath = process.execPath, zmrPath = "zmr" } = {}) {
+  const checks = [
+    { label: "node", command: nodePath, args: ["--version"], required: true },
+    { label: "zmr", command: zmrPath || "zmr", args: ["version"], required: true },
+  ];
+  if (android) checks.push({ label: "adb", command: "adb", args: ["version"], required: false });
+  if (ios) checks.push({ label: "xcrun", command: "xcrun", args: ["--version"], required: false });
+  checks.push({ label: "zig", command: "zig", args: ["version"], required: false });
+  return checks;
+}
+
+export function formatWizardCheckResult(label, result, { required = false } = {}) {
+  if (result.status === 0) {
+    const firstLine = (result.stdout || result.stderr || "").split(/\r?\n/).find(Boolean) ?? "ok";
+    return `${label}\tok\t${firstLine}`;
+  }
+  const status = required ? "missing" : "warning";
+  const detail = result.error?.message ?? `exit ${result.status ?? "unknown"}`;
+  return `${label}\t${status}\t${detail}`;
+}

package/npm/wizard.mjs

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { resolveBinary } from "./index.mjs";
+import {
+  appInitOutput,
+  ensureTraceIgnore,
+  formatWizardCheckResult,
+  nextStepCommands,
+  parseScaffoldArgs,
+  scaffoldPlan,
+  writePackageScripts,
+  writeScaffoldFiles,
+  wizardChecks,
+} from "./scaffold.mjs";
+
+const options = parseArgs(process.argv.slice(2));
+
+if (!options.json) {
+  console.log("ZMR setup wizard");
+  console.log("================");
+}
+
+if (!options.yes && !options.json) {
+  await promptForMissingOptions(options);
+}
+
+const appRoot = path.resolve(options.dir);
+
+if (!options.json) {
+  console.log("");
+  console.log("Checking necessities");
+  for (const checkSpec of wizardChecks({
+    android: options.android,
+    ios: options.ios,
+    nodePath: process.execPath,
+    zmrPath: resolveBinary() ?? "zmr",
+  })) {
+    check(checkSpec.label, checkSpec.command, checkSpec.args, { required: checkSpec.required });
+  }
+}
+
+const plan = scaffoldPlan(options.appId, {
+  android: options.android,
+  ios: options.ios,
+  androidShim: options.androidShim,
+  iosShim: options.iosShim,
+  expoDevClientScheme: options.expoDevClientScheme,
+  packageScripts: options.packageJson,
+});
+const { config, files } = plan;
+for (const result of writeScaffoldFiles(path.join(appRoot, ".zmr"), files, { cwd: appRoot })) {
+  if (!options.json) console.log(`${result.status} ${result.path}`);
+}
+const ignoredPath = ensureTraceIgnore(appRoot, { cwd: appRoot });
+if (ignoredPath && !options.json) console.log(`updated ${ignoredPath}`);
+if (options.packageJson) patchPackageJson(appRoot, options.android, options.ios);
+
+if (options.json) {
+  process.stdout.write(`${JSON.stringify(appInitOutput(appRoot, options.appId, plan, { packageScripts: options.packageJson }))}\n`);
+} else {
+  console.log("");
+  console.log("Next steps");
+  printNextSteps(config.scripts, options);
+}
+
+function parseArgs(args) {
+  try {
+    const parsed = parseScaffoldArgs(args, { wizard: true });
+    if (parsed.help) {
+      usage();
+      process.exit(0);
+    }
+    return parsed;
+  } catch (error) {
+    console.error(error.message);
+    usage();
+    process.exit(2);
+  }
+}
+
+async function promptForMissingOptions(parsed) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    parsed.appId = (await rl.question(`App id [${parsed.appId}]: `)).trim() || parsed.appId;
+    const patch = (await rl.question("Patch package.json scripts? [Y/n]: ")).trim().toLowerCase();
+    parsed.packageJson = patch === "" || patch === "y" || patch === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+function usage() {
+  console.log("Usage: zmr-wizard [--dir <app-root>] [--app-id <id>] [--android] [--android-shim <path>] [--ios] [--ios-shim <path>] [--expo-dev-client-scheme <scheme>] [--package-json] [--yes] [--json]");
+}
+
+function printNextSteps(scripts, parsed) {
+  for (const step of nextStepCommands({ scripts }, {
+    android: parsed.android,
+    ios: parsed.ios,
+    packageScripts: parsed.packageJson,
+  })) {
+    console.log(`  ${step.command}`);
+  }
+}
+
+function check(label, command, args, opts = {}) {
+  const result = spawnSync(command, args, { encoding: "utf8" });
+  console.log(`  ${formatWizardCheckResult(label, result, opts)}`);
+}
+
+function patchPackageJson(root, android, ios) {
+  const result = writePackageScripts(root, config, { android, ios, cwd: root });
+  if (result && !options.json) console.log(`${result.status} ${result.path}`);
+}

package/npm/zmr.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { spawnZmr, missingBinaryMessage } from "./index.mjs";
+
+let child;
+try {
+  child = spawnZmr(process.argv.slice(2), { stdio: "inherit" });
+} catch (error) {
+  console.error(error?.message || missingBinaryMessage());
+  process.exit(127);
+}
+
+child.on("error", (error) => {
+  console.error(error?.message || String(error));
+  process.exit(127);
+});
+
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "zig-mobile-runner",
+  "version": "0.1.0",
+  "description": "Agent-native mobile app test runner powered by Zig.",
+  "main": "npm/index.mjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnmikel/zig-mobile-runner.git"
+  },
+  "bugs": {
+    "url": "https://github.com/johnmikel/zig-mobile-runner/issues"
+  },
+  "homepage": "https://github.com/johnmikel/zig-mobile-runner#readme",
+  "bin": {
+    "zmr": "npm/zmr.mjs",
+    "zmr-init": "npm/init-app.mjs",
+    "zmr-wizard": "npm/wizard.mjs",
+    "zmr-benchmark": "scripts/benchmark.sh",
+    "zmr-benchmark-command": "scripts/benchmark-command.sh",
+    "zmr-compare-benchmarks": "scripts/compare-benchmarks.py",
+    "zmr-device-matrix": "scripts/device-matrix.sh",
+    "zmr-pilot-gate": "scripts/pilot-gate.sh",
+    "zmr-assert-ios-physical-ready": "scripts/assert-ios-physical-ready.sh",
+    "zmr-release-readiness": "scripts/release-readiness.sh",
+    "zmr-install-android-shim": "scripts/install-android-shim.sh",
+    "zmr-install-ios-shim": "scripts/install-ios-shim.sh",
+    "zmr-create-android-demo-app": "scripts/create-android-demo-app.sh",
+    "zmr-create-ios-demo-app": "scripts/create-ios-demo-app.sh",
+    "zmr-demo-android": "scripts/demo-android-real.sh",
+    "zmr-demo-ios": "scripts/demo-ios-real.sh"
+  },
+  "files": [
+    "npm/",
+    "clients/README.md",
+    "go.work",
+    "clients/typescript/",
+    "clients/python/README.md",
+    "clients/python/pyproject.toml",
+    "clients/python/zmr_client.py",
+    "clients/python/examples/",
+    "clients/go/",
+    "!clients/go/**/*_test.go",
+    "clients/rust/Cargo.toml",
+    "clients/rust/Cargo.lock",
+    "clients/rust/README.md",
+    "clients/rust/src/",
+    "clients/rust/examples/",
+    "clients/swift/Package.swift",
+    "clients/swift/README.md",
+    "clients/swift/Sources/",
+    "clients/kotlin/build.gradle.kts",
+    "clients/kotlin/settings.gradle.kts",
+    "clients/kotlin/README.md",
+    "clients/kotlin/src/",
+    "!clients/kotlin/src/test/",
+    "prebuilds/",
+    "src/",
+    "!src/*_tests.zig",
+    "!src/test_harness.zig",
+    "examples/",
+    "schemas/",
+    "skills/",
+    "shims/",
+    "viewer/",
+    "docs/",
+    "scripts/",
+    "!scripts/build-npm-package.sh",
+    "!scripts/build-release.sh",
+    "!scripts/ci-gate.sh",
+    "!scripts/coverage.sh",
+    "!scripts/generate-homebrew-formula.mjs",
+    "!scripts/generate-release-manifest.mjs",
+    "!scripts/generate-release-metadata.mjs",
+    "!scripts/notarize-macos-release.sh",
+    "!scripts/release-candidate.sh",
+    "!scripts/release-gate.sh",
+    "!scripts/release-smoke.sh",
+    "!scripts/sign-macos-release.sh",
+    "!scripts/verify-release-artifacts.sh",
+    "!scripts/__pycache__/",
+    "!scripts/**/*.pyc",
+    "!scripts/_cod[e]x_write_test.txt",
+    "!scripts/python_redirect_test.txt",
+    "build.zig",
+    "build.zig.zon",
+    "README.md",
+    "FEATURES.md",
+    "LICENSE",
+    "SECURITY.md",
+    "CONTRIBUTING.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "postinstall": "node npm/postinstall.mjs",
+    "build:zmr": "node npm/build-zmr.mjs",
+    "pack:npm": "bash scripts/build-npm-package.sh",
+    "zmr:demo": "node npm/zmr.mjs validate examples/demo-fake.json",
+    "test": "node --test tests/viewer-parser.test.mjs tests/npm-scaffold-helpers.test.mjs tests/npm-cli.test.mjs tests/npm-package.test.mjs tests/typescript-client.test.mjs && python3 -W error -m unittest tests/python_client_test.py && bash tests/go-client-test.sh && bash tests/rust-client-test.sh"
+  },
+  "keywords": [
+    "mobile-testing",
+    "android",
+    "ios",
+    "adb",
+    "simctl",
+    "ai-agents",
+    "test-runner",
+    "zig"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}