driftx 0.1.0

package/dist/bin.js

@@ -0,0 +1,2983 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync8, readdirSync as readdirSync2, symlinkSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, join as join5, resolve } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+
+// src/shell.ts
+import { execFile } from "child_process";
+var RealShell = class {
+  async exec(cmd, args, options) {
+    const controller = new AbortController();
+    const timeout = options?.timeout;
+    return new Promise((resolve2, reject) => {
+      const child = execFile(
+        cmd,
+        args,
+        {
+          signal: controller.signal,
+          maxBuffer: 10 * 1024 * 1024,
+          encoding: "utf-8"
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve2({ stdout, stderr });
+          }
+        }
+      );
+      if (timeout) {
+        setTimeout(() => {
+          controller.abort();
+          child.kill();
+        }, timeout);
+      }
+    });
+  }
+};
+
+// src/config.ts
+import { z } from "zod";
+import { cosmiconfig } from "cosmiconfig";
+
+// src/types.ts
+var DEFAULT_RETRY_POLICY = {
+  maxAttempts: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 5e3,
+  backoffMultiplier: 2,
+  retryableErrors: ["device busy", "transport error", "ECONNRESET"]
+};
+var DEFAULT_TIMEOUT_CONFIG = {
+  deviceDiscoveryMs: 5e3,
+  screenshotCaptureMs: 1e4,
+  treeInspectionMs: 15e3,
+  devToolsConnectMs: 3e3
+};
+
+// src/config.ts
+var timeoutSchema = z.object({
+  deviceDiscoveryMs: z.number().int().positive().optional(),
+  screenshotCaptureMs: z.number().int().positive().optional(),
+  treeInspectionMs: z.number().int().positive().optional(),
+  devToolsConnectMs: z.number().int().positive().optional()
+});
+var retrySchema = z.object({
+  maxAttempts: z.number().int().positive().optional(),
+  baseDelayMs: z.number().int().positive().optional(),
+  maxDelayMs: z.number().int().positive().optional(),
+  backoffMultiplier: z.number().positive().optional(),
+  retryableErrors: z.array(z.string()).optional()
+});
+var boundingBoxSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  width: z.number().positive(),
+  height: z.number().positive()
+});
+var colorRangeSchema = z.object({
+  r: z.tuple([z.number(), z.number()]),
+  g: z.tuple([z.number(), z.number()]),
+  b: z.tuple([z.number(), z.number()]),
+  a: z.tuple([z.number(), z.number()]).optional()
+});
+var ignoreRuleSchema = z.object({
+  type: z.enum(["testID", "componentName", "textPattern", "boundingBox", "sourceFile", "colorRange"]),
+  value: z.union([z.string(), boundingBoxSchema, colorRangeSchema]),
+  reason: z.string().optional()
+});
+var viewportSchema = z.object({
+  cropStatusBar: z.boolean().optional(),
+  cropNavigationBar: z.boolean().optional(),
+  statusBarHeight: z.number().int().nonnegative().optional(),
+  navigationBarHeight: z.number().int().nonnegative().optional()
+});
+var analysesSchema = z.object({
+  default: z.array(z.string()).optional(),
+  disabled: z.array(z.string()).optional(),
+  options: z.record(z.string(), z.record(z.string(), z.unknown())).optional()
+}).optional();
+var configSchema = z.object({
+  threshold: z.number().min(0).max(1).optional(),
+  diffThreshold: z.number().min(0).max(1).optional(),
+  settleTimeMs: z.number().int().positive().optional(),
+  settleCheckEnabled: z.boolean().optional(),
+  settleMaxDelta: z.number().min(0).max(1).optional(),
+  primaryDevice: z.string().optional(),
+  groups: z.record(z.string(), z.array(z.string())).optional(),
+  platform: z.enum(["android", "ios"]).optional(),
+  metroPort: z.number().int().positive().optional(),
+  devToolsPort: z.number().int().positive().optional(),
+  ignoreRules: z.array(ignoreRuleSchema).optional(),
+  viewport: viewportSchema.optional(),
+  timeouts: timeoutSchema.optional(),
+  retry: retrySchema.optional(),
+  regionMergeGap: z.number().int().nonnegative().optional(),
+  regionMinArea: z.number().int().nonnegative().optional(),
+  diffMaskColor: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+  analyses: analysesSchema
+});
+var DEFAULTS = {
+  threshold: 0.1,
+  diffThreshold: 0.01,
+  settleTimeMs: 300,
+  settleCheckEnabled: true,
+  settleMaxDelta: 1e-3,
+  primaryDevice: void 0,
+  groups: {},
+  platform: "android",
+  metroPort: 8081,
+  devToolsPort: 8097,
+  ignoreRules: [],
+  viewport: {
+    cropStatusBar: true,
+    cropNavigationBar: true,
+    statusBarHeight: 24,
+    navigationBarHeight: 48
+  },
+  timeouts: { ...DEFAULT_TIMEOUT_CONFIG },
+  retry: { ...DEFAULT_RETRY_POLICY },
+  regionMergeGap: 8,
+  regionMinArea: 100,
+  diffMaskColor: [255, 0, 0, 128],
+  analyses: {
+    default: [],
+    disabled: [],
+    options: {}
+  }
+};
+function getDefaultConfig() {
+  return structuredClone(DEFAULTS);
+}
+function parseConfig(raw) {
+  const parsed = configSchema.parse(raw);
+  const defaults = getDefaultConfig();
+  return {
+    ...defaults,
+    ...parsed,
+    viewport: { ...defaults.viewport, ...parsed.viewport },
+    timeouts: { ...defaults.timeouts, ...parsed.timeouts },
+    retry: { ...defaults.retry, ...parsed.retry },
+    analyses: {
+      default: parsed.analyses?.default ?? DEFAULTS.analyses.default,
+      disabled: parsed.analyses?.disabled ?? DEFAULTS.analyses.disabled,
+      options: { ...DEFAULTS.analyses.options, ...parsed.analyses?.options }
+    }
+  };
+}
+var explorer = cosmiconfig("driftx");
+async function loadConfig(searchFrom) {
+  const result = await explorer.search(searchFrom);
+  if (!result || result.isEmpty) {
+    return getDefaultConfig();
+  }
+  return parseConfig(result.config);
+}
+
+// src/logger.ts
+import pino from "pino";
+function createLogger(level = "info") {
+  return pino({
+    level: level === "silent" ? "silent" : level,
+    transport: process.env.NODE_ENV !== "test" ? { target: "pino-pretty", options: { colorize: true } } : void 0
+  });
+}
+var _logger;
+function getLogger() {
+  if (!_logger) {
+    _logger = createLogger();
+  }
+  return _logger;
+}
+function setLogger(logger) {
+  _logger = logger;
+}
+
+// src/prerequisites.ts
+var CLI_PREREQUISITES = [
+  {
+    name: "node",
+    cmd: "node",
+    args: ["--version"],
+    required: true,
+    versionParser: (stdout) => stdout.trim().replace(/^v/, ""),
+    fix: "Install Node.js >= 18 from https://nodejs.org"
+  },
+  {
+    name: "adb",
+    cmd: "adb",
+    args: ["--version"],
+    required: false,
+    versionParser: (stdout) => {
+      const match = stdout.match(/(\d+\.\d+\.\d+)/);
+      return match?.[1] ?? "unknown";
+    },
+    fix: "Install Android SDK Platform-Tools: https://developer.android.com/studio"
+  },
+  {
+    name: "xcrun",
+    cmd: "xcrun",
+    args: ["--version"],
+    required: false,
+    versionParser: (stdout) => stdout.trim(),
+    fix: "Install Xcode Command Line Tools: xcode-select --install"
+  }
+];
+async function checkOne(spec, shell) {
+  try {
+    const { stdout } = await shell.exec(spec.cmd, spec.args, { timeout: 5e3 });
+    return {
+      name: spec.name,
+      required: spec.required,
+      available: true,
+      version: spec.versionParser(stdout)
+    };
+  } catch (err) {
+    return {
+      name: spec.name,
+      required: spec.required,
+      available: false,
+      error: err instanceof Error ? err.message : String(err),
+      fix: spec.fix
+    };
+  }
+}
+async function checkMetro(port) {
+  try {
+    const { default: http2 } = await import("http");
+    const status = await new Promise((resolve2, reject) => {
+      const req = http2.get(`http://localhost:${port}/status`, { timeout: 2e3 }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => resolve2(data));
+      });
+      req.on("error", reject);
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("timeout"));
+      });
+    });
+    return {
+      name: "metro",
+      required: false,
+      available: true,
+      version: `running on :${port}`
+    };
+  } catch {
+    return {
+      name: "metro",
+      required: false,
+      available: false,
+      fix: "Start Metro bundler: npx react-native start"
+    };
+  }
+}
+async function checkPrerequisites(shell, metroPort = 8081) {
+  const cliChecks = CLI_PREREQUISITES.map((spec) => checkOne(spec, shell));
+  const metro = checkMetro(metroPort);
+  return Promise.all([...cliChecks, metro]);
+}
+
+// src/exit-codes.ts
+var ExitCode = {
+  Success: 0,
+  DiffFound: 1,
+  ConfigError: 2,
+  RuntimeError: 3,
+  PrerequisiteMissing: 4
+};
+
+// src/commands/doctor.ts
+function computeDoctorExitCode(checks) {
+  return checks.some((c) => c.required && !c.available) ? ExitCode.PrerequisiteMissing : ExitCode.Success;
+}
+
+// src/commands/init.ts
+function detectFramework(files, packageJson) {
+  if (packageJson) {
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (deps["react-native"]) {
+      return "react-native";
+    }
+  }
+  const hasGradle = files.some((f) => f.endsWith(".gradle") || f.endsWith(".gradle.kts"));
+  if (hasGradle) return "native-android";
+  const hasXcode = files.some((f) => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"));
+  if (hasXcode) return "native-ios";
+  return "unknown";
+}
+function generateConfig(framework) {
+  const base = {
+    threshold: 0.1,
+    diffThreshold: 0.01,
+    settleTimeMs: 300,
+    viewport: {
+      cropStatusBar: true,
+      cropNavigationBar: true
+    }
+  };
+  switch (framework) {
+    case "react-native":
+      return { ...base, framework, platform: "android", metroPort: 8081 };
+    case "native-android":
+      return { ...base, framework, platform: "android" };
+    case "native-ios":
+      return { ...base, framework, platform: "ios" };
+    default:
+      return { ...base, framework, platform: "android" };
+  }
+}
+
+// src/devices/android-discovery.ts
+function parseAdbDevices(output) {
+  const devices = [];
+  const lines = output.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("List of devices") || line.trim() === "") continue;
+    const match = line.match(/^(\S+)\s+(device|offline|unauthorized)(.*)$/);
+    if (!match) continue;
+    const [, id, rawState, rest] = match;
+    const modelMatch = rest.match(/model:(\S+)/);
+    const transportMatch = rest.match(/transport_id:(\S+)/);
+    const state = rawState === "device" ? "booted" : rawState === "offline" ? "offline" : "unauthorized";
+    devices.push({
+      id,
+      name: modelMatch?.[1] ?? id,
+      platform: "android",
+      osVersion: "",
+      state,
+      transport: transportMatch?.[1]
+    });
+  }
+  return devices;
+}
+async function fetchApiLevel(shell, deviceId) {
+  try {
+    const { stdout } = await shell.exec("adb", ["-s", deviceId, "shell", "getprop", "ro.build.version.sdk"]);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function discoverAndroidDevices(shell) {
+  const { stdout } = await shell.exec("adb", ["devices", "-l"]);
+  const devices = parseAdbDevices(stdout);
+  for (const device of devices) {
+    if (device.state === "booted") {
+      device.osVersion = await fetchApiLevel(shell, device.id);
+    }
+  }
+  return devices;
+}
+
+// src/devices/ios-discovery.ts
+function parseOsVersion(runtime) {
+  const match = runtime.match(/iOS-(\d+)-(\d+)/);
+  return match ? `${match[1]}.${match[2]}` : "";
+}
+function parseSimctlDevices(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    return [];
+  }
+  const devices = [];
+  for (const [runtime, sims] of Object.entries(parsed.devices)) {
+    const osVersion = parseOsVersion(runtime);
+    for (const sim of sims) {
+      if (!sim.isAvailable) continue;
+      const state = sim.state === "Booted" ? "booted" : "offline";
+      devices.push({
+        id: sim.udid,
+        name: sim.name,
+        platform: "ios",
+        osVersion,
+        state
+      });
+    }
+  }
+  return devices;
+}
+async function discoverIosDevices(shell) {
+  const { stdout } = await shell.exec("xcrun", ["simctl", "list", "devices", "--json"]);
+  return parseSimctlDevices(stdout);
+}
+
+// src/devices/discovery.ts
+var DeviceDiscovery = class {
+  shell;
+  cacheTtlMs;
+  cache = null;
+  cacheTime = 0;
+  constructor(shell, options) {
+    this.shell = shell;
+    this.cacheTtlMs = options?.cacheTtlMs ?? 3e4;
+  }
+  async list() {
+    if (this.cache && Date.now() - this.cacheTime < this.cacheTtlMs) {
+      return this.cache;
+    }
+    const results = [];
+    const logger = getLogger();
+    try {
+      const android = await discoverAndroidDevices(this.shell);
+      results.push(...android);
+    } catch (err) {
+      logger.debug({ err }, "Android discovery failed");
+    }
+    try {
+      const ios = await discoverIosDevices(this.shell);
+      results.push(...ios);
+    } catch (err) {
+      logger.debug({ err }, "iOS discovery failed");
+    }
+    this.cache = results;
+    this.cacheTime = Date.now();
+    return results;
+  }
+  async findById(id) {
+    const devices = await this.list();
+    return devices.find((d) => d.id === id);
+  }
+  invalidateCache() {
+    this.cache = null;
+  }
+};
+
+// src/commands/capture.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/capture/android-capture.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var DEVICE_TMP_PATH = "/sdcard/driftx-tmp.png";
+async function captureAndroidScreenshot(shell, deviceId, timeout) {
+  const localTmp = path.join(os.tmpdir(), `driftx-android-${Date.now()}-${deviceId}.png`);
+  try {
+    await shell.exec(
+      "adb",
+      ["-s", deviceId, "shell", "screencap", "-p", DEVICE_TMP_PATH],
+      timeout ? { timeout } : void 0
+    );
+    await shell.exec("adb", ["-s", deviceId, "pull", DEVICE_TMP_PATH, localTmp]);
+    if (!fs.existsSync(localTmp)) {
+      throw new Error("Screenshot capture returned empty buffer \u2014 pull did not create local file");
+    }
+    const buffer = fs.readFileSync(localTmp);
+    if (buffer.length === 0) {
+      throw new Error("Screenshot capture returned empty buffer");
+    }
+    return buffer;
+  } finally {
+    try {
+      await shell.exec("adb", ["-s", deviceId, "shell", "rm", DEVICE_TMP_PATH]);
+    } catch {
+    }
+    try {
+      if (fs.existsSync(localTmp)) fs.unlinkSync(localTmp);
+    } catch {
+    }
+  }
+}
+
+// src/capture/ios-capture.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+async function captureIosScreenshot(shell, deviceId, tmpPath) {
+  const screenshotPath = tmpPath ?? path2.join(os2.tmpdir(), `driftx-ios-${Date.now()}.png`);
+  await shell.exec("xcrun", ["simctl", "io", deviceId, "screenshot", screenshotPath]);
+  if (!fs2.existsSync(screenshotPath)) {
+    throw new Error(`iOS screenshot not created at ${screenshotPath}`);
+  }
+  const buffer = fs2.readFileSync(screenshotPath);
+  if (!tmpPath) fs2.unlinkSync(screenshotPath);
+  if (buffer.length === 0) throw new Error("iOS screenshot capture returned empty file");
+  return buffer;
+}
+
+// src/capture/capture.ts
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+function isScreenSettled(buf1, buf2, maxDelta) {
+  const img1 = PNG.sync.read(buf1);
+  const img2 = PNG.sync.read(buf2);
+  if (img1.width !== img2.width || img1.height !== img2.height) return false;
+  const diffPixels = pixelmatch(img1.data, img2.data, void 0, img1.width, img1.height, {
+    threshold: 0.1
+  });
+  const totalPixels = img1.width * img1.height;
+  return diffPixels / totalPixels <= maxDelta;
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function captureScreenshot(shell, device, options) {
+  const logger = getLogger();
+  const captureOnce = async () => {
+    if (device.platform === "android") {
+      return captureAndroidScreenshot(shell, device.id, options?.timeout);
+    }
+    return captureIosScreenshot(shell, device.id);
+  };
+  let buffer = await captureOnce();
+  if (options?.settleCheck) {
+    const maxDelta = options.settleMaxDelta ?? 1e-3;
+    const delayMs = options.settleDelayMs ?? 300;
+    const maxAttempts = options.settleMaxAttempts ?? 5;
+    for (let i = 0; i < maxAttempts; i++) {
+      await delay(delayMs);
+      const next = await captureOnce();
+      if (isScreenSettled(buffer, next, maxDelta)) {
+        logger.debug(`Screen settled after ${i + 1} check(s)`);
+        return next;
+      }
+      buffer = next;
+    }
+    logger.warn("Screen did not settle within max attempts, using last capture");
+  }
+  return buffer;
+}
+
+// src/run-store.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { nanoid } from "nanoid";
+var RunStore = class {
+  baseDir;
+  constructor(projectRoot) {
+    this.baseDir = path3.join(projectRoot, ".driftx", "runs");
+  }
+  createRun() {
+    const runId = nanoid(12);
+    const dir = path3.join(this.baseDir, runId);
+    fs3.mkdirSync(dir, { recursive: true });
+    return { runId, dir };
+  }
+  getRunDir(runId) {
+    return path3.join(this.baseDir, runId);
+  }
+  async writeMetadata(runId, metadata) {
+    const filePath = path3.join(this.getRunDir(runId), "metadata.json");
+    fs3.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+  }
+  async writeArtifact(runId, relativePath, data) {
+    const filePath = path3.join(this.getRunDir(runId), relativePath);
+    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, data);
+  }
+  listRuns() {
+    if (!fs3.existsSync(this.baseDir)) return [];
+    return fs3.readdirSync(this.baseDir).filter((f) => {
+      return fs3.statSync(path3.join(this.baseDir, f)).isDirectory();
+    });
+  }
+  getRunPath(runId, relativePath) {
+    const dir = this.getRunDir(runId);
+    return relativePath ? path3.join(dir, relativePath) : dir;
+  }
+  readArtifact(runId, relativePath) {
+    const fullPath = path3.join(this.getRunDir(runId), relativePath);
+    try {
+      return fs3.readFileSync(fullPath);
+    } catch {
+      return null;
+    }
+  }
+  getLatestRun() {
+    const runs = this.listRuns();
+    if (runs.length === 0) return void 0;
+    let latest;
+    let latestTime = 0;
+    for (const runId of runs) {
+      try {
+        const stat = fs3.statSync(this.getRunDir(runId));
+        if (stat.mtimeMs > latestTime) {
+          latestTime = stat.mtimeMs;
+          latest = runId;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return latest;
+  }
+};
+
+// src/retry.ts
+function isRetryable(error, policy) {
+  return policy.retryableErrors.some((pattern) => error.message.includes(pattern));
+}
+function delay2(ms, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted"));
+      return;
+    }
+    const timer = setTimeout(resolve2, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(new Error("Aborted"));
+    }, { once: true });
+  });
+}
+async function withRetry(fn, policy, signal) {
+  let lastError;
+  for (let attempt = 0; attempt < policy.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (!isRetryable(lastError, policy)) {
+        throw lastError;
+      }
+      if (signal?.aborted) {
+        throw lastError;
+      }
+      if (attempt < policy.maxAttempts - 1) {
+        const backoff = Math.min(
+          policy.baseDelayMs * Math.pow(policy.backoffMultiplier, attempt),
+          policy.maxDelayMs
+        );
+        try {
+          await delay2(backoff, signal);
+        } catch {
+          throw lastError;
+        }
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/commands/device-picker.ts
+import { select } from "@inquirer/prompts";
+async function pickDevice(booted) {
+  if (booted.length === 1) return booted[0];
+  const selected = await select({
+    message: "Select a device",
+    choices: booted.map((d) => ({
+      name: `${d.name}  (${d.platform}, ${d.osVersion || "unknown"})`,
+      value: d.id
+    }))
+  });
+  return booted.find((d) => d.id === selected);
+}
+
+// src/commands/capture.ts
+async function runCapture(shell, config, options) {
+  const discovery = new DeviceDiscovery(shell);
+  const devices = await discovery.list();
+  const booted = devices.filter((d) => d.state === "booted");
+  if (booted.length === 0) {
+    throw new Error("No booted devices found. Start an emulator or boot a simulator.");
+  }
+  let device;
+  if (options.device) {
+    const found = booted.find((d) => d.id === options.device || d.name === options.device);
+    if (!found) throw new Error(`Device not found: ${options.device}`);
+    device = found;
+  } else if (config.primaryDevice) {
+    const found = booted.find((d) => d.id === config.primaryDevice || d.name === config.primaryDevice);
+    if (!found) throw new Error(`Primary device not found: ${config.primaryDevice}`);
+    device = found;
+  } else {
+    device = await pickDevice(booted);
+  }
+  const buffer = await withRetry(
+    () => captureScreenshot(shell, device, {
+      settleCheck: options.settleCheck ?? config.settleCheckEnabled,
+      settleMaxDelta: config.settleMaxDelta,
+      settleDelayMs: config.settleTimeMs
+    }),
+    config.retry ?? DEFAULT_RETRY_POLICY
+  );
+  const projectRoot = process.cwd();
+  if (options.output) {
+    fs4.mkdirSync(path4.dirname(options.output), { recursive: true });
+    fs4.writeFileSync(options.output, buffer);
+    return { path: options.output, runId: "" };
+  }
+  const store = new RunStore(projectRoot);
+  const run2 = store.createRun();
+  await store.writeArtifact(run2.runId, "screenshot.png", buffer);
+  await store.writeMetadata(run2.runId, {
+    runId: run2.runId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    deviceId: device.id,
+    platform: device.platform,
+    orientation: "portrait",
+    framework: "unknown",
+    projectRoot,
+    driftxVersion: "0.1.0"
+  });
+  return { path: store.getRunPath(run2.runId, "screenshot.png"), runId: run2.runId };
+}
+
+// src/inspect/uiautomator.ts
+function parseBounds(boundsStr) {
+  const match = boundsStr.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (!match) return { x: 0, y: 0, width: 0, height: 0 };
+  const [, x1, y1, x2, y2] = match.map(Number);
+  return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };
+}
+function parseNode(nodeStr, idCounter) {
+  const attrMatch = nodeStr.match(/^<node\s+([^>]*?)(\/?>)/);
+  if (!attrMatch) return null;
+  const attrs = attrMatch[1];
+  const selfClosing = attrMatch[2] === "/>";
+  const afterTag = nodeStr.slice(attrMatch[0].length);
+  const get = (name) => {
+    const m = attrs.match(new RegExp(`${name}="([^"]*)"`));
+    return m ? m[1] : "";
+  };
+  const id = String(idCounter.n++);
+  const resourceId = get("resource-id");
+  const className = get("class");
+  const node = {
+    id,
+    name: className || "unknown",
+    nativeName: className || void 0,
+    testID: resourceId || void 0,
+    bounds: parseBounds(get("bounds")),
+    text: get("text") || void 0,
+    children: [],
+    inspectionTier: "basic"
+  };
+  if (selfClosing) {
+    return { node, remaining: afterTag };
+  }
+  let rest = afterTag;
+  while (true) {
+    rest = rest.replace(/^\s+/, "");
+    if (rest.startsWith("</node>")) {
+      rest = rest.slice("</node>".length);
+      break;
+    }
+    const child = parseNode(rest, idCounter);
+    if (!child) break;
+    node.children.push(child.node);
+    rest = child.remaining;
+  }
+  return { node, remaining: rest };
+}
+function parseUiAutomatorXml(xml) {
+  if (!xml.includes("<hierarchy")) {
+    throw new Error("Invalid UIAutomator XML: missing <hierarchy> element");
+  }
+  const hierarchyMatch = xml.match(/<hierarchy[^>]*>([\s\S]*)<\/hierarchy>/);
+  if (!hierarchyMatch) return [];
+  const content = hierarchyMatch[1].trim();
+  if (!content) return [];
+  const nodes = [];
+  const idCounter = { n: 0 };
+  let remaining = content;
+  while (remaining.trim()) {
+    remaining = remaining.replace(/^\s+/, "");
+    if (!remaining.startsWith("<node")) break;
+    const result = parseNode(remaining, idCounter);
+    if (!result) break;
+    nodes.push(result.node);
+    remaining = result.remaining;
+  }
+  return nodes;
+}
+async function dumpUiAutomator(shell, deviceId, timeout) {
+  const { stdout } = await shell.exec("adb", ["-s", deviceId, "exec-out", "uiautomator", "dump", "/dev/tty"], timeout ? { timeout } : void 0);
+  return parseUiAutomatorXml(stdout);
+}
+
+// src/inspect/ios-accessibility.ts
+function parseElement(el, idCounter) {
+  const id = String(idCounter.n++);
+  return {
+    id,
+    name: el.role ?? "unknown",
+    nativeName: el.role,
+    testID: el.identifier || void 0,
+    bounds: el.frame ? { x: el.frame.x, y: el.frame.y, width: el.frame.width, height: el.frame.height } : { x: 0, y: 0, width: 0, height: 0 },
+    text: el.label || void 0,
+    children: (el.children ?? []).map((c) => parseElement(c, idCounter)),
+    inspectionTier: "basic"
+  };
+}
+function parseIosAccessibility(json) {
+  const data = JSON.parse(json);
+  const elements = data.AXElements ?? [];
+  const idCounter = { n: 0 };
+  return elements.map((el) => parseElement(el, idCounter));
+}
+async function dumpIosAccessibility(shell, deviceId, timeout) {
+  const logger = getLogger();
+  const opts = timeout ? { timeout } : void 0;
+  try {
+    const { stdout } = await shell.exec("idb", ["ui", "describe-all", "--udid", deviceId], opts);
+    return parseIosAccessibility(stdout);
+  } catch {
+    logger.debug("idb not available, skipping iOS accessibility tree");
+  }
+  throw new Error("iOS accessibility inspection requires idb (brew install idb-companion && pip install fb-idb) or React DevTools");
+}
+
+// src/inspect/cdp-client.ts
+import WebSocket from "ws";
+import http from "http";
+var FIBER_WALK_SCRIPT = `(function() {
+  try {
+    var hook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook || !hook.renderers || hook.renderers.size === 0) return JSON.stringify(null);
+
+    var flat = [];
+    hook.renderers.forEach(function(renderer, id) {
+      var roots = hook.getFiberRoots(id);
+      if (!roots) return;
+      roots.forEach(function(root) {
+        if (root.current) flattenFiber(root.current, 0);
+      });
+    });
+
+    return flat.length > 0 ? JSON.stringify(flat) : JSON.stringify(null);
+  } catch(e) {
+    return JSON.stringify(null);
+  }
+
+  function getName(fiber) {
+    if (typeof fiber.type === 'string') return fiber.type;
+    if (fiber.type && fiber.type.displayName) return fiber.type.displayName;
+    if (fiber.type && fiber.type.name) return fiber.type.name;
+    if (fiber.tag === 3) return null;
+    return null;
+  }
+
+  function isNoise(name, fiber) {
+    if (!name) return true;
+    if (fiber.tag === 6) return true;
+    var props = fiber.memoizedProps || {};
+    var hasSignal = props.testID || props.nativeID || typeof props.children === 'string';
+    if (hasSignal) return false;
+    if (name === 'Unknown') return true;
+    if (fiber.tag === 5) return true;
+    if (name.substring(0, 3) === 'RCT' || name.substring(0, 5) === 'RNSVG') return true;
+    if (name.indexOf('ViewManagerAdapter_') === 0) return true;
+    var len = name.length;
+    if (len > 7 && name.indexOf('Context', len - 7) === len - 7) return true;
+    if (len > 8 && name.indexOf('Provider', len - 8) === len - 8) return true;
+    if (len > 8 && name.indexOf('Consumer', len - 8) === len - 8) return true;
+    var c = name.charCodeAt(0);
+    if (c >= 97 && c <= 122) return true;
+    if (name.indexOf('Animated(') === 0) return true;
+    return false;
+  }
+
+  function flattenFiber(fiber, depth) {
+    if (!fiber) return;
+    var name = getName(fiber);
+    var noise = isNoise(name, fiber);
+
+    if (!noise) {
+      var props = fiber.memoizedProps || {};
+      var testID = props.testID || props.nativeID || undefined;
+      var text = typeof props.children === 'string' ? props.children : undefined;
+      flat.push({ n: name, d: depth, t: testID, x: text });
+      var child = fiber.child;
+      while (child) { flattenFiber(child, depth + 1); child = child.sibling; }
+    } else {
+      var child = fiber.child;
+      while (child) { flattenFiber(child, depth); child = child.sibling; }
+    }
+  }
+})()`;
+async function discoverTargets(metroPort) {
+  return new Promise((resolve2, reject) => {
+    const req = http.get(`http://localhost:${metroPort}/json/list`, { timeout: 2e3 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          resolve2(JSON.parse(data));
+        } catch {
+          resolve2([]);
+        }
+      });
+    });
+    req.on("error", () => resolve2([]));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2([]);
+    });
+  });
+}
+function findRuntimeTarget(targets, deviceName) {
+  const rnTargets = targets.filter(
+    (t) => t.reactNative && t.description.includes("React Native")
+  );
+  if (deviceName) {
+    return rnTargets.find(
+      (t) => t.deviceName?.toLowerCase().includes(deviceName.toLowerCase())
+    );
+  }
+  return rnTargets[0];
+}
+var CdpClient = class {
+  ws = null;
+  connected = false;
+  msgId = 0;
+  pending = /* @__PURE__ */ new Map();
+  async connectAndGetTree(metroPort, timeoutMs, deviceName) {
+    const logger = getLogger();
+    const targets = await discoverTargets(metroPort);
+    const target = findRuntimeTarget(targets, deviceName);
+    if (!target) {
+      logger.debug("No React Native debug target found via Metro");
+      return [];
+    }
+    logger.debug(`Found CDP target: ${target.title} (${target.description})`);
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.cleanup();
+        resolve2([]);
+      }, timeoutMs);
+      try {
+        this.ws = new WebSocket(target.webSocketDebuggerUrl);
+      } catch {
+        clearTimeout(timer);
+        resolve2([]);
+        return;
+      }
+      this.ws.on("open", async () => {
+        this.connected = true;
+        try {
+          const result = await this.evaluate(FIBER_WALK_SCRIPT);
+          clearTimeout(timer);
+          resolve2(this.parseResult(result));
+        } catch {
+          clearTimeout(timer);
+          resolve2([]);
+        }
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.id !== void 0) {
+            const p = this.pending.get(msg.id);
+            if (p) {
+              this.pending.delete(msg.id);
+              p.resolve(msg);
+            }
+          }
+        } catch {
+        }
+      });
+      this.ws.on("error", () => {
+        clearTimeout(timer);
+        resolve2([]);
+      });
+      this.ws.on("close", () => {
+        this.connected = false;
+      });
+    });
+  }
+  evaluate(expression) {
+    const id = ++this.msgId;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.ws.send(JSON.stringify({
+        id,
+        method: "Runtime.evaluate",
+        params: { expression, returnByValue: true }
+      }));
+    });
+  }
+  parseResult(response) {
+    const value = response.result?.result?.value;
+    if (!value || typeof value !== "string") return [];
+    const parsed = JSON.parse(value);
+    if (!Array.isArray(parsed)) return [];
+    return this.optimize(this.rebuildTree(parsed));
+  }
+  optimize(roots) {
+    let tree = roots;
+    let prevCount = -1;
+    for (let i = 0; i < 10; i++) {
+      tree = this.dedup(tree);
+      tree = this.pruneLeaves(tree);
+      const count = this.countNodes(tree);
+      if (count === prevCount) break;
+      prevCount = count;
+    }
+    return tree;
+  }
+  countNodes(nodes) {
+    let c = 0;
+    for (const n of nodes) c += 1 + this.countNodes(n.children);
+    return c;
+  }
+  pruneLeaves(nodes) {
+    return nodes.reduce((acc, node) => {
+      node.children = this.pruneLeaves(node.children);
+      if (node.children.length === 0 && !node.testID && !node.text) return acc;
+      acc.push(node);
+      return acc;
+    }, []);
+  }
+  rebuildTree(flat) {
+    const roots = [];
+    const stack = [];
+    let id = 0;
+    for (const entry of flat) {
+      const node = {
+        id: String(id++),
+        name: entry.n,
+        reactName: entry.n,
+        testID: entry.t || void 0,
+        bounds: { x: 0, y: 0, width: 0, height: 0 },
+        text: entry.x || void 0,
+        children: [],
+        inspectionTier: "detailed"
+      };
+      while (stack.length > entry.d) stack.pop();
+      if (stack.length === 0) {
+        roots.push(node);
+      } else {
+        stack[stack.length - 1].children.push(node);
+      }
+      stack.push(node);
+    }
+    return roots;
+  }
+  dedup(nodes) {
+    return nodes.map((node) => this.dedupNode(node)).filter(Boolean);
+  }
+  dedupNode(node) {
+    node.children = this.dedup(node.children);
+    if (node.children.length === 1) {
+      const child = node.children[0];
+      const sameText = node.text && child.text && node.text === child.text;
+      const sameTestID = node.testID && child.testID && node.testID === child.testID;
+      if (sameText || sameTestID) {
+        child.children = [...child.children];
+        return child;
+      }
+      const nodeHasSignal = node.testID || node.text;
+      if (!nodeHasSignal) {
+        child.children = [...child.children];
+        return child;
+      }
+    }
+    return node;
+  }
+  getCapabilities() {
+    return {
+      tree: this.connected ? "detailed" : "none",
+      sourceMapping: this.connected ? "partial" : "none",
+      styles: this.connected ? "partial" : "none",
+      protocol: "cdp"
+    };
+  }
+  async disconnect() {
+    this.cleanup();
+  }
+  cleanup() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.connected = false;
+    for (const [, p] of this.pending) {
+      p.reject(new Error("disconnected"));
+    }
+    this.pending.clear();
+  }
+};
+
+// src/inspect/strategy-cache.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var StrategyCache = class {
+  filePath;
+  ttlMs;
+  entries;
+  constructor(projectRoot, ttlMs = 6e4) {
+    this.filePath = path5.join(projectRoot, ".driftx", "strategy-cache.json");
+    this.ttlMs = ttlMs;
+    this.entries = this.load();
+  }
+  get(deviceId) {
+    const entry = this.entries.get(deviceId);
+    if (!entry) return void 0;
+    if (Date.now() - entry.timestamp > this.ttlMs) {
+      this.entries.delete(deviceId);
+      this.persist();
+      return void 0;
+    }
+    return entry;
+  }
+  set(deviceId, method, reason, appId) {
+    this.entries.set(deviceId, { method, reason, appId, timestamp: Date.now() });
+    this.persist();
+  }
+  delete(deviceId) {
+    this.entries.delete(deviceId);
+    this.persist();
+  }
+  clear() {
+    this.entries.clear();
+    this.persist();
+  }
+  load() {
+    try {
+      const raw = fs5.readFileSync(this.filePath, "utf-8");
+      const data = JSON.parse(raw);
+      return new Map(Object.entries(data));
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  persist() {
+    try {
+      const dir = path5.dirname(this.filePath);
+      fs5.mkdirSync(dir, { recursive: true });
+      const obj = Object.fromEntries(this.entries);
+      fs5.writeFileSync(this.filePath, JSON.stringify(obj, null, 2));
+    } catch {
+    }
+  }
+};
+
+// src/inspect/tree-inspector.ts
+var TreeInspector = class {
+  shell;
+  fileCache;
+  constructor(shell, projectRoot) {
+    this.shell = shell;
+    this.fileCache = projectRoot ? new StrategyCache(projectRoot) : null;
+  }
+  invalidateCache(deviceId) {
+    if (!this.fileCache) return;
+    if (deviceId) {
+      this.fileCache.delete(deviceId);
+    } else {
+      this.fileCache.clear();
+    }
+  }
+  async resolveStrategy(device, options) {
+    if (options.metroPort > 0) {
+      const targets = await discoverTargets(options.metroPort);
+      const target = findRuntimeTarget(targets, device.name);
+      if (target) {
+        return {
+          method: "cdp",
+          reason: "React Native app connected via Metro",
+          appId: target.appId,
+          cdpTarget: target
+        };
+      }
+    }
+    if (device.platform === "android") {
+      return { method: "uiautomator", reason: "Android native inspection" };
+    }
+    return { method: "idb", reason: "iOS native inspection via idb" };
+  }
+  async inspect(device, options) {
+    const logger = getLogger();
+    const hints = [];
+    let usedCache = false;
+    const cachedEntry = this.fileCache?.get(device.id);
+    let strategy;
+    if (cachedEntry && cachedEntry.method !== "none") {
+      logger.debug(`Using cached strategy for ${device.name}: ${cachedEntry.method}`);
+      usedCache = true;
+      if (cachedEntry.method === "cdp" && options.metroPort > 0) {
+        const targets = await discoverTargets(options.metroPort);
+        const target = findRuntimeTarget(targets, device.name);
+        strategy = target ? { method: "cdp", reason: cachedEntry.reason, appId: target.appId, cdpTarget: target } : await this.resolveStrategy(device, options);
+      } else {
+        strategy = { method: cachedEntry.method, reason: cachedEntry.reason, appId: cachedEntry.appId };
+      }
+    } else {
+      strategy = await this.resolveStrategy(device, options);
+    }
+    this.fileCache?.set(device.id, strategy.method, strategy.reason, strategy.appId);
+    const base = { device: { name: device.name, platform: device.platform }, strategy };
+    if (strategy.method === "cdp" && strategy.cdpTarget) {
+      try {
+        const cdp = new CdpClient();
+        const tree = await cdp.connectAndGetTree(
+          options.metroPort,
+          options.timeoutMs,
+          device.name
+        );
+        const caps = cdp.getCapabilities();
+        await cdp.disconnect();
+        if (tree.length > 0) {
+          logger.debug(`CDP: got ${tree.length} root nodes for ${device.name}`);
+          return { ...base, tree, capabilities: caps, hints };
+        }
+      } catch (err) {
+        logger.debug(`CDP failed: ${err instanceof Error ? err.message : err}`);
+      }
+      logger.debug("CDP strategy resolved but returned no tree, falling back to native");
+    }
+    if (strategy.method === "uiautomator" || strategy.method === "cdp" && device.platform === "android") {
+      try {
+        const tree = await dumpUiAutomator(this.shell, device.id, options.timeoutMs);
+        logger.debug(`UIAutomator: got ${tree.length} root nodes for ${device.name}`);
+        return {
+          ...base,
+          strategy: { method: "uiautomator", reason: strategy.method === "cdp" ? "CDP fallback to native" : strategy.reason },
+          tree,
+          capabilities: { tree: "basic", sourceMapping: "none", styles: "none", protocol: "uiautomator" },
+          hints
+        };
+      } catch (err) {
+        logger.debug(`UIAutomator failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    if (strategy.method === "idb" || strategy.method === "cdp" && device.platform === "ios") {
+      try {
+        const tree = await dumpIosAccessibility(this.shell, device.id, options.timeoutMs);
+        logger.debug(`idb: got ${tree.length} root nodes for ${device.name}`);
+        return {
+          ...base,
+          strategy: { method: "idb", reason: strategy.method === "cdp" ? "CDP fallback to native" : strategy.reason },
+          tree,
+          capabilities: { tree: "basic", sourceMapping: "none", styles: "none", protocol: "idb" },
+          hints
+        };
+      } catch (err) {
+        logger.debug(`iOS accessibility failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    if (device.platform === "ios") {
+      hints.push("Install idb for native iOS tree inspection: brew install idb-companion && pip install fb-idb");
+    }
+    if (usedCache) {
+      this.fileCache?.delete(device.id);
+      logger.debug(`Invalidated cached strategy for ${device.name} after complete failure`);
+    }
+    return {
+      ...base,
+      strategy: { method: "none", reason: "No inspection method available" },
+      tree: [],
+      capabilities: { tree: "none", sourceMapping: "none", styles: "none", protocol: "none" },
+      hints
+    };
+  }
+};
+
+// src/formatters/compare.ts
+import pc from "picocolors";
+function confidenceLabel(confidence) {
+  if (confidence >= 0.8) return "high";
+  if (confidence >= 0.5) return "probable";
+  return "approximate";
+}
+function severityColor(severity, text) {
+  if (severity === "critical") return pc.red(pc.bold(text));
+  if (severity === "major") return pc.yellow(text);
+  if (severity === "minor") return pc.cyan(text);
+  return pc.dim(text);
+}
+function severityCounts(findings) {
+  const counts = {};
+  for (const f of findings) {
+    counts[f.severity] = (counts[f.severity] ?? 0) + 1;
+  }
+  const parts = [];
+  for (const sev of ["critical", "major", "minor", "info"]) {
+    if (counts[sev]) parts.push(`${counts[sev]} ${sev}`);
+  }
+  return parts.join(", ");
+}
+function formatTreePlain(nodes, indent = 0) {
+  const lines = [];
+  for (const node of nodes) {
+    const prefix = "  ".repeat(indent);
+    const name = node.reactName ?? node.name;
+    const testId = node.testID ? ` [${node.testID}]` : "";
+    const text = node.text ? ` "${node.text}"` : "";
+    const b = node.bounds;
+    const bounds = b.width > 0 ? ` (${b.x},${b.y} ${b.width}x${b.height})` : "";
+    lines.push(`${prefix}${name}${testId}${text}${bounds}`);
+    const childStr = formatTreePlain(node.children, indent + 1);
+    if (childStr) lines.push(childStr);
+  }
+  return lines.join("\n");
+}
+function getPixelMeta(analyses) {
+  const pixel = analyses.find((a) => a.analysisName === "pixel");
+  const meta = pixel?.metadata;
+  return {
+    diffPercentage: meta?.diffPercentage ?? 0,
+    diffPixels: meta?.diffPixels ?? 0,
+    totalPixels: meta?.totalPixels ?? 0,
+    regions: meta?.regions ?? []
+  };
+}
+var compareFormatter = {
+  terminal(data) {
+    const { report } = data;
+    const pm = getPixelMeta(report.analyses);
+    const lines = [];
+    lines.push("");
+    lines.push(`  Diff: ${pm.diffPercentage.toFixed(2)}% (${pm.diffPixels.toLocaleString()}/${pm.totalPixels.toLocaleString()} pixels)`);
+    if (pm.regions.length > 0) lines.push(`  Regions: ${pm.regions.length}`);
+    lines.push(`  Duration: ${report.durationMs}ms`);
+    for (const a of report.analyses) {
+      lines.push(`  [${a.analysisName}] ${a.summary}`);
+    }
+    if (report.findings.length === 0) {
+      lines.push("");
+      lines.push(pc.green("  No differences found."));
+      lines.push("");
+      lines.push(`  Run: ${report.runId}`);
+      lines.push("");
+      return lines.join("\n");
+    }
+    lines.push("");
+    lines.push("  Findings");
+    lines.push("  " + "\u2500".repeat(70));
+    for (const f of report.findings) {
+      const tag = severityColor(f.severity, `[${f.severity.toUpperCase()}]`);
+      const comp = f.component ? `${f.component.name}${f.component.testID ? ` [${f.component.testID}]` : ""}` : pc.dim("(unmatched)");
+      const region = `(${f.region.x},${f.region.y} ${f.region.width}x${f.region.height})`;
+      const conf = `(${confidenceLabel(f.confidence)})`;
+      lines.push(`  ${tag}  ${f.id}  ${comp}  ${region}  ${conf}`);
+    }
+    lines.push("");
+    lines.push(`  Summary: Found ${report.findings.length} differences (${severityCounts(report.findings)})`);
+    lines.push("");
+    lines.push(`  Run: ${report.runId}`);
+    lines.push("");
+    return lines.join("\n");
+  },
+  markdown(data) {
+    const { report, device, artifactDir } = data;
+    const pm = getPixelMeta(report.analyses);
+    const lines = ["# Driftx Compare Report", ""];
+    if (device) lines.push(`**Device:** ${device.name} (${device.platform})`);
+    const meta = report.metadata;
+    if (meta.gitCommit || meta.gitBranch) {
+      const git = [meta.gitCommit, meta.gitBranch].filter(Boolean).join(" on ");
+      lines.push(`**Git:** ${git}`);
+    }
+    if (meta.framework && meta.framework !== "unknown") lines.push(`**Framework:** ${meta.framework}`);
+    lines.push(`**Diff:** ${pm.diffPercentage.toFixed(2)}% (${pm.diffPixels.toLocaleString()} / ${pm.totalPixels.toLocaleString()} pixels)`);
+    if (pm.regions.length > 0) lines.push(`**Regions:** ${pm.regions.length}`);
+    lines.push(`**Duration:** ${report.durationMs}ms`);
+    lines.push(`**Run ID:** ${report.runId}`);
+    if (report.analyses.length > 0) {
+      lines.push("", "## Analyses", "");
+      for (const a of report.analyses) {
+        lines.push(`- **${a.analysisName}** (${a.durationMs}ms): ${a.summary}`);
+      }
+    }
+    if (report.findings.length === 0) {
+      lines.push("", "No differences found.");
+      return lines.join("\n");
+    }
+    lines.push("", "## Artifacts", "");
+    lines.push(`- Screenshot: \`${artifactDir}/screenshot.png\``);
+    lines.push(`- Design: \`${artifactDir}/design.png\``);
+    lines.push(`- Diff mask: \`${artifactDir}/diff-mask.png\``);
+    lines.push("", "## Findings");
+    report.findings.forEach((f, i) => {
+      const compName = f.component?.name ?? "Unmatched region";
+      lines.push("", `### ${i + 1}. [${f.severity.toUpperCase()}] ${compName} (${f.id})`, "");
+      if (f.component) {
+        lines.push(`- **Component:** ${f.component.name}`);
+        if (f.component.testID) lines.push(`- **testID:** ${f.component.testID}`);
+      }
+      lines.push(`- **Category:** ${f.category}`);
+      lines.push(`- **Region:** (${f.region.x}, ${f.region.y}) ${f.region.width}x${f.region.height}`);
+      lines.push(`- **Confidence:** ${confidenceLabel(f.confidence)}`);
+      if (f.evidence.length > 0) {
+        lines.push("- **Evidence:**");
+        for (const e of f.evidence) {
+          lines.push(`  - ${e.type}: ${Math.round(e.score * 100)}% score \u2014 "${e.note}"`);
+        }
+      }
+      const regionId = pm.regions[i]?.id;
+      if (regionId) lines.push(`- **Region crop:** \`${artifactDir}/regions/${regionId}.png\``);
+    });
+    if (data.tree && data.tree.length > 0) {
+      lines.push("", "## Component Tree Context", "", "```");
+      lines.push(formatTreePlain(data.tree));
+      lines.push("```");
+    }
+    if (data.inspectHints && data.inspectHints.length > 0) {
+      lines.push("", "## Hints", "");
+      for (const hint of data.inspectHints) {
+        lines.push(`- ${hint}`);
+      }
+    }
+    return lines.join("\n");
+  },
+  json(data) {
+    return JSON.stringify({
+      report: data.report,
+      device: data.device,
+      artifactDir: data.artifactDir
+    }, null, 2);
+  }
+};
+
+// src/analyses/context.ts
+import sharp from "sharp";
+import { readFileSync as readFileSync5 } from "fs";
+async function buildDriftxImage(filePath) {
+  const buffer = readFileSync5(filePath);
+  const image = sharp(buffer);
+  const metadata = await image.metadata();
+  const width = metadata.width;
+  const height = metadata.height;
+  const rawPixels = await image.raw().ensureAlpha().toBuffer();
+  return {
+    buffer,
+    rawPixels,
+    width,
+    height,
+    aspectRatio: width / height,
+    path: filePath
+  };
+}
+function buildAnalysisConfig(configAnalyses, withFlag, withoutFlag) {
+  const enabled = withFlag ? withFlag.split(",").map((s) => s.trim()) : [...configAnalyses.default];
+  const disabled = withoutFlag ? withoutFlag.split(",").map((s) => s.trim()) : [...configAnalyses.disabled];
+  return {
+    enabled,
+    disabled,
+    options: configAnalyses.options
+  };
+}
+
+// src/analyses/registry.ts
+var AnalysisRegistry = class {
+  plugins = /* @__PURE__ */ new Map();
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Analysis "${plugin.name}" already registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  all() {
+    return [...this.plugins.values()];
+  }
+  names() {
+    return [...this.plugins.keys()];
+  }
+};
+
+// src/diff/image-loader.ts
+import sharp2 from "sharp";
+import * as fs6 from "fs";
+async function loadImage(filePath) {
+  if (!fs6.existsSync(filePath)) {
+    throw new Error(`Image not found: ${filePath}`);
+  }
+  const input = fs6.readFileSync(filePath);
+  const metadata = await sharp2(input).metadata();
+  if (!metadata.width || !metadata.height) {
+    throw new Error(`Invalid image: could not read dimensions from ${filePath}`);
+  }
+  const rawPixels = await sharp2(input).ensureAlpha().raw().toBuffer();
+  return {
+    buffer: input,
+    width: metadata.width,
+    height: metadata.height,
+    aspectRatio: metadata.width / metadata.height,
+    rawPixels
+  };
+}
+
+// src/diff/alignment.ts
+import sharp3 from "sharp";
+async function alignImages(design, screenshot) {
+  const targetWidth = screenshot.width;
+  const targetHeight = screenshot.height;
+  const logger = getLogger();
+  const aspectDiff = Math.abs(design.aspectRatio - screenshot.aspectRatio) / screenshot.aspectRatio;
+  const aspectRatioWarning = aspectDiff > 0.05;
+  if (aspectRatioWarning) {
+    logger.warn(
+      `Aspect ratio divergence: design=${design.aspectRatio.toFixed(3)} screenshot=${screenshot.aspectRatio.toFixed(3)} (${(aspectDiff * 100).toFixed(1)}%)`
+    );
+  }
+  let designPixels;
+  if (design.width === targetWidth && design.height === targetHeight) {
+    designPixels = design.rawPixels;
+  } else {
+    designPixels = await sharp3(design.buffer).resize(targetWidth, targetHeight, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).ensureAlpha().raw().toBuffer();
+  }
+  return {
+    designPixels,
+    screenshotPixels: screenshot.rawPixels,
+    width: targetWidth,
+    height: targetHeight,
+    aspectRatioWarning
+  };
+}
+
+// src/diff/pixel-diff.ts
+import pixelmatch2 from "pixelmatch";
+function computePixelDiff(aligned, threshold) {
+  const { width, height, designPixels, screenshotPixels } = aligned;
+  const totalPixels = width * height;
+  const diffMask = Buffer.alloc(width * height * 4);
+  const diffPixels = pixelmatch2(
+    designPixels,
+    screenshotPixels,
+    diffMask,
+    width,
+    height,
+    { threshold, includeAA: false }
+  );
+  return {
+    diffPixels,
+    totalPixels,
+    diffPercentage: totalPixels > 0 ? diffPixels / totalPixels * 100 : 0,
+    diffMask,
+    width,
+    height
+  };
+}
+
+// src/diff/region-extractor.ts
+function isDiffPixel(mask, idx) {
+  return mask[idx] > 0 || mask[idx + 1] > 0 || mask[idx + 2] > 0;
+}
+function floodFill(mask, visited, width, height, startX, startY) {
+  const stack = [[startX, startY]];
+  let minX = startX, maxX = startX, minY = startY, maxY = startY;
+  let count = 0;
+  while (stack.length > 0) {
+    const [x, y] = stack.pop();
+    const idx = y * width + x;
+    if (x < 0 || x >= width || y < 0 || y >= height) continue;
+    if (visited[idx]) continue;
+    if (!isDiffPixel(mask, idx * 4)) continue;
+    visited[idx] = 1;
+    count++;
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+    stack.push([x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]);
+  }
+  return {
+    bounds: { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 },
+    pixelCount: count
+  };
+}
+function shouldMerge(a, b, gap) {
+  const aRight = a.x + a.width + gap;
+  const aBottom = a.y + a.height + gap;
+  const bRight = b.x + b.width + gap;
+  const bBottom = b.y + b.height + gap;
+  return !(a.x - gap > bRight || b.x - gap > aRight || a.y - gap > bBottom || b.y - gap > aBottom);
+}
+function mergeBounds(a, b) {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return {
+    x,
+    y,
+    width: Math.max(a.x + a.width, b.x + b.width) - x,
+    height: Math.max(a.y + a.height, b.y + b.height) - y
+  };
+}
+function extractRegions(diffMask, width, height, options) {
+  const visited = new Uint8Array(width * height);
+  let rawRegions = [];
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      if (visited[idx] || !isDiffPixel(diffMask, idx * 4)) continue;
+      rawRegions.push(floodFill(diffMask, visited, width, height, x, y));
+    }
+  }
+  let merged = true;
+  while (merged) {
+    merged = false;
+    const next = [];
+    const used = /* @__PURE__ */ new Set();
+    for (let i = 0; i < rawRegions.length; i++) {
+      if (used.has(i)) continue;
+      let current = rawRegions[i];
+      for (let j = i + 1; j < rawRegions.length; j++) {
+        if (used.has(j)) continue;
+        if (shouldMerge(current.bounds, rawRegions[j].bounds, options.mergeGap)) {
+          current = {
+            bounds: mergeBounds(current.bounds, rawRegions[j].bounds),
+            pixelCount: current.pixelCount + rawRegions[j].pixelCount
+          };
+          used.add(j);
+          merged = true;
+        }
+      }
+      next.push(current);
+    }
+    rawRegions = next;
+  }
+  const totalPixels = width * height;
+  return rawRegions.filter((r) => r.bounds.width * r.bounds.height >= options.minArea).map((r, i) => ({
+    id: `region-${i}`,
+    bounds: r.bounds,
+    pixelCount: r.pixelCount,
+    percentage: totalPixels > 0 ? r.pixelCount / totalPixels * 100 : 0
+  }));
+}
+
+// src/diff/ignore-rules.ts
+function boxesOverlap(a, b) {
+  return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+}
+function regionMatchesColorRange(region, range, ctx) {
+  const { bounds } = region;
+  const endX = Math.min(bounds.x + bounds.width, ctx.width);
+  const endY = Math.min(bounds.y + bounds.height, ctx.height);
+  for (let y = bounds.y; y < endY; y++) {
+    for (let x = bounds.x; x < endX; x++) {
+      const idx = (y * ctx.width + x) * 4;
+      const r = ctx.screenshotPixels[idx];
+      const g = ctx.screenshotPixels[idx + 1];
+      const b = ctx.screenshotPixels[idx + 2];
+      if (r < range.r[0] || r > range.r[1]) return false;
+      if (g < range.g[0] || g > range.g[1]) return false;
+      if (b < range.b[0] || b > range.b[1]) return false;
+    }
+  }
+  return true;
+}
+function isIgnored(region, rule, ctx) {
+  switch (rule.type) {
+    case "boundingBox":
+      return boxesOverlap(region.bounds, rule.value);
+    case "colorRange":
+      if (!ctx) return false;
+      return regionMatchesColorRange(region, rule.value, ctx);
+    default:
+      return false;
+  }
+}
+function filterByIgnoreRules(regions, rules, pixelContext) {
+  if (rules.length === 0) return regions;
+  return regions.filter((region) => !rules.some((rule) => isIgnored(region, rule, pixelContext)));
+}
+
+// src/diff/mask-generator.ts
+import sharp4 from "sharp";
+async function generateDiffMask(screenshotBuffer, diffMask, width, height, color) {
+  const overlay = Buffer.alloc(width * height * 4);
+  const alpha = Math.round(color.a * 255);
+  for (let i = 0; i < width * height; i++) {
+    const idx = i * 4;
+    const hasDiff = diffMask[idx] > 0 || diffMask[idx + 1] > 0 || diffMask[idx + 2] > 0;
+    if (hasDiff) {
+      overlay[idx] = color.r;
+      overlay[idx + 1] = color.g;
+      overlay[idx + 2] = color.b;
+      overlay[idx + 3] = alpha;
+    } else {
+      overlay[idx + 3] = 0;
+    }
+  }
+  const overlayPng = await sharp4(overlay, { raw: { width, height, channels: 4 } }).png().toBuffer();
+  return sharp4(screenshotBuffer).composite([{ input: overlayPng, blend: "over" }]).png().toBuffer();
+}
+
+// src/diff/viewport.ts
+import sharp5 from "sharp";
+async function cropViewport(imageBuffer, options) {
+  const metadata = await sharp5(imageBuffer).metadata();
+  const width = metadata.width;
+  let height = metadata.height;
+  let top = 0;
+  if (options.cropStatusBar) {
+    const barHeight = options.platform === "android" ? options.statusBarHeight.android : options.statusBarHeight.ios;
+    top = barHeight;
+    height -= barHeight;
+  }
+  if (top === 0 && height === metadata.height) {
+    return { buffer: imageBuffer, width, height };
+  }
+  const buffer = await sharp5(imageBuffer).extract({ left: 0, top, width, height }).png().toBuffer();
+  return { buffer, width, height };
+}
+
+// src/diff/compare.ts
+import sharp6 from "sharp";
+function sanitizeDiffMask(mask, width, height) {
+  const clean = Buffer.alloc(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const idx = i * 4;
+    const r = mask[idx];
+    const g = mask[idx + 1];
+    const b = mask[idx + 2];
+    if (r > 0 && g === 0 && b === 0) {
+      clean[idx] = r;
+      clean[idx + 1] = g;
+      clean[idx + 2] = b;
+      clean[idx + 3] = mask[idx + 3];
+    }
+  }
+  return clean;
+}
+async function runComparison(designPath, screenshotPath, options) {
+  const start = Date.now();
+  let design = await loadImage(designPath);
+  let screenshot = await loadImage(screenshotPath);
+  if (options.viewport) {
+    const vpOpts = { ...options.viewport, platform: options.platform };
+    const croppedDesign = await cropViewport(design.buffer, vpOpts);
+    const croppedScreenshot = await cropViewport(screenshot.buffer, vpOpts);
+    design = {
+      buffer: croppedDesign.buffer,
+      width: croppedDesign.width,
+      height: croppedDesign.height,
+      aspectRatio: croppedDesign.width / croppedDesign.height,
+      rawPixels: await sharp6(croppedDesign.buffer).ensureAlpha().raw().toBuffer()
+    };
+    screenshot = {
+      buffer: croppedScreenshot.buffer,
+      width: croppedScreenshot.width,
+      height: croppedScreenshot.height,
+      aspectRatio: croppedScreenshot.width / croppedScreenshot.height,
+      rawPixels: await sharp6(croppedScreenshot.buffer).ensureAlpha().raw().toBuffer()
+    };
+  }
+  const aligned = await alignImages(design, screenshot);
+  const diff = computePixelDiff(aligned, options.threshold);
+  const cleanMask = sanitizeDiffMask(diff.diffMask, diff.width, diff.height);
+  let regions = extractRegions(cleanMask, diff.width, diff.height, {
+    mergeGap: options.regionMergeGap,
+    minArea: options.regionMinArea
+  });
+  regions = filterByIgnoreRules(regions, options.ignoreRules);
+  const diffMaskBuffer = await generateDiffMask(
+    screenshot.buffer,
+    cleanMask,
+    diff.width,
+    diff.height,
+    options.diffMaskColor
+  );
+  const regionCrops = await Promise.all(
+    regions.map(async (r) => {
+      const crop = await sharp6(screenshot.buffer).extract({
+        left: r.bounds.x,
+        top: r.bounds.y,
+        width: Math.min(r.bounds.width, diff.width - r.bounds.x),
+        height: Math.min(r.bounds.height, diff.height - r.bounds.y)
+      }).png().toBuffer();
+      return { id: r.id, buffer: crop };
+    })
+  );
+  return {
+    totalPixels: diff.totalPixels,
+    diffPixels: diff.diffPixels,
+    diffPercentage: diff.diffPercentage,
+    regions,
+    diffMaskBuffer,
+    regionCrops,
+    width: diff.width,
+    height: diff.height,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/inspect/component-matcher.ts
+function boxesOverlap2(a, b) {
+  return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+}
+function overlapArea(a, b) {
+  const x1 = Math.max(a.x, b.x);
+  const y1 = Math.max(a.y, b.y);
+  const x2 = Math.min(a.x + a.width, b.x + b.width);
+  const y2 = Math.min(a.y + a.height, b.y + b.height);
+  if (x2 <= x1 || y2 <= y1) return 0;
+  return (x2 - x1) * (y2 - y1);
+}
+function findDeepestOverlap(nodes, regionBounds, depth) {
+  let best = null;
+  const regionArea = regionBounds.width * regionBounds.height;
+  for (const node of nodes) {
+    if (!boxesOverlap2(node.bounds, regionBounds)) continue;
+    const overlap = overlapArea(node.bounds, regionBounds);
+    const ratio = regionArea > 0 ? overlap / regionArea : 0;
+    if (ratio > 0.5) {
+      const childMatch = findDeepestOverlap(node.children, regionBounds, depth + 1);
+      if (childMatch && childMatch.overlapRatio > 0.5) {
+        if (!best || childMatch.depth > best.depth) {
+          best = childMatch;
+        }
+      } else {
+        if (!best || depth > best.depth || depth === best.depth && ratio > best.overlapRatio) {
+          best = { node, depth, overlapRatio: ratio };
+        }
+      }
+    }
+  }
+  return best;
+}
+function computeConfidence(node, overlapRatio) {
+  let base;
+  if (node.inspectionTier === "detailed") {
+    base = 0.6;
+    if (node.source) base = 0.8;
+  } else {
+    base = 0.4;
+  }
+  const overlapBonus = Math.min(overlapRatio * 0.2, 0.2);
+  return Math.min(base + overlapBonus, node.inspectionTier === "detailed" ? 0.95 : 0.6);
+}
+function matchRegionsToComponents(regions, tree) {
+  const matches = [];
+  for (const region of regions) {
+    const candidate = findDeepestOverlap(tree, region.bounds, 0);
+    if (!candidate) continue;
+    const { node, depth, overlapRatio } = candidate;
+    const confidence = computeConfidence(node, overlapRatio);
+    matches.push({
+      regionId: region.id,
+      component: {
+        name: node.reactName ?? node.name,
+        testID: node.testID,
+        source: node.source,
+        bounds: node.bounds,
+        depth
+      },
+      confidence,
+      overlapRatio
+    });
+  }
+  return matches;
+}
+
+// src/inspect/finding-generator.ts
+function classifySeverity(pixelPercentage) {
+  if (pixelPercentage >= 10) return "critical";
+  if (pixelPercentage >= 3) return "major";
+  if (pixelPercentage >= 0.5) return "minor";
+  return "info";
+}
+function generateFindings(regions, matches, totalPixels) {
+  const matchMap = new Map(matches.map((m) => [m.regionId, m]));
+  return regions.map((region, i) => {
+    const match = matchMap.get(region.id);
+    const pixelPct = totalPixels > 0 ? region.pixelCount / totalPixels * 100 : 0;
+    const evidence = [
+      { type: "pixel", score: pixelPct / 100, note: `${pixelPct.toFixed(1)}% pixel difference in region` }
+    ];
+    if (match) {
+      evidence.push({
+        type: "tree",
+        score: match.confidence,
+        note: `Matched to ${match.component.name} via bounds overlap (${Math.round(match.overlapRatio * 100)}%)`
+      });
+    }
+    return {
+      id: `diff-${i}`,
+      category: "unknown",
+      severity: classifySeverity(pixelPct),
+      confidence: match?.confidence ?? 0.3,
+      region: region.bounds,
+      component: match?.component,
+      evidence
+    };
+  });
+}
+
+// src/analyses/plugins/pixel.ts
+var PixelAnalysis = class {
+  name = "pixel";
+  description = "Pixel-level image comparison between screenshot and design";
+  isAvailable(ctx) {
+    return !!ctx.design;
+  }
+  async run(ctx) {
+    const start = Date.now();
+    const { config } = ctx;
+    const [mr, mg, mb, ma] = config.diffMaskColor;
+    const compareResult = await runComparison(ctx.design.path, ctx.screenshot.path, {
+      threshold: config.threshold,
+      diffThreshold: config.diffThreshold,
+      regionMergeGap: config.regionMergeGap,
+      regionMinArea: config.regionMinArea,
+      ignoreRules: config.ignoreRules,
+      diffMaskColor: { r: mr, g: mg, b: mb, a: ma / 255 },
+      platform: config.platform
+    });
+    await ctx.store.writeArtifact(ctx.runId, "diff-mask.png", compareResult.diffMaskBuffer);
+    for (const crop of compareResult.regionCrops) {
+      await ctx.store.writeArtifact(ctx.runId, `regions/${crop.id}.png`, crop.buffer);
+    }
+    const matches = ctx.tree?.length ? matchRegionsToComponents(compareResult.regions, ctx.tree) : [];
+    const findings = generateFindings(
+      compareResult.regions,
+      matches,
+      compareResult.totalPixels
+    );
+    const passed = compareResult.diffPercentage <= config.diffThreshold;
+    return {
+      analysisName: this.name,
+      findings,
+      summary: passed ? `Pixel diff: ${compareResult.diffPercentage.toFixed(3)}% (pass)` : `Pixel diff: ${compareResult.diffPercentage.toFixed(3)}% \u2014 ${compareResult.regions.length} regions (fail)`,
+      metadata: {
+        totalPixels: compareResult.totalPixels,
+        diffPixels: compareResult.diffPixels,
+        diffPercentage: compareResult.diffPercentage,
+        regions: compareResult.regions,
+        durationMs: compareResult.durationMs,
+        passed
+      },
+      durationMs: Date.now() - start
+    };
+  }
+};
+
+// src/analyses/plugins/a11y.ts
+var INTERACTIVE_NAMES = /* @__PURE__ */ new Set([
+  "Pressable",
+  "TouchableOpacity",
+  "Button",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback"
+]);
+function isInteractive(name) {
+  if (INTERACTIVE_NAMES.has(name)) return true;
+  return name.includes("Button") || name.includes("Pressable");
+}
+function collectNodes(nodes) {
+  const result = [];
+  const stack = [...nodes];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    result.push(node);
+    for (const child of node.children) {
+      stack.push(child);
+    }
+  }
+  return result;
+}
+var AccessibilityAnalysis = class {
+  name = "a11y";
+  description = "Accessibility audit of component tree";
+  isAvailable(ctx) {
+    return !!ctx.tree?.length;
+  }
+  async run(ctx) {
+    const start = Date.now();
+    const nodes = collectNodes(ctx.tree ?? []);
+    const platform = ctx.config.platform;
+    const tapThreshold = platform === "ios" ? 44 : 48;
+    const findings = [];
+    let labelCount = 0;
+    let tapTargetCount = 0;
+    let imageCount = 0;
+    let emptyTextCount = 0;
+    for (const node of nodes) {
+      if (isInteractive(node.name) && !node.testID) {
+        const styles = node.styles ?? {};
+        const hasLabel = "accessibilityLabel" in styles || "aria-label" in styles;
+        if (!hasLabel) {
+          findings.push({
+            id: `a11y-label-${labelCount++}`,
+            category: "accessibility",
+            severity: "major",
+            confidence: 1,
+            region: node.bounds,
+            component: { name: node.name, testID: node.testID, bounds: node.bounds, depth: 0 },
+            evidence: [{ type: "accessibility", score: 1, note: `Interactive component "${node.name}" is missing an accessibilityLabel` }],
+            description: `Interactive component "${node.name}" is missing an accessibilityLabel`
+          });
+        }
+      }
+      if (node.bounds.width > 0 && node.bounds.height > 0) {
+        if (node.bounds.width < tapThreshold || node.bounds.height < tapThreshold) {
+          if (isInteractive(node.name)) {
+            findings.push({
+              id: `a11y-tap-${tapTargetCount++}`,
+              category: "accessibility",
+              severity: "minor",
+              confidence: 1,
+              region: node.bounds,
+              component: { name: node.name, testID: node.testID, bounds: node.bounds, depth: 0 },
+              evidence: [{ type: "accessibility", score: 1, note: `Tap target "${node.name}" is ${node.bounds.width}x${node.bounds.height}, smaller than ${tapThreshold}x${tapThreshold}` }],
+              description: `Tap target "${node.name}" is ${node.bounds.width}x${node.bounds.height}, smaller than the recommended ${tapThreshold}x${tapThreshold}`
+            });
+          }
+        }
+      }
+      if (node.name.includes("Image")) {
+        const styles = node.styles ?? {};
+        const hasAlt = "accessibilityLabel" in styles || "aria-label" in styles || "alt" in styles;
+        if (!hasAlt) {
+          findings.push({
+            id: `a11y-image-${imageCount++}`,
+            category: "accessibility",
+            severity: "major",
+            confidence: 1,
+            region: node.bounds,
+            component: { name: node.name, testID: node.testID, bounds: node.bounds, depth: 0 },
+            evidence: [{ type: "accessibility", score: 1, note: `Image component "${node.name}" is missing an accessibilityLabel or alt text` }],
+            description: `Image component "${node.name}" is missing an accessibilityLabel or alt text`
+          });
+        }
+      }
+      if (node.text === "") {
+        findings.push({
+          id: `a11y-empty-${emptyTextCount++}`,
+          category: "accessibility",
+          severity: "info",
+          confidence: 1,
+          region: node.bounds,
+          component: { name: node.name, testID: node.testID, bounds: node.bounds, depth: 0 },
+          evidence: [{ type: "accessibility", score: 1, note: `Component "${node.name}" has an empty text node` }],
+          description: `Component "${node.name}" has an empty text node`
+        });
+      }
+    }
+    const totalIssues = findings.length;
+    const summary = totalIssues === 0 ? "No accessibility issues" : `${totalIssues} accessibility issue${totalIssues === 1 ? "" : "s"} found`;
+    return {
+      analysisName: this.name,
+      findings,
+      summary,
+      metadata: {
+        totalChecked: nodes.length,
+        issuesByType: {
+          label: labelCount,
+          tapTarget: tapTargetCount,
+          image: imageCount,
+          emptyText: emptyTextCount
+        }
+      },
+      durationMs: Date.now() - start
+    };
+  }
+};
+
+// src/analyses/plugins/regression.ts
+var RegressionAnalysis = class {
+  name = "regression";
+  description = "Layout regression detection against previous baseline";
+  isAvailable(ctx) {
+    return !!ctx.baseline;
+  }
+  async run(ctx) {
+    const start = Date.now();
+    const { config } = ctx;
+    const [mr, mg, mb, ma] = config.diffMaskColor;
+    const compareResult = await runComparison(ctx.baseline.path, ctx.screenshot.path, {
+      threshold: config.threshold,
+      diffThreshold: config.diffThreshold,
+      regionMergeGap: config.regionMergeGap,
+      regionMinArea: config.regionMinArea,
+      ignoreRules: config.ignoreRules,
+      diffMaskColor: { r: mr, g: mg, b: mb, a: ma / 255 },
+      platform: config.platform
+    });
+    await ctx.store.writeArtifact(ctx.runId, "regression-diff-mask.png", compareResult.diffMaskBuffer);
+    for (const crop of compareResult.regionCrops) {
+      await ctx.store.writeArtifact(ctx.runId, `regression-regions/${crop.id}.png`, crop.buffer);
+    }
+    const regressionThreshold = ctx.analysisConfig.options["regression"]?.regressionThreshold;
+    const passed = compareResult.diffPercentage <= (regressionThreshold ?? config.diffThreshold);
+    const findings = compareResult.regions.map((region, index) => ({
+      id: `regression-${index}`,
+      category: "regression",
+      severity: "major",
+      confidence: 1,
+      region: region.bounds,
+      component: { name: "region", bounds: region.bounds, depth: 0 },
+      evidence: [{ type: "regression", score: region.percentage / 100, note: `${region.percentage.toFixed(3)}% changed` }],
+      description: `Region ${region.id}: ${region.percentage.toFixed(3)}% changed (${region.pixelCount}px)`
+    }));
+    return {
+      analysisName: this.name,
+      findings,
+      summary: passed ? "Regression: no changes detected" : `Regression: ${compareResult.diffPercentage.toFixed(3)}% changed, ${compareResult.regions.length} regions`,
+      metadata: {
+        totalPixels: compareResult.totalPixels,
+        diffPixels: compareResult.diffPixels,
+        diffPercentage: compareResult.diffPercentage,
+        regions: compareResult.regions,
+        passed
+      },
+      durationMs: Date.now() - start
+    };
+  }
+};
+
+// src/analyses/default-registry.ts
+function createDefaultRegistry() {
+  const registry = new AnalysisRegistry();
+  registry.register(new PixelAnalysis());
+  registry.register(new AccessibilityAnalysis());
+  registry.register(new RegressionAnalysis());
+  return registry;
+}
+
+// src/analyses/orchestrator.ts
+var AnalysisOrchestrator = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async run(ctx) {
+    const start = Date.now();
+    const plugins = this.selectPlugins(ctx);
+    const settled = await Promise.allSettled(
+      plugins.map((plugin) => plugin.run(ctx))
+    );
+    const analyses = settled.map((result, i) => {
+      if (result.status === "fulfilled") return result.value;
+      return {
+        analysisName: plugins[i].name,
+        findings: [],
+        summary: `Error: ${result.reason?.message ?? "unknown error"}`,
+        metadata: {},
+        durationMs: 0,
+        error: result.reason?.message ?? "unknown error"
+      };
+    });
+    const findings = analyses.flatMap((a) => a.findings);
+    const summaries = analyses.map((a) => a.summary).join("; ");
+    const durationMs = Date.now() - start;
+    return {
+      runId: ctx.runId,
+      analyses,
+      findings,
+      summary: summaries,
+      metadata: {},
+      durationMs
+    };
+  }
+  selectPlugins(ctx) {
+    let plugins = this.registry.all();
+    const { enabled, disabled } = ctx.analysisConfig;
+    if (enabled.length > 0) {
+      plugins = plugins.filter((p) => enabled.includes(p.name));
+    }
+    if (disabled.length > 0) {
+      plugins = plugins.filter((p) => !disabled.includes(p.name));
+    }
+    return plugins.filter((p) => p.isAvailable(ctx));
+  }
+};
+
+// src/commands/compare.ts
+import * as fs7 from "fs";
+async function runCompare(shell, config, options) {
+  const store = new RunStore(process.cwd());
+  const run2 = store.createRun();
+  let screenshotPath;
+  let deviceId = "unknown";
+  let platform = config.platform;
+  let deviceInfo;
+  if (options.screenshot) {
+    screenshotPath = options.screenshot;
+  } else {
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (options.device) {
+      device = booted.find((d) => d.id === options.device || d.name === options.device);
+      if (!device) throw new Error(`Device not found: ${options.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    deviceId = device.id;
+    platform = device.platform;
+    deviceInfo = device;
+    const buffer = await captureScreenshot(shell, device, {
+      settleCheck: config.settleCheckEnabled,
+      settleMaxDelta: config.settleMaxDelta,
+      settleDelayMs: config.settleTimeMs
+    });
+    screenshotPath = store.getRunPath(run2.runId, "screenshot.png");
+    await store.writeArtifact(run2.runId, "screenshot.png", buffer);
+  }
+  const screenshotImage = await buildDriftxImage(screenshotPath);
+  let designImage;
+  if (options.design) {
+    const designBuffer = fs7.readFileSync(options.design);
+    await store.writeArtifact(run2.runId, "design.png", designBuffer);
+    designImage = await buildDriftxImage(options.design);
+  }
+  let baselineImage;
+  if (options.baseline) {
+    const latestRunId = store.getLatestRun();
+    if (latestRunId) {
+      const baselinePath = store.getRunPath(latestRunId, "screenshot.png");
+      if (fs7.existsSync(baselinePath)) {
+        baselineImage = await buildDriftxImage(baselinePath);
+      }
+    }
+  }
+  let inspectResult;
+  let inspectionCapabilities = {
+    tree: "none",
+    sourceMapping: "none",
+    styles: "none",
+    protocol: "none"
+  };
+  if (deviceInfo) {
+    const inspector = new TreeInspector(shell, process.cwd());
+    inspectResult = await inspector.inspect(deviceInfo, {
+      metroPort: config.metroPort,
+      devToolsPort: config.devToolsPort,
+      timeoutMs: config.timeouts.treeInspectionMs
+    });
+    inspectionCapabilities = inspectResult.capabilities;
+  }
+  const analysisConfig = buildAnalysisConfig(config.analyses, options.with, options.without);
+  const ctx = {
+    screenshot: screenshotImage,
+    design: designImage,
+    baseline: baselineImage,
+    tree: inspectResult?.tree,
+    device: deviceInfo,
+    config,
+    analysisConfig,
+    runId: run2.runId,
+    store
+  };
+  const registry = createDefaultRegistry();
+  const orchestrator = new AnalysisOrchestrator(registry);
+  const report = await orchestrator.run(ctx);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    runId: run2.runId,
+    startedAt,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectRoot: process.cwd(),
+    deviceId,
+    platform,
+    orientation: "portrait",
+    framework: "unknown",
+    driftxVersion: "0.1.0",
+    configHash: ""
+  };
+  report.metadata = metadata;
+  await store.writeMetadata(run2.runId, metadata);
+  const resultJson = JSON.stringify(report, null, 2);
+  await store.writeArtifact(run2.runId, "result.json", Buffer.from(resultJson));
+  const anyFailed = report.analyses.some((a) => {
+    const meta = a.metadata;
+    return meta.passed === false;
+  });
+  const exitCode = anyFailed ? ExitCode.DiffFound : ExitCode.Success;
+  const formatData = {
+    report,
+    device: deviceInfo ? { name: deviceInfo.name, platform: deviceInfo.platform } : void 0,
+    artifactDir: store.getRunPath(run2.runId),
+    tree: inspectResult?.tree,
+    inspectHints: inspectResult?.hints
+  };
+  const reportMarkdown = compareFormatter.markdown(formatData);
+  await store.writeArtifact(run2.runId, "report.md", Buffer.from(reportMarkdown));
+  return { report, exitCode, formatData };
+}
+
+// src/formatters/clipboard.ts
+import { exec } from "child_process";
+function getClipboardCommand(platform) {
+  if (platform === "darwin") return "pbcopy";
+  if (platform === "win32") return "clip";
+  if (platform === "linux") return "xclip -selection clipboard";
+  return void 0;
+}
+async function copyToClipboard(text) {
+  const logger = getLogger();
+  const cmd = getClipboardCommand(process.platform);
+  if (!cmd) {
+    logger.debug(`Clipboard not supported on ${process.platform}`);
+    return;
+  }
+  return new Promise((resolve2) => {
+    const proc = exec(cmd, (err) => {
+      if (err) {
+        logger.debug(`Clipboard copy failed: ${err.message}`);
+      }
+      resolve2();
+    });
+    proc.stdin?.write(text);
+    proc.stdin?.end();
+  });
+}
+
+// src/formatters/format.ts
+async function formatOutput(formatter, data, ctx) {
+  const output = formatter[ctx.format](data);
+  if (!ctx.quiet) {
+    console.log(output);
+  }
+  if (ctx.copy) {
+    const clipboardContent = ctx.format === "terminal" ? formatter.markdown(data) : output;
+    await copyToClipboard(clipboardContent);
+  }
+  return output;
+}
+
+// src/formatters/devices.ts
+import pc2 from "picocolors";
+function stateLabel(state) {
+  if (state === "booted") return pc2.green("\u25CF booted");
+  if (state === "offline") return pc2.yellow("\u25CB offline");
+  return pc2.red("\u2717 unauthorized");
+}
+function stateText(state) {
+  if (state === "booted") return "booted";
+  if (state === "offline") return "offline";
+  return "unauthorized";
+}
+var devicesFormatter = {
+  terminal(devices) {
+    if (devices.length === 0) {
+      return "No devices found. Start an emulator or connect a device.";
+    }
+    const lines = [];
+    const header = `  ${"ID".padEnd(20)} ${"Name".padEnd(20)} ${"Platform".padEnd(10)} ${"OS".padEnd(10)} ${"State"}`;
+    lines.push("");
+    lines.push(header);
+    lines.push("  " + "-".repeat(70));
+    for (const d of devices) {
+      lines.push(`  ${d.id.padEnd(20)} ${d.name.padEnd(20)} ${d.platform.padEnd(10)} ${(d.osVersion || "-").padEnd(10)} ${stateLabel(d.state)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  },
+  markdown(devices) {
+    if (devices.length === 0) {
+      return "# Driftx Devices\n\nNo devices found. Start an emulator or connect a device.";
+    }
+    const lines = ["# Driftx Devices", "", "| ID | Name | Platform | OS | State |", "|----|------|----------|-----|-------|"];
+    for (const d of devices) {
+      lines.push(`| ${d.id} | ${d.name} | ${d.platform} | ${d.osVersion || "-"} | ${stateText(d.state)} |`);
+    }
+    return lines.join("\n");
+  },
+  json(devices) {
+    return JSON.stringify(devices, null, 2);
+  }
+};
+
+// src/formatters/doctor.ts
+import pc3 from "picocolors";
+var doctorFormatter = {
+  terminal(checks) {
+    const lines = [];
+    lines.push("Prerequisite Check");
+    lines.push("\u2500".repeat(60));
+    for (const check of checks) {
+      const icon = check.available ? pc3.green("+") : pc3.red("-");
+      const status = check.available ? "ok" : pc3.red("missing");
+      const version = check.version ?? "";
+      const required = check.required ? "required" : "optional";
+      lines.push(`  [${icon}] ${check.name.padEnd(12)} ${String(status).padEnd(10)} ${version.padEnd(16)} (${required})`);
+      if (!check.available && check.fix) {
+        lines.push(`      Fix: ${check.fix}`);
+      }
+    }
+    lines.push("\u2500".repeat(60));
+    return lines.join("\n");
+  },
+  markdown(checks) {
+    const lines = ["# Driftx Doctor", "", "| Tool | Status | Version | Required | Fix |", "|------|--------|---------|----------|-----|"];
+    for (const check of checks) {
+      const status = check.available ? "available" : "unavailable";
+      const version = check.version || "\u2014";
+      const required = check.required ? "yes" : "no";
+      const fix = check.fix || "\u2014";
+      lines.push(`| ${check.name} | ${status} | ${version} | ${required} | ${fix} |`);
+    }
+    return lines.join("\n");
+  },
+  json(checks) {
+    return JSON.stringify(checks, null, 2);
+  }
+};
+
+// src/formatters/inspect.ts
+import pc4 from "picocolors";
+var STRATEGY_LABELS = {
+  cdp: "CDP via Metro (React DevTools)",
+  uiautomator: "UIAutomator (native Android)",
+  idb: "idb (native iOS)",
+  none: "None"
+};
+function formatTreeText(nodes, indent = 0) {
+  const lines = [];
+  for (const node of nodes) {
+    const prefix = "  ".repeat(indent);
+    const name = node.reactName ?? node.name;
+    const testId = node.testID ? ` [${node.testID}]` : "";
+    const text = node.text ? ` "${node.text}"` : "";
+    const tier = node.inspectionTier === "detailed" ? " \u269B" : "";
+    const b = node.bounds;
+    const bounds = b.width > 0 ? ` (${b.x},${b.y} ${b.width}x${b.height})` : "";
+    lines.push(`${prefix}${name}${testId}${text}${bounds}${tier}`);
+    const childStr = formatTreeText(node.children, indent + 1);
+    if (childStr) lines.push(childStr);
+  }
+  return lines.join("\n");
+}
+function formatStrategySection(result, colored) {
+  const lines = [];
+  const label = STRATEGY_LABELS[result.strategy.method] ?? result.strategy.method;
+  const strategyText = colored ? result.strategy.method === "none" ? pc4.dim(label) : pc4.cyan(label) : label;
+  lines.push("");
+  lines.push(`  Device:    ${result.device.name} (${result.device.platform})`);
+  lines.push(`  Strategy:  ${strategyText}`);
+  if (result.strategy.appId) {
+    lines.push(`  App:       ${result.strategy.appId}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatCapsSection(caps) {
+  const lines = [];
+  lines.push("  Capabilities");
+  lines.push("  " + "-".repeat(40));
+  lines.push(`  Tree:           ${caps.tree}`);
+  lines.push(`  Source mapping:  ${caps.sourceMapping}`);
+  lines.push(`  Styles:         ${caps.styles}`);
+  lines.push(`  Protocol:       ${caps.protocol}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function formatHintsSection(hints, colored) {
+  if (hints.length === 0) return "";
+  const lines = ["", "  Hints", "  " + "-".repeat(40)];
+  for (const hint of hints) {
+    lines.push(colored ? `  ${pc4.yellow(hint)}` : `  ${hint}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var inspectFormatter = {
+  terminal(result) {
+    const parts = [formatStrategySection(result, true)];
+    if (result.tree.length === 0) {
+      parts.push("  No component tree available. Try running with React DevTools enabled.");
+      parts.push(formatHintsSection(result.hints, true));
+      return parts.filter(Boolean).join("\n");
+    }
+    parts.push(formatTreeText(result.tree));
+    parts.push("");
+    parts.push(formatCapsSection(result.capabilities));
+    parts.push(formatHintsSection(result.hints, true));
+    return parts.filter(Boolean).join("\n");
+  },
+  markdown(result) {
+    const lines = [
+      "# Driftx Inspect Report",
+      "",
+      `**Device:** ${result.device.name} (${result.device.platform})`,
+      `**Strategy:** ${STRATEGY_LABELS[result.strategy.method] ?? result.strategy.method}`
+    ];
+    if (result.strategy.appId) {
+      lines.push(`**App:** ${result.strategy.appId}`);
+    }
+    if (result.tree.length > 0) {
+      lines.push("", "## Component Tree", "", "```", formatTreeText(result.tree), "```");
+    } else {
+      lines.push("", "No component tree available.");
+    }
+    lines.push("", "## Capabilities", "", "| Capability | Level |", "|------------|-------|");
+    lines.push(`| Tree | ${result.capabilities.tree} |`);
+    lines.push(`| Source mapping | ${result.capabilities.sourceMapping} |`);
+    lines.push(`| Styles | ${result.capabilities.styles} |`);
+    lines.push(`| Protocol | ${result.capabilities.protocol} |`);
+    if (result.hints.length > 0) {
+      lines.push("", "## Hints", "");
+      for (const hint of result.hints) {
+        lines.push(`- ${hint}`);
+      }
+    }
+    return lines.join("\n");
+  },
+  json(result) {
+    return JSON.stringify({
+      tree: result.tree,
+      capabilities: result.capabilities,
+      strategy: result.strategy,
+      device: result.device,
+      hints: result.hints
+    }, null, 2);
+  }
+};
+
+// src/interact/android.ts
+var AndroidBackend = class {
+  constructor(shell) {
+    this.shell = shell;
+  }
+  async tap(device, point) {
+    await this.adb(device, ["input", "tap", String(point.x), String(point.y)]);
+  }
+  async longPress(device, point, durationMs) {
+    await this.adb(device, ["input", "swipe", String(point.x), String(point.y), String(point.x), String(point.y), String(durationMs)]);
+  }
+  async swipe(device, from, to, durationMs) {
+    await this.adb(device, ["input", "swipe", String(from.x), String(from.y), String(to.x), String(to.y), String(durationMs)]);
+  }
+  async type(device, text) {
+    const escaped = text.replace(/ /g, "%s");
+    await this.adb(device, ["input", "text", escaped]);
+  }
+  async keyEvent(device, key) {
+    await this.adb(device, ["input", "keyevent", key]);
+  }
+  async openUrl(device, url) {
+    await this.shell.exec("adb", ["-s", device.id, "shell", "am", "start", "-a", "android.intent.action.VIEW", "-d", url]);
+  }
+  async adb(device, inputArgs) {
+    await this.shell.exec("adb", ["-s", device.id, "shell", ...inputArgs]);
+  }
+};
+
+// src/interact/ios.ts
+var IosBackend = class {
+  constructor(shell) {
+    this.shell = shell;
+  }
+  async tap(device, point) {
+    await this.simctlIo(device, ["tap", String(point.x), String(point.y)]);
+  }
+  async longPress(device, point, _durationMs) {
+    await this.simctlIo(device, ["longpress", String(point.x), String(point.y)]);
+  }
+  async swipe(device, from, to, _durationMs) {
+    await this.simctlIo(device, ["swipe", String(from.x), String(from.y), String(to.x), String(to.y)]);
+  }
+  async type(device, text) {
+    await this.simctlIo(device, ["type", text]);
+  }
+  async keyEvent(device, key) {
+    await this.simctlIo(device, ["sendkey", key]);
+  }
+  async openUrl(device, url) {
+    await this.shell.exec("xcrun", ["simctl", "openurl", device.id, url]);
+  }
+  async simctlIo(device, args) {
+    await this.shell.exec("xcrun", ["simctl", "io", device.id, ...args]);
+  }
+};
+
+// src/interact/backend.ts
+function createBackend(shell, platform) {
+  return platform === "android" ? new AndroidBackend(shell) : new IosBackend(shell);
+}
+
+// src/interact/resolver.ts
+function resolveTarget(tree, query) {
+  const nodes = flattenTree(tree);
+  const byTestID = nodes.find((n) => n.testID === query && hasSize(n));
+  if (byTestID) return centerOf(byTestID, `testID:${query}`);
+  const byName = nodes.find((n) => n.name === query && hasSize(n));
+  if (byName) return centerOf(byName, `name:${query}`);
+  const byText = nodes.find((n) => n.text === query && hasSize(n));
+  if (byText) return centerOf(byText, `text:${query}`);
+  return null;
+}
+function flattenTree(nodes) {
+  const result = [];
+  const stack = [...nodes];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    result.push(node);
+    for (const child of node.children) stack.push(child);
+  }
+  return result;
+}
+function hasSize(node) {
+  return node.bounds.width > 0 && node.bounds.height > 0;
+}
+function centerOf(node, resolvedFrom) {
+  return {
+    x: Math.round(node.bounds.x + node.bounds.width / 2),
+    y: Math.round(node.bounds.y + node.bounds.height / 2),
+    resolvedFrom
+  };
+}
+
+// src/interact/gestures.ts
+var GestureExecutor = class {
+  constructor(backend) {
+    this.backend = backend;
+  }
+  async tap(device, tree, query) {
+    const start = Date.now();
+    try {
+      const target = resolveTarget(tree, query);
+      if (!target) {
+        return { success: false, action: "tap", durationMs: Date.now() - start, error: `Target not found: ${query}` };
+      }
+      await this.backend.tap(device, target);
+      return { success: true, action: "tap", target, durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "tap", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async tapXY(device, x, y) {
+    const start = Date.now();
+    try {
+      const target = { x, y };
+      await this.backend.tap(device, target);
+      return { success: true, action: "tapXY", target, durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "tapXY", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async longPress(device, tree, query, durationMs = 1e3) {
+    const start = Date.now();
+    try {
+      const target = resolveTarget(tree, query);
+      if (!target) {
+        return { success: false, action: "longPress", durationMs: Date.now() - start, error: `Target not found: ${query}` };
+      }
+      await this.backend.longPress(device, target, durationMs);
+      return { success: true, action: "longPress", target, durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "longPress", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async swipe(device, direction, distance = 600, durationMs = 300) {
+    const start = Date.now();
+    try {
+      const cx = device.screenSize?.width ? Math.round(device.screenSize.width / 2) : 540;
+      const cy = device.screenSize?.height ? Math.round(device.screenSize.height / 2) : 960;
+      const from = { x: cx, y: cy };
+      const half = Math.round(distance / 2);
+      const to = direction === "up" ? { x: cx, y: cy - half } : direction === "down" ? { x: cx, y: cy + half } : direction === "left" ? { x: cx - half, y: cy } : { x: cx + half, y: cy };
+      await this.backend.swipe(device, from, to, durationMs);
+      return { success: true, action: "swipe", durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "swipe", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async typeInto(device, tree, query, text) {
+    const start = Date.now();
+    try {
+      const target = resolveTarget(tree, query);
+      if (!target) {
+        return { success: false, action: "typeInto", durationMs: Date.now() - start, error: `Target not found: ${query}` };
+      }
+      await this.backend.tap(device, target);
+      await this.backend.type(device, text);
+      return { success: true, action: "typeInto", target, durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "typeInto", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async goBack(device) {
+    const start = Date.now();
+    try {
+      const key = device.platform === "android" ? "KEYCODE_BACK" : "home";
+      await this.backend.keyEvent(device, key);
+      return { success: true, action: "goBack", durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "goBack", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+  async openUrl(device, url) {
+    const start = Date.now();
+    try {
+      await this.backend.openUrl(device, url);
+      return { success: true, action: "openUrl", durationMs: Date.now() - start };
+    } catch (e) {
+      return { success: false, action: "openUrl", durationMs: Date.now() - start, error: String(e) };
+    }
+  }
+};
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+function getFormatterContext(opts) {
+  return {
+    format: opts.format ?? "terminal",
+    copy: !!opts.copy,
+    quiet: !!opts.quiet
+  };
+}
+function createProgram() {
+  const program = new Command();
+  program.name("driftx").description("Visual diff tool for React Native and Android development").version(pkg.version).option("--verbose", "enable debug logging").option("--quiet", "suppress all output except errors").option("--format <type>", "output format: terminal, markdown, json", "terminal").option("--copy", "copy output to clipboard");
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    const opts = actionCommand.optsWithGlobals();
+    const level = opts.verbose ? "debug" : opts.quiet ? "silent" : "info";
+    setLogger(createLogger(level));
+  });
+  program.command("doctor").description("Check system prerequisites for driftx").action(async function() {
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const checks = await checkPrerequisites(shell, config.metroPort);
+    const ctx = getFormatterContext(this.optsWithGlobals());
+    await formatOutput(doctorFormatter, checks, ctx);
+    process.exitCode = computeDoctorExitCode(checks);
+  });
+  program.command("init").description("Initialize driftx configuration for this project").action(async () => {
+    const cwd = process.cwd();
+    const files = readdirSync2(cwd);
+    let packageJson;
+    try {
+      packageJson = JSON.parse(readFileSync8(join5(cwd, "package.json"), "utf-8"));
+    } catch {
+    }
+    const framework = detectFramework(files, packageJson);
+    const config = generateConfig(framework);
+    const configPath = join5(cwd, ".driftxrc.json");
+    writeFileSync4(configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(`Created ${configPath} (framework: ${framework})`);
+  });
+  program.command("devices").description("List connected devices and simulators").action(async function() {
+    const shell = new RealShell();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const ctx = getFormatterContext(this.optsWithGlobals());
+    await formatOutput(devicesFormatter, devices, ctx);
+  });
+  program.command("capture").description("Capture a screenshot from a device").option("-d, --device <id>", "device ID or name").option("-o, --output <path>", "output file path").option("--settle", "enable settle-time check").option("--no-settle", "disable settle-time check").action(async (opts) => {
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const result = await runCapture(shell, config, {
+      device: opts.device,
+      output: opts.output,
+      settleCheck: opts.settle
+    });
+    console.log(`Screenshot saved: ${result.path}`);
+    if (result.runId) {
+      console.log(`Run ID: ${result.runId}`);
+    }
+  });
+  program.command("compare").description("Compare a screenshot against a design").option("--design <path>", "path to design image").option("-d, --device <id>", "device ID or name").option("--threshold <n>", "diff percentage threshold", parseFloat).option("--screenshot <path>", "use existing screenshot instead of capturing").option("--with <analyses>", "comma-separated analyses to run").option("--without <analyses>", "exclude specific analyses").option("--baseline", "compare against previous run screenshot").action(async function(opts) {
+    if (!opts.design && !opts.baseline) {
+      throw new Error("Either --design or --baseline must be provided");
+    }
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const { exitCode, formatData } = await runCompare(shell, config, {
+      design: opts.design,
+      device: opts.device,
+      threshold: opts.threshold,
+      screenshot: opts.screenshot,
+      with: opts.with,
+      without: opts.without,
+      baseline: !!opts.baseline
+    });
+    const ctx = getFormatterContext(this.optsWithGlobals());
+    await formatOutput(compareFormatter, formatData, ctx);
+    process.exitCode = exitCode;
+  });
+  program.command("inspect").description("Inspect component tree on device").option("-d, --device <id>", "device ID or name").option("--json", "output as JSON (alias for --format json)").option("--capabilities", "show inspection capabilities only").action(async function(opts) {
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const inspector = new TreeInspector(shell, process.cwd());
+    const result = await inspector.inspect(device, {
+      metroPort: config.metroPort,
+      devToolsPort: config.devToolsPort,
+      timeoutMs: config.timeouts.treeInspectionMs
+    });
+    const globalOpts = this.optsWithGlobals();
+    if (opts.json) globalOpts.format = "json";
+    const ctx = getFormatterContext(globalOpts);
+    await formatOutput(inspectFormatter, result, ctx);
+  });
+  program.command("tap <target>").description("Tap a component by testID, name, or text").option("-d, --device <id>", "device ID or name").option("--xy", "treat target as x,y coordinates").action(async (target, opts) => {
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const backend = createBackend(shell, device.platform);
+    const executor = new GestureExecutor(backend);
+    let result;
+    if (opts.xy) {
+      const [x, y] = target.split(",").map(Number);
+      result = await executor.tapXY(device, x, y);
+    } else {
+      const inspector = new TreeInspector(shell, process.cwd());
+      const inspectResult = await inspector.inspect(device, {
+        metroPort: config.metroPort,
+        devToolsPort: config.devToolsPort,
+        timeoutMs: config.timeouts.treeInspectionMs
+      });
+      result = await executor.tap(device, inspectResult.tree, target);
+    }
+    console.log(JSON.stringify(result, null, 2));
+  });
+  program.command("type <target> <text>").description("Tap a component then type text into it").option("-d, --device <id>", "device ID or name").action(async (target, text, opts) => {
+    const shell = new RealShell();
+    const config = await loadConfig();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const inspector = new TreeInspector(shell, process.cwd());
+    const inspectResult = await inspector.inspect(device, {
+      metroPort: config.metroPort,
+      devToolsPort: config.devToolsPort,
+      timeoutMs: config.timeouts.treeInspectionMs
+    });
+    const backend = createBackend(shell, device.platform);
+    const executor = new GestureExecutor(backend);
+    const result = await executor.typeInto(device, inspectResult.tree, target, text);
+    console.log(JSON.stringify(result, null, 2));
+  });
+  program.command("swipe <direction>").description("Swipe up, down, left, or right").option("-d, --device <id>", "device ID or name").action(async (direction, opts) => {
+    const shell = new RealShell();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const backend = createBackend(shell, device.platform);
+    const executor = new GestureExecutor(backend);
+    const result = await executor.swipe(device, direction);
+    console.log(JSON.stringify(result, null, 2));
+  });
+  program.command("go-back").description("Press the back button").option("-d, --device <id>", "device ID or name").action(async (opts) => {
+    const shell = new RealShell();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const backend = createBackend(shell, device.platform);
+    const executor = new GestureExecutor(backend);
+    const result = await executor.goBack(device);
+    console.log(JSON.stringify(result, null, 2));
+  });
+  program.command("open-url <url>").description("Open a deep link or URL on the device").option("-d, --device <id>", "device ID or name").action(async (url, opts) => {
+    const shell = new RealShell();
+    const discovery = new DeviceDiscovery(shell);
+    const devices = await discovery.list();
+    const booted = devices.filter((d) => d.state === "booted");
+    if (booted.length === 0) throw new Error("No booted devices found");
+    let device;
+    if (opts.device) {
+      device = booted.find((d) => d.id === opts.device || d.name === opts.device);
+      if (!device) throw new Error(`Device not found: ${opts.device}`);
+    } else {
+      device = await pickDevice(booted);
+    }
+    const backend = createBackend(shell, device.platform);
+    const executor = new GestureExecutor(backend);
+    const result = await executor.openUrl(device, url);
+    console.log(JSON.stringify(result, null, 2));
+  });
+  program.command("setup-claude").description("Register driftx as a Claude Code plugin").action(() => {
+    const claudeDir = join5(homedir(), ".claude");
+    const pluginsDir = join5(claudeDir, "plugins");
+    const driftxPluginDir = join5(pluginsDir, "driftx");
+    const registryPath = join5(pluginsDir, "installed_plugins.json");
+    const packageRoot = resolve(dirname4(fileURLToPath(import.meta.url)), "..");
+    const skillSource = join5(packageRoot, "driftx-plugin");
+    if (!existsSync6(skillSource)) {
+      console.error(`driftx-plugin directory not found at ${skillSource}`);
+      process.exitCode = 1;
+      return;
+    }
+    mkdirSync4(pluginsDir, { recursive: true });
+    if (existsSync6(driftxPluginDir)) {
+      try {
+        unlinkSync3(driftxPluginDir);
+      } catch {
+        console.error(`Could not remove existing ${driftxPluginDir}. Remove it manually and retry.`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+    symlinkSync(skillSource, driftxPluginDir);
+    let registry = { version: 2, plugins: {} };
+    try {
+      registry = JSON.parse(readFileSync8(registryPath, "utf-8"));
+    } catch {
+    }
+    registry.plugins["driftx@local"] = [{
+      scope: "user",
+      installPath: driftxPluginDir,
+      version: pkg.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }];
+    writeFileSync4(registryPath, JSON.stringify(registry, null, 2));
+    console.log("driftx registered as Claude Code plugin.");
+    console.log(`  Symlink: ${driftxPluginDir} -> ${skillSource}`);
+    console.log(`  Registry: ${registryPath}`);
+    console.log("\nRestart Claude Code to pick up the driftx skill.");
+  });
+  return program;
+}
+function run(argv) {
+  const program = createProgram();
+  program.parseAsync(argv);
+}
+
+// src/bin.ts
+run(process.argv);
+//# sourceMappingURL=bin.js.map