@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/chunk-AVECSGEH.js

@@ -0,0 +1,1462 @@
+import {
+  hasBugCandidate
+} from "./chunk-UAHWEUDI.js";
+import {
+  decideRequest,
+  defaultAllowlistFile,
+  isMutatingMethod,
+  parseAllowlist,
+  readMethods
+} from "./chunk-Q6CXF3NJ.js";
+import {
+  checkButtons,
+  fillScript,
+  hasForbiddenWord,
+  linkClickScript,
+  listActionsScript,
+  stepLabels,
+  stepTarget,
+  summarizeButtons
+} from "./chunk-SWW42KTA.js";
+import {
+  installAndLaunch,
+  installSourceOf
+} from "./chunk-JZDYF3HL.js";
+import {
+  execFileText
+} from "./chunk-AXQNUPGC.js";
+import {
+  isLoginPath,
+  sleep,
+  waitForScreen
+} from "./chunk-NLX3V7ZJ.js";
+import {
+  appIdFor
+} from "./chunk-NJNTEWXE.js";
+
+// packages/engine/src/explore/run.ts
+import path6 from "path";
+
+// packages/core/src/device/types.ts
+var deviceConcurrency = 2;
+
+// packages/core/src/explore/guard.ts
+var allRequests = "**/*";
+var blockedErrorCode = "blockedbyclient";
+function originOf(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function isExternal(url, webOrigin, apiOrigin) {
+  const target = originOf(url);
+  if (target === null || target === "null") return true;
+  const internal = [originOf(webOrigin), originOf(apiOrigin)].filter((origin) => origin !== null);
+  return !internal.includes(target);
+}
+function guardPath(url, webOrigin, apiOrigin) {
+  const parsed = new URL(url);
+  if (isExternal(url, webOrigin, apiOrigin)) return `${parsed.origin}${parsed.pathname}`;
+  return parsed.pathname;
+}
+function guardTargetOf(app, webOrigin) {
+  return { webOrigin, apiOrigin: app.apiOrigin || void 0, forbiddenApiPatterns: app.guard.forbiddenApiPatterns, pushTokenRequests: app.guard.pushTokenRequests };
+}
+function decide(route, target, allowlist) {
+  const request = route.request();
+  const method = request.method().toUpperCase();
+  try {
+    const path8 = guardPath(request.url(), target.webOrigin, target.apiOrigin);
+    const decision = decideRequest(method, path8, allowlist, target);
+    return decision.allow ? null : { method, path: path8, reason: decision.reason, at: Date.now() };
+  } catch {
+    if (readMethods.includes(method)) return null;
+    return { method, path: request.url(), reason: "unknown", at: Date.now() };
+  }
+}
+async function guardAndroidPage(page, target, allowlist, onBlocked) {
+  const handler = async (route) => {
+    const blocked = decide(route, target, allowlist);
+    if (!blocked) {
+      await route.continue();
+      return;
+    }
+    await route.abort(blockedErrorCode);
+    onBlocked(blocked);
+  };
+  await page.route(allRequests, handler);
+  return () => page.unroute(allRequests, handler);
+}
+
+// packages/core/src/logs/network.ts
+function formatNetworkLog(method, status, url, reason = "") {
+  return [method.toUpperCase(), String(status), url, reason].filter(Boolean).join(" ").trim();
+}
+var networkLogLine = /^([A-Za-z]+) (\d{1,3}) (\S+)(?: .*)?$/;
+function parseNetworkLog(text) {
+  const match = networkLogLine.exec(text.trim());
+  if (!match) return null;
+  return { method: match[1].toUpperCase(), status: Number(match[2]), url: match[3] };
+}
+
+// packages/core/src/explore/probe.ts
+var maxOffscreen = 20;
+var layoutSnapshotScript = `(() => {
+  const vw = document.documentElement.clientWidth;
+  const vh = window.innerHeight;
+  const root = document.documentElement;
+  const body = document.body;
+  const isVisible = (el, rect) => {
+    if (rect.width <= 0 || rect.height <= 0) return false;
+    const style = getComputedStyle(el);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+  };
+  const isClipped = (el) => {
+    for (let node = el.parentElement; node && node !== body && node !== root; node = node.parentElement) {
+      if (getComputedStyle(node).overflowX !== "visible") return true;
+    }
+    return false;
+  };
+  const labelOf = (el) => {
+    const name = el.getAttribute("aria-label") || (el.innerText || "").trim().slice(0, 40);
+    const id = el.id ? "#" + el.id : "";
+    return el.tagName.toLowerCase() + id + (name ? " " + JSON.stringify(name) : "");
+  };
+  const probe = document.createElement("div");
+  probe.style.cssText = "position:fixed;left:0;bottom:0;width:0;height:0;visibility:hidden;padding-bottom:env(safe-area-inset-bottom);";
+  body.appendChild(probe);
+  const safeAreaBottom = parseFloat(getComputedStyle(probe).paddingBottom) || 0;
+  probe.remove();
+  const offscreen = [];
+  const bottomFixed = [];
+  for (const el of Array.from(body.querySelectorAll("*"))) {
+    const rect = el.getBoundingClientRect();
+    if (!isVisible(el, rect)) continue;
+    if (offscreen.length < ${maxOffscreen} && (rect.right > vw + 1 || rect.left < -1) && !isClipped(el)) {
+      offscreen.push({ label: labelOf(el), left: rect.left, right: rect.right });
+    }
+    const position = getComputedStyle(el).position;
+    if ((position === "fixed" || position === "sticky") && rect.top > vh / 2) {
+      bottomFixed.push({ label: labelOf(el), bottom: rect.bottom });
+    }
+  }
+  return {
+    viewportWidth: vw,
+    viewportHeight: vh,
+    scrollWidth: root.scrollWidth,
+    bodyTextLength: (body.innerText || "").trim().length,
+    imageCount: body.querySelectorAll("img, svg, canvas, video, picture").length,
+    offscreen,
+    bottomFixed,
+    safeAreaBottom,
+  };
+})()`;
+function layoutIssues(snapshot) {
+  const issues = [];
+  if (snapshot.scrollWidth > snapshot.viewportWidth) {
+    issues.push({ kind: "overflow", message: `\uAC00\uB85C \uB118\uCE68: scrollWidth ${snapshot.scrollWidth} > ${snapshot.viewportWidth}` });
+  }
+  for (const item of snapshot.offscreen.slice(0, maxOffscreen)) {
+    issues.push({ kind: "offscreen", message: `\uD654\uBA74 \uBC16 \uC694\uC18C ${item.label} (left ${item.left}, right ${item.right})` });
+  }
+  if (snapshot.bodyTextLength === 0 && snapshot.imageCount === 0) {
+    issues.push({ kind: "blank", message: "\uBE48 \uD654\uBA74: \uAE00\uC790\uC640 \uC774\uBBF8\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4." });
+  }
+  const limit = snapshot.viewportHeight - snapshot.safeAreaBottom;
+  for (const item of snapshot.bottomFixed) {
+    if (item.bottom > limit) {
+      issues.push({ kind: "bottom-covered", message: `\uD558\uB2E8 \uAC00\uB9BC ${item.label} (bottom ${item.bottom} > ${limit})` });
+    }
+  }
+  return issues;
+}
+var alwaysBadStatuses = [401, 403, 404, 405];
+var writeValidationStatuses = [400, 409, 422];
+var serverErrorMin = 500;
+function includesStatus(list, status) {
+  return list.includes(status);
+}
+function networkIssue(entry) {
+  const message = `${entry.method.toUpperCase()} ${entry.status} ${entry.url}`;
+  if (entry.status >= serverErrorMin || includesStatus(alwaysBadStatuses, entry.status)) return { kind: "network", message };
+  if (!includesStatus(writeValidationStatuses, entry.status)) return null;
+  return entry.allowedWrite ? null : { kind: "network", message };
+}
+function pathnameOf(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function isAllowedWrite(method, url, allowlist, rules) {
+  if (!allowlist || !isMutatingMethod(method)) return false;
+  return decideRequest(method, pathnameOf(url), allowlist, rules).allow;
+}
+function logIssue(entry, allowlist, rules) {
+  if (entry.source === "console") return { kind: "console", message: entry.text };
+  if (entry.source === "crash") return { kind: "crash", message: entry.text };
+  if (entry.source !== "network") return null;
+  const parsed = parseNetworkLog(entry.text);
+  if (!parsed) return null;
+  return networkIssue({ ...parsed, allowedWrite: isAllowedWrite(parsed.method, parsed.url, allowlist, rules) });
+}
+async function pageIssues(driver) {
+  const issues = [];
+  const path8 = await driver.currentPath();
+  const { loginPaths, appErrorText } = driver.app;
+  if (isLoginPath(path8, loginPaths)) issues.push({ kind: "login-redirect", message: `\uB85C\uADF8\uC778 \uD654\uBA74\uC73C\uB85C \uC774\uB3D9: ${path8}` });
+  if (await driver.hasText(appErrorText)) issues.push({ kind: "app-error", message: appErrorText });
+  const snapshot = await driver.evaluate(layoutSnapshotScript);
+  return [...issues, ...layoutIssues(snapshot)];
+}
+async function probeScreen(driver, ring, since, allowlist) {
+  const screen = await pageIssues(driver);
+  const logs = ring.since(since).map((entry) => logIssue(entry, allowlist, driver.app.guard));
+  return [...screen, ...logs.filter((issue) => issue !== null)];
+}
+
+// packages/core/src/logs/redact.ts
+var patterns = [
+  /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi,
+  /010[-.\s]?\d{3,4}[-.\s]?\d{4}/g,
+  /Bearer\s+\S+/gi,
+  /token=[^&\s]+/gi,
+  /cookie\s*[:=]\s*\S+/gi
+];
+function redactText(value) {
+  return patterns.reduce((text, pattern) => text.replace(pattern, "\uAC00\uB9BC"), value);
+}
+
+// packages/core/src/logs/ring.ts
+var logWindowMs = 3e4;
+var LogRing = class {
+  constructor(windowMs = logWindowMs, now = Date.now) {
+    this.windowMs = windowMs;
+    this.now = now;
+  }
+  windowMs;
+  now;
+  entries = [];
+  push(entry) {
+    const at = this.now();
+    this.entries.push({ ...entry, at, text: redactText(entry.text) });
+    this.entries = this.entries.filter((item) => item.at >= at - this.windowMs);
+  }
+  around(at) {
+    return this.entries.filter((item) => item.at >= at - this.windowMs && item.at <= at + this.windowMs);
+  }
+  since(at) {
+    return this.entries.filter((item) => item.at >= at);
+  }
+};
+var FrameRing = class {
+  constructor(windowMs = logWindowMs) {
+    this.windowMs = windowMs;
+  }
+  windowMs;
+  items = [];
+  push(frame, at, key = true) {
+    this.items.push({ at, frame, key });
+    const kept = this.items.filter((item) => item.at >= at - this.windowMs);
+    const firstKey = kept.findIndex((item) => item.key);
+    this.items = firstKey < 0 ? [] : kept.slice(firstKey);
+  }
+  frames() {
+    return [...this.items];
+  }
+  clear() {
+    this.items = [];
+  }
+};
+
+// packages/engine/src/results.ts
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+var devicesRoot = path.resolve("test-results/devices");
+var retentionDays = 30;
+var restartMessage = "\uC11C\uBC84 \uC7AC\uC2DC\uC791\uC73C\uB85C \uC911\uB2E8\uB428";
+var dayMs = 24 * 60 * 6e4;
+var runFile = "run.json";
+var fallbackFps = 10;
+function runPath(root, runId) {
+  return path.join(root, runId, runFile);
+}
+function writeRun(run, root = devicesRoot) {
+  const file = runPath(root, run.runId);
+  mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.part`;
+  writeFileSync(temp, JSON.stringify(run, null, 2));
+  renameSync(temp, file);
+}
+function isDeviceRun(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const run = value;
+  return typeof run.runId === "string" && typeof run.startedAt === "string" && Array.isArray(run.outcomes);
+}
+function readRun(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return isDeviceRun(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function runDirs(root) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name));
+}
+function readRuns(root) {
+  return runDirs(root).flatMap((dir) => readRun(path.join(dir, runFile)) ?? []);
+}
+function readLatestRun(root = devicesRoot) {
+  const runs = readRuns(root).sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+  return runs.at(-1) ?? null;
+}
+function closeUnfinishedRun(root = devicesRoot, now = Date.now) {
+  const unfinished = readRuns(root).filter((run) => run.finishedAt === null);
+  for (const run of unfinished) {
+    for (const outcome of run.outcomes) {
+      if (outcome.status !== "running") continue;
+      outcome.status = "skipped";
+      outcome.message = restartMessage;
+    }
+    run.finishedAt = new Date(now()).toISOString();
+    writeRun(run, root);
+  }
+  return unfinished.length > 0;
+}
+function isJpeg(frame) {
+  return frame[0] === 255 && frame[1] === 216;
+}
+function framesPerSecond(frames) {
+  const first = frames[0]?.at ?? 0;
+  const last = frames.at(-1)?.at ?? 0;
+  const seconds = (last - first) / 1e3;
+  return seconds > 0 ? Math.max(1, Math.round(frames.length / seconds)) : fallbackFps;
+}
+function ffmpegEncodeVideo(exec = execFileText) {
+  return async (frames, outFile) => {
+    const dir = mkdtempSync(path.join(tmpdir(), "bundle-video-"));
+    const format = isJpeg(frames[0].frame) ? "mjpeg" : "h264";
+    const input = path.join(dir, `frames.${format}`);
+    try {
+      writeFileSync(input, Buffer.concat(frames.map((item) => item.frame)));
+      const fps = String(framesPerSecond(frames));
+      await exec("ffmpeg", ["-y", "-loglevel", "error", "-f", format, "-framerate", fps, "-i", input, "-c:v", "libx264", "-pix_fmt", "yuv420p", outFile]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  };
+}
+var defaultBundleDeps = { encodeVideo: ffmpegEncodeVideo() };
+async function writeFailureBundle(dir, input, deps = defaultBundleDeps) {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "logs.jsonl"), input.logs.map((entry) => JSON.stringify(entry)).join("\n") + (input.logs.length > 0 ? "\n" : ""));
+  writeFileSync(path.join(dir, "screenshot.png"), input.screenshot);
+  if (input.baseline) {
+    writeFileSync(path.join(dir, "baseline.png"), input.baseline.baseline);
+    writeFileSync(path.join(dir, "diff.png"), input.baseline.diff);
+  }
+  if (input.frames.length > 0) await deps.encodeVideo(input.frames, path.join(dir, "video.mp4"));
+}
+function runStartedAt(dir) {
+  const run = readRun(path.join(dir, runFile));
+  const started = run ? Date.parse(run.startedAt) : Number.NaN;
+  return Number.isNaN(started) ? statSync(dir).mtimeMs : started;
+}
+function pruneRuns(root, now, days = retentionDays) {
+  const cutoff = now - days * dayMs;
+  const expired = runDirs(root).filter((dir) => runStartedAt(dir) < cutoff);
+  for (const dir of expired) rmSync(dir, { recursive: true, force: true });
+  return expired.length;
+}
+
+// packages/engine/src/run.ts
+import { randomBytes } from "crypto";
+import path4 from "path";
+
+// packages/core/src/flows/run.ts
+var flowStepWaitMs = 1e4;
+var clickSettleMs = 2e3;
+async function runStep(driver, step, waitMs, waitForScreen2) {
+  if (step.type === "home") {
+    if (!driver.goHome) throw new Error("\uC774 \uB4DC\uB77C\uC774\uBC84\uB294 \uD648 \uD0ED\uC73C\uB85C \uAC08 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    await driver.goHome();
+    const ready = await waitForScreen2(driver, driver.app.homePath);
+    if (!ready.ok) throw new Error(ready.message);
+    return;
+  }
+  if (step.type === "click") {
+    await driver.currentPath().then((path8) => waitForScreen2(driver, path8)).catch(() => void 0);
+    await driver.clickButton(step.target.name, step.target.role, step.target.match);
+    await sleep(clickSettleMs);
+    return;
+  }
+  return driver.expectText(step.text, waitMs);
+}
+function withHome(flow) {
+  return [{ type: "home" }, ...flow.steps];
+}
+async function runFlow(driver, flow, options = {}) {
+  const { now = Date.now, waitMs = flowStepWaitMs, waitForScreen: waitForScreen2 = (target, path8) => waitForScreen(target, path8), onStep } = options;
+  const steps = [];
+  for (const [index, step] of withHome(flow).entries()) {
+    onStep?.(index);
+    const started = now();
+    const base = { index, type: step.type, target: stepTarget(step, driver.app.homeTabName) };
+    try {
+      await runStep(driver, step, waitMs, waitForScreen2);
+      steps.push({ ...base, status: "passed", durationMs: now() - started });
+    } catch (error) {
+      steps.push({ ...base, status: "failed", durationMs: now() - started });
+      const reason = error instanceof Error ? error.message.split("\n")[0] : String(error);
+      return { status: "failed", steps, message: `${index + 1}\uB2E8\uACC4 ${stepLabels[step.type]} \u300C${base.target}\u300D \uC2E4\uD328: ${reason}` };
+    }
+  }
+  return { status: "passed", steps };
+}
+
+// packages/engine/src/check.ts
+import path3 from "path";
+import { PNG as PNG2 } from "pngjs";
+
+// packages/engine/src/baseline/store.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import path2 from "path";
+import { PNG } from "pngjs";
+
+// packages/core/src/baseline/diff.ts
+var channelTolerance = 16;
+var failRatio = 0.02;
+var diffMessage = "\uAE30\uC900 \uD654\uBA74\uACFC \uB2E4\uB985\uB2C8\uB2E4.";
+var sizeMessage = "\uAE30\uC900 \uD654\uBA74\uACFC \uD06C\uAE30\uAC00 \uB2E4\uB985\uB2C8\uB2E4.";
+function channelsDiffer(left, right, offset) {
+  const red = Math.abs(left[offset] - right[offset]);
+  const green = Math.abs(left[offset + 1] - right[offset + 1]);
+  const blue = Math.abs(left[offset + 2] - right[offset + 2]);
+  return Math.max(red, green, blue) > channelTolerance;
+}
+function buildMask(images) {
+  const first = images[0];
+  if (!first) return new Uint8Array();
+  const usable = images.filter((image) => image.width === first.width && image.height === first.height);
+  const count = first.width * first.height;
+  const mask = new Uint8Array(count);
+  mask.fill(255);
+  if (usable.length < 2) return mask;
+  for (let index = 0; index < count; index += 1) {
+    const offset = index * 4;
+    for (let left = 0; left < usable.length; left += 1) {
+      let differed = false;
+      for (let right = left + 1; right < usable.length; right += 1) {
+        if (!channelsDiffer(usable[left].data, usable[right].data, offset)) continue;
+        mask[index] = 0;
+        differed = true;
+        break;
+      }
+      if (differed) break;
+    }
+  }
+  return mask;
+}
+function compareImages(current, baseline, mask) {
+  if (current.width !== baseline.width || current.height !== baseline.height) {
+    return { pass: false, message: sizeMessage };
+  }
+  const count = current.width * current.height;
+  const useMask = mask != null && mask.length === count;
+  let compared = 0;
+  let changed = 0;
+  for (let index = 0; index < count; index += 1) {
+    if (useMask && mask[index] === 0) continue;
+    compared += 1;
+    if (channelsDiffer(current.data, baseline.data, index * 4)) changed += 1;
+  }
+  const ratio = compared === 0 ? 0 : changed / compared;
+  if (ratio > failRatio) return { pass: false, message: diffMessage };
+  return { pass: true, ratio };
+}
+
+// packages/engine/src/baseline/store.ts
+var baselinesRoot = path2.resolve("test-results/baselines");
+var archiveLimit = 5;
+function scenarioDir(root, name) {
+  const id = createHash("sha256").update(name, "utf8").digest("hex").slice(0, 16);
+  return path2.join(root, id);
+}
+function pendingPath(root) {
+  return path2.join(root, "pending.json");
+}
+function readPng(file) {
+  const png = PNG.sync.read(readFileSync2(file));
+  return { width: png.width, height: png.height, data: png.data };
+}
+function writeGrayMask(file, width, height, mask) {
+  const png = new PNG({ width, height, colorType: 0 });
+  for (let index = 0; index < mask.length; index += 1) {
+    const value = mask[index] === 0 ? 0 : 255;
+    const offset = index * 4;
+    png.data[offset] = value;
+    png.data[offset + 1] = value;
+    png.data[offset + 2] = value;
+    png.data[offset + 3] = 255;
+  }
+  writeFileSync2(file, PNG.sync.write(png));
+}
+function readMask(file, width, height) {
+  if (!existsSync2(file)) return null;
+  const png = PNG.sync.read(readFileSync2(file));
+  if (png.width !== width || png.height !== height) return null;
+  const mask = new Uint8Array(width * height);
+  for (let index = 0; index < mask.length; index += 1) {
+    mask[index] = png.data[index * 4] === 0 ? 0 : 255;
+  }
+  return mask;
+}
+function archiveFiles(dir) {
+  if (!existsSync2(dir)) return [];
+  return readdirSync2(dir).flatMap((name) => {
+    const match = /^(\d+)\.png$/.exec(name);
+    if (!match) return [];
+    return [{ index: Number(match[1]), file: path2.join(dir, name) }];
+  }).sort((left, right) => left.index - right.index);
+}
+function readPending(root = baselinesRoot) {
+  try {
+    const parsed = JSON.parse(readFileSync2(pendingPath(root), "utf8"));
+    if (!Array.isArray(parsed.names)) return [];
+    return parsed.names.filter((name) => typeof name === "string");
+  } catch {
+    return [];
+  }
+}
+function writePending(root, names) {
+  mkdirSync2(root, { recursive: true });
+  writeFileSync2(pendingPath(root), JSON.stringify({ names }, null, 2));
+}
+function addPending(root, name) {
+  const names = readPending(root);
+  if (!names.includes(name)) names.push(name);
+  writePending(root, names);
+}
+function hasBaseline(name, root = baselinesRoot) {
+  return existsSync2(path2.join(scenarioDir(root, name), "baseline.png"));
+}
+function saveCandidate(name, png, root = baselinesRoot) {
+  const dir = scenarioDir(root, name);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(path2.join(dir, "candidate.png"), png);
+  addPending(root, name);
+}
+function compareToBaseline(name, png, root = baselinesRoot) {
+  const dir = scenarioDir(root, name);
+  const current = PNG.sync.read(png);
+  const baseline = readPng(path2.join(dir, "baseline.png"));
+  const mask = readMask(path2.join(dir, "mask.png"), baseline.width, baseline.height);
+  return compareImages({ width: current.width, height: current.height, data: current.data }, baseline, mask);
+}
+function rebuildMask(dir) {
+  const files = archiveFiles(path2.join(dir, "archive"));
+  const baseline = readPng(path2.join(dir, "baseline.png"));
+  const images = files.map((file) => readPng(file.file)).filter((image) => image.width === baseline.width && image.height === baseline.height);
+  const mask = buildMask(images.length > 0 ? images : [baseline]);
+  writeGrayMask(path2.join(dir, "mask.png"), baseline.width, baseline.height, mask);
+}
+function confirmScenario(name, root = baselinesRoot) {
+  if (!readPending(root).includes(name)) return false;
+  const dir = scenarioDir(root, name);
+  const candidate = path2.join(dir, "candidate.png");
+  if (!existsSync2(candidate)) return false;
+  const archive = path2.join(dir, "archive");
+  mkdirSync2(archive, { recursive: true });
+  const existing = archiveFiles(archive);
+  const next = (existing.at(-1)?.index ?? 0) + 1;
+  const archived = path2.join(archive, `${String(next).padStart(4, "0")}.png`);
+  writeFileSync2(archived, readFileSync2(candidate));
+  const files = archiveFiles(archive);
+  while (files.length > archiveLimit) {
+    const oldest = files.shift();
+    if (oldest) unlinkSync(oldest.file);
+  }
+  writeFileSync2(path2.join(dir, "baseline.png"), readFileSync2(archived));
+  rebuildMask(dir);
+  unlinkSync(candidate);
+  writePending(
+    root,
+    readPending(root).filter((item) => item !== name)
+  );
+  return true;
+}
+function confirmPending(root = baselinesRoot) {
+  const names = readPending(root);
+  let confirmed = 0;
+  for (const name of names) {
+    if (confirmScenario(name, root)) confirmed += 1;
+  }
+  return confirmed;
+}
+
+// packages/engine/src/check.ts
+var deviceBaselinesRoot = path3.resolve("test-results/device-baselines");
+var statusBarFallbackRatio = 0.08;
+var statusBarHeights = {
+  "SM-A325N": 80,
+  // 갤럭시 A32, Android 13, 1080x2400 (2026-10-26 실측)
+  "iPhone 16": 177
+  // 안전 영역 위 59pt × 3배. 캡처 1178x2556 (2026-10-26 확인)
+};
+function baselineKey(device, scenario) {
+  return `${device.model}|${device.osVersion}|${scenario}`;
+}
+function statusBarIgnore(device, width, height) {
+  const barHeight = statusBarHeights[device.model] ?? Math.round(height * statusBarFallbackRatio);
+  return { x: 0, y: 0, width, height: Math.min(barHeight, height) };
+}
+function blankStatusBar(png, device) {
+  const image = PNG2.sync.read(png);
+  const box = statusBarIgnore(device, image.width, image.height);
+  const end = box.height * image.width * 4;
+  for (let offset = 0; offset < end; offset += 4) {
+    image.data[offset] = 0;
+    image.data[offset + 1] = 0;
+    image.data[offset + 2] = 0;
+    image.data[offset + 3] = 255;
+  }
+  return PNG2.sync.write(image);
+}
+async function checkScreen(driver, device, scenario, baselineRoot = deviceBaselinesRoot, waitFor = (target, path8) => waitForScreen(target, path8)) {
+  await driver.navigate(scenario.path);
+  const ready = await waitFor(driver, scenario.path);
+  if (!ready.ok) return { status: "failed", message: ready.message };
+  const note = ready.redirectedTo ? `${ready.redirectedTo}\uB85C \uC774\uB3D9\uB428` : void 0;
+  const { appErrorText, loginPaths } = driver.app;
+  if (await driver.hasText(appErrorText)) {
+    return { status: "failed", message: `${scenario.path} \uC5D0\uC11C \uC571 \uC624\uB958\uAC00 \uB0AC\uC2B5\uB2C8\uB2E4.` };
+  }
+  if (isLoginPath(await driver.currentPath(), loginPaths)) return { status: "login_required" };
+  const screenshot = blankStatusBar(await driver.screenshot(), device);
+  const key = baselineKey(device, scenario.name);
+  if (!hasBaseline(key, baselineRoot)) {
+    saveCandidate(key, screenshot, baselineRoot);
+    return { status: "candidate", message: note, screenshot };
+  }
+  const result = compareToBaseline(key, screenshot, baselineRoot);
+  if (result.pass) return { status: "passed", message: note, screenshot };
+  return { status: "failed", message: result.message, screenshot };
+}
+function pendingDeviceBaselines(root = deviceBaselinesRoot) {
+  return readPending(root);
+}
+function confirmDeviceBaselines(names, root = deviceBaselinesRoot) {
+  if (!names) return confirmPending(root);
+  return names.filter((name) => confirmScenario(name, root)).length;
+}
+
+// packages/engine/src/run.ts
+var humanControlMessage = "\uC9C1\uC811 \uC870\uC791 \uC911\uC774\uB77C \uAC74\uB108\uB700";
+var stoppedMessage = "\uC810\uAC80\uC744 \uBA48\uCDC4\uC2B5\uB2C8\uB2E4.";
+var testResultsRoot = path4.resolve("test-results");
+var offlinePattern = /device not found|disconnected|offline/i;
+var installedVersionLabel = "\uC124\uCE58\uB41C \uC571";
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isOffline(error) {
+  return offlinePattern.test(errorMessage(error));
+}
+function createRunId(now) {
+  const stamp = new Date(now).toISOString().replace(/[-:.]/g, "").replace("Z", "");
+  return `${stamp}-${randomBytes(2).toString("hex")}`;
+}
+function settle(job, status, message) {
+  delete job.outcome.phase;
+  delete job.outcome.current;
+  delete job.outcome.flowSteps;
+  job.outcome.status = status;
+  if (message === void 0) delete job.outcome.message;
+  else job.outcome.message = message;
+  job.deps.onUpdate(job.run);
+}
+function isStopped(job) {
+  return job.deps.signal?.aborted === true;
+}
+function stoppedOutcome(outcome) {
+  return outcome.screens.some((screen) => screen.status === "failed") ? "failed" : "skipped";
+}
+function screensOutcome(outcome) {
+  if (outcome.screens.some((screen) => screen.status === "failed")) return "failed";
+  if (outcome.screens.some((screen) => screen.status === "login_required")) return "login_required";
+  return "passed";
+}
+function pathSegment(name) {
+  return name.replace(/[\\/]/g, "_").replace(/^\.+/, "_");
+}
+function logOf(deps) {
+  return deps.log ?? ((message) => console.warn(`[run] ${message}`));
+}
+async function failureScreenshot(job, driver, result) {
+  if (result.screenshot) return result.screenshot;
+  try {
+    return await driver.screenshot();
+  } catch (error) {
+    logOf(job.deps)(`${job.device.id} \uC2E4\uD328 \uD654\uBA74 \uC2A4\uD06C\uB9B0\uC0F7\uC744 \uBABB \uCC0D\uC5C8\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+    return null;
+  }
+}
+function baselineImages(job, scenario, screenshot) {
+  try {
+    return job.deps.baselineFor?.(job.device, scenario, screenshot);
+  } catch (error) {
+    logOf(job.deps)(`${scenario.name} \uAE30\uC900\xB7\uCC28\uC774 \uC774\uBBF8\uC9C0\uB97C \uBABB \uB9CC\uB4E4\uC5C8\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+    return void 0;
+  }
+}
+async function bundleFailure(job, driver, capture, name, result, scenario) {
+  const screenshot = await failureScreenshot(job, driver, result);
+  if (!screenshot) return {};
+  const root = job.deps.resultsRoot ?? testResultsRoot;
+  const dir = path4.join(root, "devices", job.run.runId, pathSegment(job.device.id), pathSegment(name));
+  const relative = path4.relative(root, dir).split(path4.sep).join("/");
+  const input = {
+    logs: capture.ring.around((job.deps.now ?? Date.now)()),
+    frames: capture.frames(),
+    screenshot,
+    // checkScreen이 스크린샷을 돌려준 실패 = 기준 비교 실패. 앱 오류·예외는 기준·차이를 붙이지 않는다.
+    baseline: result.screenshot && scenario ? baselineImages(job, scenario, screenshot) : void 0
+  };
+  try {
+    await (job.deps.writeBundle ?? writeFailureBundle)(dir, input);
+  } catch (error) {
+    logOf(job.deps)(`${relative} \uC2E4\uD328 \uBB36\uC74C \uC77C\uBD80\uB97C \uBABB \uC37C\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+  }
+  return { screenshot: `${relative}/screenshot.png`, logDir: relative };
+}
+async function checkOne(job, driver, scenario) {
+  const check = job.deps.checkScreen ?? checkScreen;
+  try {
+    return await check(driver, job.device, scenario);
+  } catch (error) {
+    if (isOffline(error)) throw error;
+    return { status: "failed", message: errorMessage(error) };
+  }
+}
+async function pressButtons(job, driver, capture, scenario, result) {
+  const setup = job.deps.buttonCheck;
+  if (!job.request.buttonCheck || !setup || result.status !== "passed" && result.status !== "candidate") return { result };
+  job.outcome.current = `${scenario.name} \xB7 \uBC84\uD2BC \uB20C\uB7EC\uBCF4\uAE30`;
+  job.deps.onUpdate(job.run);
+  const ring = capture?.ring ?? new LogRing();
+  const buttons = await (setup.checkButtons ?? checkButtons)(driver, {
+    probe: (since) => setup.probe(driver, ring, since),
+    screenPath: scenario.path,
+    restore: async () => {
+      await driver.goHome?.();
+      await driver.navigate(scenario.path);
+      await waitForScreen(driver, scenario.path);
+    }
+  });
+  try {
+    setup.recordMap?.(scenario.path, buttons);
+  } catch (error) {
+    logOf(job.deps)(`\uD654\uBA74 \uC9C0\uB3C4 \uAE30\uB85D \uC2E4\uD328: ${errorMessage(error)}`);
+  }
+  const summary = summarizeButtons(buttons);
+  const message = result.message ? `${result.message} \xB7 ${summary}` : summary;
+  if (buttons.some((button) => button.status === "error")) return { result: { status: "failed", message }, buttons };
+  return { result: { ...result, message }, buttons };
+}
+async function runScenarios(job, driver, capture) {
+  for (const scenario of job.request.flowsOnly ? [] : job.deps.scenarios) {
+    if (isStopped(job)) return;
+    job.outcome.phase = "checking";
+    job.outcome.current = scenario.name;
+    job.deps.onUpdate(job.run);
+    const { result, buttons } = await pressButtons(job, driver, capture, scenario, await checkOne(job, driver, scenario));
+    const bundle = result.status === "failed" && capture ? await bundleFailure(job, driver, capture, scenario.name, result, scenario) : {};
+    job.outcome.screens.push({ scenario: scenario.name, status: result.status, message: result.message, buttons, ...bundle });
+    job.deps.onUpdate(job.run);
+    if (result.status === "login_required") return;
+  }
+  await runFlows(job, driver, capture);
+  await runQaScreens(job, driver, capture);
+  await runPolicyScreens(job, driver, capture);
+}
+var flowScenarioPrefix = "\uD50C\uB85C\uC6B0 \xB7 ";
+var qaScenarioPrefix = "\uB370\uC774\uD130 \xB7 ";
+var policyScenarioPrefix = "\uC815\uCC45 \xB7 ";
+var qaScreensOf = (deps) => deps.runQa ? deps.qaScreens ?? [] : [];
+async function qaOne(runQa, driver, screen) {
+  try {
+    return await runQa(driver, screen);
+  } catch (error) {
+    if (isOffline(error)) throw error;
+    return { path: screen.path, name: screen.name, apis: [], checks: [{ id: "run", title: "\uB370\uC774\uD130 QA \uC2E4\uD589", ok: false, message: errorMessage(error) }] };
+  }
+}
+async function runQaScreens(job, driver, capture) {
+  const { runQa } = job.deps;
+  if (!runQa) return;
+  for (const screen of qaScreensOf(job.deps)) {
+    if (isStopped(job)) return;
+    const name = `${qaScenarioPrefix}${screen.name}`;
+    job.outcome.phase = "checking";
+    job.outcome.current = name;
+    job.deps.onUpdate(job.run);
+    const report = await qaOne(runQa, driver, screen);
+    const failed = report.checks.filter((check) => !check.ok);
+    const message = failed.length > 0 ? `${failed.length}\uAC1C \uC2E4\uD328 \xB7 ${failed[0].title}: ${failed[0].message ?? ""}` : void 0;
+    const status = failed.length > 0 ? "failed" : "passed";
+    const bundle = status === "failed" && capture ? await bundleFailure(job, driver, capture, name, { status: "failed", message }) : {};
+    job.outcome.screens.push({ scenario: name, status, message, checks: report.checks, ...bundle });
+    job.deps.onUpdate(job.run);
+  }
+}
+function policyMessage(report) {
+  const open = report.checks.filter((check) => !check.ok && !check.ignored && check.finding);
+  const notes = [
+    open.length > 0 ? `\uC5B4\uAE0B\uB0A8 ${open.length}\uAC1C \xB7 ${open[0].title}: ${open[0].message ?? ""}` : null,
+    report.situational > 0 ? `\uC0C1\uD669 \uD544\uC694 \uADDC\uCE59 ${report.situational}\uAC1C\uB294 \uD655\uC778 \uC548 \uD568` : null,
+    report.judgeError ?? null
+  ].filter(Boolean);
+  return notes.length > 0 ? notes.join(" \xB7 ") : void 0;
+}
+async function runPolicyScreens(job, driver, capture) {
+  const { runPolicy } = job.deps;
+  if (!runPolicy) return;
+  for (const screen of job.deps.policyScreens ?? []) {
+    if (isStopped(job)) return;
+    const name = `${policyScenarioPrefix}${screen.path}`;
+    job.outcome.phase = "checking";
+    job.outcome.current = name;
+    job.deps.onUpdate(job.run);
+    let report;
+    try {
+      report = await runPolicy(driver, screen);
+    } catch (error) {
+      if (isOffline(error)) throw error;
+      report = { path: screen.path, checks: [], situational: 0, cached: false, judgeError: errorMessage(error) };
+    }
+    const status = hasBugCandidate(report.checks) ? "failed" : "passed";
+    const message = policyMessage(report);
+    const bundle = status === "failed" && capture ? await bundleFailure(job, driver, capture, name, { status: "failed", message }) : {};
+    job.outcome.screens.push({ scenario: name, status, message, checks: report.checks, ...bundle });
+    job.deps.onUpdate(job.run);
+  }
+}
+function flowStepViews(flow, running) {
+  return withHome(flow).map((step, index) => ({
+    label: `${stepLabels[step.type]} \u300C${stepTarget(step)}\u300D`,
+    status: index < running ? "passed" : index === running ? "running" : "pending"
+  }));
+}
+async function flowOne(job, driver, flow) {
+  const onStep = (index) => {
+    job.outcome.flowSteps = flowStepViews(flow, index);
+    job.deps.onUpdate(job.run);
+  };
+  try {
+    return await (job.deps.runFlow ?? ((target, item, step) => runFlow(target, item, { onStep: step })))(driver, flow, onStep);
+  } catch (error) {
+    if (isOffline(error)) throw error;
+    return { status: "failed", steps: [], message: errorMessage(error) };
+  }
+}
+async function runFlows(job, driver, capture) {
+  for (const flow of job.deps.flows ?? []) {
+    if (isStopped(job)) return;
+    const name = `${flowScenarioPrefix}${flow.name}`;
+    job.outcome.phase = "checking";
+    job.outcome.current = name;
+    job.deps.onUpdate(job.run);
+    const result = await flowOne(job, driver, flow);
+    delete job.outcome.flowSteps;
+    const bundle = result.status === "failed" && capture ? await bundleFailure(job, driver, capture, name, { status: "failed" }) : {};
+    job.outcome.screens.push({ scenario: name, status: result.status, message: result.message, steps: result.steps, ...bundle });
+    job.deps.onUpdate(job.run);
+  }
+}
+function emptyCapture() {
+  return { ring: new LogRing(), frames: () => [], stop: async () => void 0 };
+}
+async function startCapture(job, driver, appId) {
+  if (!job.deps.capture) return null;
+  try {
+    return await job.deps.capture(job.device, driver, appId);
+  } catch (error) {
+    logOf(job.deps)(`${job.device.id} \uB85C\uADF8 \uC218\uC9D1\uC744 \uBABB \uB744\uC6E0\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+    return emptyCapture();
+  }
+}
+async function stopCapture(job, capture) {
+  try {
+    await capture?.stop();
+  } catch (error) {
+    logOf(job.deps)(`${job.device.id} \uB85C\uADF8 \uC218\uC9D1 \uC815\uC9C0 \uC2E4\uD328: ${errorMessage(error)}`);
+  }
+}
+var testflightUnsupportedMessage = "TestFlight \uC124\uCE58\uB97C \uAE30\uB2E4\uB9B4 \uBC29\uBC95\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+async function installBuild(job) {
+  const { device, request, deps } = job;
+  try {
+    if (installSourceOf(deps.app.install, device.platform, request.kind) === "testflight") {
+      if (!deps.waitForTestflight) return { ok: false, message: testflightUnsupportedMessage };
+      return await deps.waitForTestflight(device, request.kind, request.version);
+    }
+    const file = await deps.fetchBuild({ platform: device.platform, kind: request.kind, version: request.version });
+    return await (deps.installAndLaunch ?? installAndLaunch)(device, file, appIdFor(deps.app, request.kind, device.platform), deps.exec);
+  } catch (error) {
+    return { ok: false, message: errorMessage(error) };
+  }
+}
+function markPhase(job, phase) {
+  job.outcome.phase = phase;
+  delete job.outcome.current;
+  job.deps.onUpdate(job.run);
+}
+async function guardButtons(job, driver) {
+  if (!job.request.buttonCheck || !job.deps.buttonCheck) return null;
+  try {
+    return await job.deps.buttonCheck.guard(driver);
+  } catch (error) {
+    job.request = { ...job.request, buttonCheck: false };
+    job.outcome.message = `\uBC84\uD2BC \uB20C\uB7EC\uBCF4\uAE30\uB97C \uAC74\uB108\uB700: ${errorMessage(error)}`;
+    return null;
+  }
+}
+async function testDevice(job) {
+  if (isStopped(job)) {
+    settle(job, "skipped", stoppedMessage);
+    return;
+  }
+  if (!job.request.flowsOnly) {
+    const source = installSourceOf(job.deps.app.install, job.device.platform, job.request.kind);
+    markPhase(job, source === "testflight" ? "waiting_testflight" : "installing");
+    const installed = await installBuild(job);
+    if (!installed.ok) {
+      settle(job, "install_failed", installed.message);
+      return;
+    }
+    if (isStopped(job)) {
+      settle(job, "skipped", stoppedMessage);
+      return;
+    }
+  }
+  const appId = appIdFor(job.deps.app, job.request.kind, job.device.platform);
+  const driver = await job.deps.openDriver(job.device, appId);
+  const capture = await startCapture(job, driver, appId);
+  const unguard = await guardButtons(job, driver);
+  try {
+    await runScenarios(job, driver, capture);
+  } finally {
+    await unguard?.().catch((error) => logOf(job.deps)(`${job.device.id} \uBC84\uD2BC \uAC00\uB4DC \uD574\uC81C \uC2E4\uD328: ${errorMessage(error)}`));
+    await stopCapture(job, capture);
+    await driver.close().catch(() => void 0);
+  }
+  if (isStopped(job)) {
+    settle(job, stoppedOutcome(job.outcome), stoppedMessage);
+    return;
+  }
+  settle(job, screensOutcome(job.outcome), job.outcome.message);
+}
+async function runDevice(job) {
+  const owner = { kind: "bot", runId: job.run.runId };
+  if (!job.deps.locks.acquire(job.device.id, owner)) {
+    settle(job, "skipped", humanControlMessage);
+    return;
+  }
+  try {
+    await testDevice(job);
+  } catch (error) {
+    settle(job, isOffline(error) ? "offline" : "failed", errorMessage(error));
+  } finally {
+    job.deps.locks.release(job.device.id, owner);
+  }
+}
+async function eachLimited(items, limit, work) {
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const item = items[next];
+      next += 1;
+      await work(item);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+function pickDevices(devices, deviceIds) {
+  if (deviceIds === "all") return [...devices];
+  return devices.filter((device) => deviceIds.includes(device.id));
+}
+async function runDevices(request, deps) {
+  const now = deps.now ?? Date.now;
+  const startedAt = now();
+  const devices = pickDevices(await deps.listDevices(), request.deviceIds);
+  const run = {
+    runId: request.runId ?? createRunId(startedAt),
+    kind: request.kind,
+    version: request.version,
+    trigger: request.trigger ?? "manual",
+    scenarioCount: (request.flowsOnly ? 0 : deps.scenarios.length) + (deps.flows?.length ?? 0) + qaScreensOf(deps).length,
+    startedAt: new Date(startedAt).toISOString(),
+    finishedAt: null,
+    outcomes: devices.map((device) => ({ device, status: "running", screens: [] }))
+  };
+  deps.onUpdate(run);
+  const jobs = run.outcomes.map((outcome) => ({ device: outcome.device, outcome, request, run, deps }));
+  await eachLimited(jobs, deviceConcurrency, runDevice);
+  run.finishedAt = new Date(now()).toISOString();
+  deps.onUpdate(run);
+  return run;
+}
+
+// packages/engine/src/explore/crawler.ts
+import { createHash as createHash2 } from "crypto";
+import { setTimeout as wait } from "timers/promises";
+var exploreLimits = { maxDepth: 6, maxActionsPerScreen: 20, maxMinutes: 30 };
+var actionSettleMs = 500;
+var minuteMs = 6e4;
+var hashLength = 16;
+function toAction(candidate, formValues, forbiddenWords) {
+  if (candidate.role === "input") {
+    const value = formValues[candidate.name];
+    return value ? { kind: "fill", label: candidate.name, value } : null;
+  }
+  if (hasForbiddenWord(candidate.name, forbiddenWords)) return null;
+  return { kind: "click", role: candidate.role, name: candidate.name };
+}
+function actionSortKey(action) {
+  return action.kind === "fill" ? `${action.label}\0fill` : `${action.name}\0${action.role}`;
+}
+function compareActions(a, b) {
+  const left = actionSortKey(a);
+  const right = actionSortKey(b);
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function selectActions(candidates, formValues, forbiddenWords) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const action = toAction(candidate, formValues, forbiddenWords);
+    if (action) unique.set(actionSortKey(action), action);
+  }
+  return [...unique.values()].sort(compareActions).slice(0, exploreLimits.maxActionsPerScreen);
+}
+async function listActions(driver, formValues) {
+  const candidates = await driver.evaluate(listActionsScript);
+  return selectActions(candidates, formValues, driver.app.guard.forbiddenButtonWords);
+}
+function shortHash(value) {
+  return createHash2("sha256").update(value).digest("hex").slice(0, hashLength);
+}
+function screenKey(path8, actions) {
+  return shortHash(JSON.stringify([path8, actions]));
+}
+function pathId(actions) {
+  return shortHash(JSON.stringify(actions));
+}
+async function runAction(driver, action) {
+  if (action.kind === "fill") {
+    await driver.evaluate(fillScript(action.label, action.value));
+    return;
+  }
+  if (action.role === "button") {
+    await driver.clickButton(action.name);
+    return;
+  }
+  await driver.evaluate(linkClickScript(action.name));
+}
+async function replay(driver, path8, settleMs = actionSettleMs) {
+  await driver.navigate("/");
+  for (const action of path8.actions) {
+    await runAction(driver, action);
+    if (settleMs > 0) await wait(settleMs);
+  }
+}
+function clickDepth(actions) {
+  return actions.filter((action) => action.kind === "click").length;
+}
+function childPaths(path8, actions) {
+  if (clickDepth(path8.actions) >= exploreLimits.maxDepth) return [];
+  const fills = actions.filter((action) => action.kind === "fill");
+  return actions.filter((action) => action.kind === "click").map((click) => {
+    const next = [...path8.actions, ...fills, click];
+    return { id: pathId(next), actions: next };
+  });
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function visit(input, run, path8, seen) {
+  const { driver } = input;
+  try {
+    await replay(driver, path8, input.settleMs);
+  } catch (error) {
+    run.replayFailures.push({ pathId: path8.id, message: errorMessage2(error) });
+    return { clean: false, children: [] };
+  }
+  if (await input.isExternal()) return { clean: true, children: [] };
+  const actions = await listActions(driver, input.formValues);
+  const key = screenKey(await driver.currentPath(), actions);
+  if (seen.has(key)) return { clean: false, children: [] };
+  seen.add(key);
+  const issues = await input.probe();
+  run.issues.push(...issues.map((issue) => ({ ...issue, pathId: path8.id, screenshot: "", logDir: "" })));
+  return { clean: true, children: childPaths(path8, actions) };
+}
+function takeBlocked(input) {
+  return input.blockedSince ? input.blockedSince() : [];
+}
+async function crawl(input) {
+  const now = input.now ?? Date.now;
+  const startedAt = now();
+  const deadline = startedAt + exploreLimits.maxMinutes * minuteMs;
+  const run = {
+    runId: input.runId ?? "",
+    deviceId: input.deviceId ?? "",
+    startedAt: new Date(startedAt).toISOString(),
+    finishedAt: null,
+    paths: [],
+    issues: [],
+    blocked: [],
+    cleanPathIds: [],
+    replayFailures: []
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [{ id: pathId([]), actions: [] }];
+  takeBlocked(input);
+  while (queue.length > 0 && now() <= deadline) {
+    const path8 = queue.shift();
+    if (!path8) break;
+    const result = await visit(input, run, path8, seen);
+    const blocked = takeBlocked(input);
+    run.paths.push(path8);
+    run.blocked.push(...blocked.map((request) => ({ ...request, pathId: path8.id })));
+    if (result.clean && blocked.length === 0) run.cleanPathIds.push(path8.id);
+    queue.push(...result.children);
+    input.onStep(run);
+  }
+  run.finishedAt = new Date(now()).toISOString();
+  input.onStep(run);
+  return run;
+}
+
+// packages/engine/src/explore/results.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import path5 from "path";
+var exploreDir = "explore";
+var jsonExtension = ".json";
+function exploreRunDir(runId, root = testResultsRoot) {
+  return path5.join(root, exploreDir, pathSegment(runId));
+}
+function writeExploreResult(result, root = testResultsRoot) {
+  const file = path5.join(exploreRunDir(result.runId, root), `${pathSegment(result.deviceId)}${jsonExtension}`);
+  mkdirSync3(path5.dirname(file), { recursive: true });
+  writeFileSync3(`${file}.part`, JSON.stringify(result, null, 2));
+  renameSync2(`${file}.part`, file);
+}
+function isExploreResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const run = value;
+  return typeof run.runId === "string" && typeof run.platform === "string" && typeof run.deviceId === "string" && Array.isArray(run.paths) && Array.isArray(run.cleanPathIds);
+}
+function readResult(file) {
+  try {
+    const parsed = JSON.parse(readFileSync3(file, "utf8"));
+    return isExploreResult(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readExploreRun(runId, root = testResultsRoot) {
+  const dir = exploreRunDir(runId, root);
+  if (!existsSync3(dir)) return [];
+  return readdirSync3(dir).filter((name) => name.endsWith(jsonExtension)).sort().flatMap((name) => readResult(path5.join(dir, name)) ?? []);
+}
+function readLatestExplore(root = testResultsRoot) {
+  const base = path5.join(root, exploreDir);
+  if (!existsSync3(base)) return [];
+  const latest = readdirSync3(base, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+  return latest ? readExploreRun(latest, root) : [];
+}
+function cleanAndroidPaths(results) {
+  const crawled = results.filter((result) => result.platform === "android" && result.finishedAt !== null && result.message === void 0);
+  if (crawled.length === 0) return null;
+  const paths = /* @__PURE__ */ new Map();
+  for (const result of crawled) {
+    const clean = new Set(result.cleanPathIds);
+    for (const item of result.paths) if (clean.has(item.id) && !paths.has(item.id)) paths.set(item.id, item);
+  }
+  return [...paths.values()];
+}
+
+// packages/engine/src/explore/run.ts
+var devOnlyMessage = "dev \uBE4C\uB4DC\uC5D0\uC11C\uB9CC \uD0D0\uC0C9\uD569\uB2C8\uB2E4.";
+var noAndroidMessage = "Android \uD0D0\uC0C9 \uACB0\uACFC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.";
+var iosCleanOnlyMessage = "iOS\uB294 Android\uC5D0\uC11C \uCC28\uB2E8 \uC5C6\uC774 \uB05D\uB09C \uACBD\uB85C\uB9CC \uB2E4\uC2DC \uB3D5\uB2C8\uB2E4.";
+var ExploreRequestError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var emptyBundle = { screenshot: "", logDir: "" };
+function isAndroidDriver(driver) {
+  return "context" in driver;
+}
+var defaultGuard = async (driver, webOrigin, allowlist, onBlocked) => {
+  if (!isAndroidDriver(driver)) throw new Error("Android \uB4DC\uB77C\uC774\uBC84\uAC00 \uC544\uB2C8\uB77C \uC694\uCCAD \uAC00\uB4DC\uB97C \uCF24 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  return guardAndroidPage(driver.context, guardTargetOf(driver.app, webOrigin), allowlist, onBlocked);
+};
+var nowOf = (deps) => (deps.now ?? Date.now)();
+var logOf2 = (deps) => deps.log ?? ((message) => console.warn(`[explore] ${message}`));
+async function bundleScreen(session) {
+  const { deps } = session;
+  const root = deps.resultsRoot ?? testResultsRoot;
+  session.bundles += 1;
+  const dir = path6.join(root, "explore", pathSegment(session.runId), pathSegment(session.device.id), `screen-${session.bundles}`);
+  const relative = path6.relative(root, dir).split(path6.sep).join("/");
+  let screenshot;
+  try {
+    screenshot = await session.driver.screenshot();
+  } catch (error) {
+    logOf2(deps)(`${relative} \uC2A4\uD06C\uB9B0\uC0F7\uC744 \uBABB \uCC0D\uC5B4 \uBB36\uC74C\uC744 \uAC74\uB108\uB701\uB2C8\uB2E4: ${errorMessage(error)}`);
+    return emptyBundle;
+  }
+  const input = { logs: session.capture.ring.around(nowOf(deps)), frames: session.capture.frames(), screenshot };
+  try {
+    await (deps.writeBundle ?? writeFailureBundle)(dir, input);
+  } catch (error) {
+    logOf2(deps)(`${relative} \uC2E4\uD328 \uBB36\uC74C \uC77C\uBD80\uB97C \uBABB \uC37C\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+  }
+  return { screenshot: `${relative}/screenshot.png`, logDir: relative };
+}
+function newResult(runId, device, now) {
+  return {
+    runId,
+    deviceId: device.id,
+    platform: device.platform,
+    startedAt: new Date(now).toISOString(),
+    finishedAt: null,
+    paths: [],
+    issues: [],
+    blocked: [],
+    cleanPathIds: [],
+    replayFailures: []
+  };
+}
+function emptyCapture2() {
+  return { ring: new LogRing(), frames: () => [], stop: async () => void 0 };
+}
+async function startCapture2(deps, device, driver) {
+  if (!deps.capture) return emptyCapture2();
+  try {
+    return await deps.capture(device, driver, appIdFor(deps.app, "dev", device.platform));
+  } catch (error) {
+    logOf2(deps)(`${device.id} \uB85C\uADF8 \uC218\uC9D1\uC744 \uBABB \uB744\uC6E0\uC2B5\uB2C8\uB2E4: ${errorMessage(error)}`);
+    return emptyCapture2();
+  }
+}
+async function withDevice(deps, device, runId, body) {
+  const owner = { kind: "bot", runId };
+  if (!deps.locks.acquire(device.id, owner)) return false;
+  try {
+    const driver = await deps.openDriver(device, appIdFor(deps.app, "dev", device.platform));
+    const capture = await startCapture2(deps, device, driver);
+    try {
+      await body({ deps, device, driver, capture, runId, bundles: 0 });
+    } finally {
+      await capture.stop().catch((error) => logOf2(deps)(`${device.id} \uB85C\uADF8 \uC218\uC9D1 \uC815\uC9C0 \uC2E4\uD328: ${errorMessage(error)}`));
+      await driver.close().catch(() => void 0);
+    }
+  } finally {
+    deps.locks.release(device.id, owner);
+  }
+  return true;
+}
+function fillBundles(result, bundles) {
+  result.issues.forEach((issue, index) => {
+    const bundle = bundles[index];
+    if (bundle) Object.assign(issue, bundle);
+  });
+}
+async function crawlAndroid(session, result, publish) {
+  const { deps, driver, capture } = session;
+  const blocked = [];
+  const unguard = await (deps.guard ?? defaultGuard)(driver, deps.webOrigin, deps.allowlist, (request) => blocked.push(request));
+  const bundles = [];
+  let since = nowOf(deps);
+  const probe = async () => {
+    const issues = await (deps.probe ?? probeScreen)(driver, capture.ring, since, deps.allowlist);
+    const bundle = issues.length > 0 ? await bundleScreen(session) : emptyBundle;
+    bundles.push(...issues.map(() => bundle));
+    return issues;
+  };
+  try {
+    await (deps.crawl ?? crawl)({
+      driver,
+      probe,
+      formValues: deps.formValues,
+      now: deps.now,
+      runId: session.runId,
+      deviceId: session.device.id,
+      isExternal: async () => isExternal(await driver.evaluate("location.href"), deps.webOrigin, deps.app.apiOrigin || void 0),
+      blockedSince: () => {
+        since = nowOf(deps);
+        return blocked.splice(0);
+      },
+      onStep: (step) => {
+        Object.assign(result, step, { platform: session.device.platform });
+        fillBundles(result, bundles);
+        publish();
+      }
+    });
+  } finally {
+    await unguard();
+  }
+}
+async function replayIos(session, result, paths, publish) {
+  const { deps, driver, capture } = session;
+  for (const item of paths) {
+    const since = nowOf(deps);
+    result.paths.push(item);
+    try {
+      await (deps.replay ?? replay)(driver, item);
+    } catch (error) {
+      result.replayFailures.push({ pathId: item.id, message: errorMessage(error) });
+      publish();
+      continue;
+    }
+    const issues = await (deps.probe ?? probeScreen)(driver, capture.ring, since, deps.allowlist);
+    const bundle = issues.length > 0 ? await bundleScreen(session) : emptyBundle;
+    result.issues.push(...issues.map((issue) => ({ ...issue, pathId: item.id, ...bundle })));
+    if (issues.length === 0) result.cleanPathIds.push(item.id);
+    publish();
+  }
+}
+function publisher(context, result) {
+  return () => {
+    writeExploreResult(result, context.deps.resultsRoot);
+    context.deps.onUpdate?.(context.results);
+  };
+}
+function skipReason(device, androidPaths) {
+  if (device.appVersion === null) return devOnlyMessage;
+  if (device.platform === "ios" && androidPaths === null) return noAndroidMessage;
+  return null;
+}
+async function exploreDevice(context, device, androidPaths) {
+  const { deps } = context;
+  const result = newResult(context.runId, device, nowOf(deps));
+  context.results.push(result);
+  const publish = publisher(context, result);
+  const skip = skipReason(device, androidPaths);
+  try {
+    if (skip !== null) result.message = skip;
+    else {
+      const ran = await withDevice(
+        deps,
+        device,
+        context.runId,
+        (session) => device.platform === "android" ? crawlAndroid(session, result, publish) : replayIos(session, result, androidPaths ?? [], publish)
+      );
+      if (!ran) result.message = humanControlMessage;
+    }
+  } catch (error) {
+    result.message = errorMessage(error);
+  } finally {
+    result.finishedAt ??= new Date(nowOf(deps)).toISOString();
+    publish();
+  }
+}
+async function runExplore(request, deps) {
+  const context = { runId: request.runId ?? createRunId(nowOf(deps)), deps, results: [] };
+  const devices = pickDevices(await deps.listDevices(), request.deviceIds);
+  const androids = devices.filter((device) => device.platform === "android");
+  await eachLimited(androids, deviceConcurrency, (device) => exploreDevice(context, device, null));
+  const androidPaths = cleanAndroidPaths(context.results);
+  const iosDevices = devices.filter((device) => device.platform === "ios");
+  await eachLimited(iosDevices, deviceConcurrency, (device) => exploreDevice(context, device, androidPaths));
+  return context.results;
+}
+async function replayAndProbe(session, item) {
+  const { deps, driver, capture } = session;
+  const blocked = [];
+  const unguard = session.device.platform === "android" ? await (deps.guard ?? defaultGuard)(driver, deps.webOrigin, deps.allowlist, (request) => blocked.push(request)) : async () => void 0;
+  try {
+    const since = nowOf(deps);
+    await (deps.replay ?? replay)(driver, item);
+    const issues = await (deps.probe ?? probeScreen)(driver, capture.ring, since, deps.allowlist);
+    return [...issues, ...blocked.map((request) => ({ kind: "network", message: `\uCC28\uB2E8\uB428 ${request.method} ${request.path} (${request.reason})` }))];
+  } finally {
+    await unguard();
+  }
+}
+async function replayOne(deviceId, runId, pathId2, deps) {
+  const results = readExploreRun(runId, deps.resultsRoot);
+  const item = results.flatMap((result) => result.paths).find((candidate) => candidate.id === pathId2);
+  if (!item) throw new ExploreRequestError(404, "\uB2E4\uC2DC \uB3CC\uB9B4 \uACBD\uB85C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  const device = (await deps.listDevices()).find((candidate) => candidate.id === deviceId);
+  if (!device) throw new ExploreRequestError(404, "\uC5F0\uACB0\uB41C \uAE30\uAE30\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+  if (device.appVersion === null) throw new ExploreRequestError(400, devOnlyMessage);
+  const clean = cleanAndroidPaths(results) ?? [];
+  if (device.platform === "ios" && !clean.some((candidate) => candidate.id === pathId2)) throw new ExploreRequestError(400, iosCleanOnlyMessage);
+  let issues = [];
+  const ran = await withDevice(deps, device, `replay-${runId}`, async (session) => {
+    issues = await replayAndProbe(session, item);
+  });
+  if (!ran) throw new ExploreRequestError(409, humanControlMessage);
+  return issues;
+}
+
+// packages/server/src/explore.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import path7 from "path";
+var formValuesFile = path7.resolve("explore/form-values.json");
+var readJson = (file, fallback) => existsSync4(file) ? JSON.parse(readFileSync4(file, "utf8")) : fallback;
+function parseFormValues(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("form-values: { \uB77C\uBCA8: \uAC12 } \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4.");
+  const entries = Object.entries(value);
+  if (entries.some(([, item]) => typeof item !== "string")) throw new Error("form-values: \uAC12\uC740 \uBB38\uC790\uC5F4\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+  return Object.fromEntries(entries);
+}
+function loadExploreInputs(allowlistFile = defaultAllowlistFile, valuesFile = formValuesFile) {
+  return {
+    allowlist: parseAllowlist(readJson(allowlistFile, { entries: [] })),
+    formValues: parseFormValues(readJson(valuesFile, {}))
+  };
+}
+
+export {
+  formatNetworkLog,
+  probeScreen,
+  LogRing,
+  FrameRing,
+  devicesRoot,
+  writeRun,
+  readLatestRun,
+  closeUnfinishedRun,
+  pruneRuns,
+  channelTolerance,
+  deviceBaselinesRoot,
+  baselineKey,
+  pendingDeviceBaselines,
+  confirmDeviceBaselines,
+  testResultsRoot,
+  installedVersionLabel,
+  errorMessage,
+  createRunId,
+  runDevices,
+  readLatestExplore,
+  ExploreRequestError,
+  defaultGuard,
+  runExplore,
+  replayOne,
+  loadExploreInputs
+};