@delacour/warden-e2e 0.0.0-stage → 0.1.1

package/index.mjs

@@ -0,0 +1,998 @@
+// @bun
+import {
+  BUN_TIMEOUT_MARGIN_MS,
+  E2eError,
+  WARDEN_E2E_VERSION,
+  attemptDir,
+  attemptSession,
+  callerFile,
+  canObserve,
+  createScope,
+  currentScope,
+  fieldValue,
+  flowIdOf,
+  getSession,
+  hash6,
+  hooksFor,
+  isLocator,
+  markOnly,
+  matchesText,
+  normalizeText,
+  pickOne,
+  registrationDefaults,
+  renderHeader,
+  renderSnapshot,
+  resolve,
+  resolveUse,
+  runInScope,
+  runStep,
+  textOf
+} from "./chunk-qtkmfjbq.mjs";
+// ../../packages/e2e/src/expect/expect.ts
+import { expect as bunExpect } from "bun:test";
+
+// ../../packages/e2e/src/expect/matchers.ts
+var NEGATION_GRACE_MS = 1000;
+var NEGATION_QUIET_MS = 250;
+var NOT_FOUND = "element not found";
+function missing() {
+  return { kind: "missing" };
+}
+function judged(matches, received) {
+  return { kind: "judged", matches, received };
+}
+function show(match) {
+  return typeof match === "string" ? JSON.stringify(match) : String(match);
+}
+function assertOptions(matcher, options, allowed) {
+  const unknown = Object.keys(options).filter((key) => !allowed.includes(key));
+  if (unknown.length > 0) {
+    throw new E2eError("INVALID_ARGUMENT", `${matcher} does not take ${unknown.map((key) => `"${key}"`).join(", ")}; it takes ${allowed.join(", ")}`);
+  }
+  const bag = options;
+  for (const key of ["checked", "exact", "ignoreCase"]) {
+    if (bag[key] !== undefined && typeof bag[key] !== "boolean") {
+      throw new E2eError("INVALID_ARGUMENT", `${matcher}: "${key}" must be a boolean`);
+    }
+  }
+  const timeout = bag.timeout;
+  if (timeout !== undefined && (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout < 0)) {
+    throw new E2eError("INVALID_ARGUMENT", `${matcher}: "timeout" must be a non-negative number of milliseconds`);
+  }
+}
+function failUnlessRetryable(error) {
+  if (!error.retryable)
+    throw new E2eError("DRIVER", `snapshot failed: ${error.code}: ${error.message}`);
+}
+function regexTest(pattern, value, ignoreCase = false) {
+  const flags = pattern.flags.replaceAll(/[gy]/g, "");
+  return new RegExp(pattern.source, ignoreCase && !flags.includes("i") ? `${flags}i` : flags).test(value);
+}
+function containsText(value, expected, ignoreCase) {
+  if (typeof expected !== "string")
+    return regexTest(expected, normalizeText(value), ignoreCase);
+  const haystack = normalizeText(value);
+  const needle = normalizeText(expected);
+  return ignoreCase ? haystack.toLowerCase().includes(needle.toLowerCase()) : haystack.includes(needle);
+}
+
+class LocatorAssertions {
+  locator;
+  context;
+  constructor(locator, context) {
+    this.locator = locator;
+    this.context = context;
+  }
+  get not() {
+    return new LocatorAssertions(this.locator, { ...this.context, negate: !this.context.negate });
+  }
+  async toBeVisible(options = {}) {
+    assertOptions("toBeVisible", options, ["timeout"]);
+    return this.assert({
+      call: "toBeVisible()",
+      expected: "visible",
+      strict: true,
+      judge: (entry) => entry === undefined ? judged(false, "not found") : judged(entry.visible, entry.visible ? "visible" : "hidden")
+    }, options);
+  }
+  async toBeHidden(options = {}) {
+    assertOptions("toBeHidden", options, ["timeout"]);
+    return this.assert({
+      call: "toBeHidden()",
+      expected: "hidden",
+      strict: true,
+      judge: (entry) => entry === undefined ? judged(true, "not found") : judged(!entry.visible, entry.visible ? "visible" : "hidden")
+    }, options);
+  }
+  async toHaveText(expected, options = {}) {
+    assertOptions("toHaveText", options, ["exact", "timeout"]);
+    const exact = options.exact ?? true;
+    return this.assert({
+      call: `toHaveText(${show(expected)})`,
+      expected: exact ? show(expected) : `${show(expected)} (substring, ignoring case)`,
+      strict: true,
+      judge: (entry) => {
+        if (entry === undefined)
+          return missing();
+        const value = textOf(entry);
+        return judged(matchesText(value, expected, { exact }), JSON.stringify(value));
+      }
+    }, options);
+  }
+  async toContainText(expected, options = {}) {
+    assertOptions("toContainText", options, ["ignoreCase", "timeout"]);
+    const ignoreCase = options.ignoreCase ?? false;
+    return this.assert({
+      call: `toContainText(${show(expected)})`,
+      expected: `text containing ${show(expected)}`,
+      strict: true,
+      judge: (entry) => {
+        if (entry === undefined)
+          return missing();
+        const value = textOf(entry);
+        return judged(containsText(value, expected, ignoreCase), JSON.stringify(value));
+      }
+    }, options);
+  }
+  async toHaveValue(expected, options = {}) {
+    assertOptions("toHaveValue", options, ["timeout"]);
+    return this.assert({
+      call: `toHaveValue(${show(expected)})`,
+      expected: show(expected),
+      strict: true,
+      judge: (entry) => {
+        if (entry === undefined)
+          return missing();
+        if (entry.secure) {
+          throw new E2eError("INVALID_ARGUMENT", "toHaveValue cannot judge a secure field: its value is withheld. Assert the outcome of the fill instead.");
+        }
+        const value = fieldValue(entry);
+        const matches = typeof expected === "string" ? value === expected : regexTest(expected, value);
+        return judged(matches, JSON.stringify(value));
+      }
+    }, options);
+  }
+  async toBeChecked(options = {}) {
+    assertOptions("toBeChecked", options, ["checked", "timeout"]);
+    const want = options.checked ?? true;
+    return this.assert({
+      call: options.checked === undefined ? "toBeChecked()" : `toBeChecked({ checked: ${want} })`,
+      expected: want ? "checked" : "unchecked",
+      strict: true,
+      judge: (entry) => {
+        if (entry === undefined)
+          return missing();
+        const checked = entry.states.checked ?? false;
+        return judged(checked === want, checked ? "checked" : "unchecked");
+      }
+    }, options);
+  }
+  async toBeEnabled(options = {}) {
+    assertOptions("toBeEnabled", options, ["timeout"]);
+    return this.assert({
+      call: "toBeEnabled()",
+      expected: "enabled",
+      strict: true,
+      judge: (entry) => entry === undefined ? missing() : judged(!entry.states.disabled, entry.states.disabled ? "disabled" : "enabled")
+    }, options);
+  }
+  async toBeDisabled(options = {}) {
+    assertOptions("toBeDisabled", options, ["timeout"]);
+    return this.assert({
+      call: "toBeDisabled()",
+      expected: "disabled",
+      strict: true,
+      judge: (entry) => entry === undefined ? missing() : judged(entry.states.disabled, entry.states.disabled ? "disabled" : "enabled")
+    }, options);
+  }
+  async toHaveCount(expected, options = {}) {
+    assertOptions("toHaveCount", options, ["timeout"]);
+    if (!Number.isInteger(expected) || expected < 0) {
+      throw new E2eError("INVALID_ARGUMENT", `toHaveCount takes a non-negative integer, got ${String(expected)}`);
+    }
+    return this.assert({
+      call: `toHaveCount(${expected})`,
+      expected: String(expected),
+      strict: false,
+      judge: (_entry, count) => judged(count === expected, String(count))
+    }, options);
+  }
+  async assert(spec, options) {
+    const rt = this.locator.runtime;
+    const timeoutMs = options.timeout ?? rt.assertionTimeout();
+    try {
+      await rt.step(`expect ${this.locator}.${spec.call}`, () => this.poll(spec, timeoutMs));
+    } catch (error) {
+      if (this.context.soft !== undefined && error instanceof E2eError && error.code !== "TIMEOUT") {
+        this.context.soft(error);
+        return;
+      }
+      throw error;
+    }
+  }
+  async poll(spec, timeoutMs) {
+    const rt = this.locator.runtime;
+    const { negate } = this.context;
+    const hold = conditionHold(negate, Math.min(NEGATION_GRACE_MS, timeoutMs), rt.clock.now);
+    const result = await rt.poll(async (attempt) => {
+      const observation = await rt.tryObserve({ reuse: attempt === 1 });
+      if (!observation.ok) {
+        failUnlessRetryable(observation.error);
+        hold.broken();
+        return { done: false, state: { received: "(screen unreadable)" } };
+      }
+      const { observed } = observation;
+      const entries = resolve(this.locator.expr, observed.index);
+      if (spec.strict && entries.length > 1)
+        pickOne(rt, this.locator.expr, entries, observed);
+      const judgement = spec.judge(entries[0], entries.length);
+      const verdict = await hold.next(judgement.kind === "judged" && judgement.matches !== negate, observed.driver);
+      if (verdict === "pass")
+        return { done: true, value: true };
+      return {
+        done: false,
+        state: {
+          received: judgement.kind === "missing" ? NOT_FOUND : judgement.received,
+          snapshot: observed.snapshot
+        },
+        ...verdict.wakeMs === undefined ? {} : { maxWaitMs: verdict.wakeMs }
+      };
+    }, timeoutMs);
+    if (result.status === "done")
+      return;
+    throw this.failure(spec, result.last);
+  }
+  failure(spec, last) {
+    const { negate } = this.context;
+    const lines = [
+      `expect(${this.locator})${negate ? ".not" : ""}.${spec.call}`,
+      `Expected: ${negate ? "not " : ""}${spec.expected}`,
+      `Received: ${last?.received ?? NOT_FOUND}`
+    ];
+    const screen = last?.snapshot === undefined ? undefined : this.locator.runtime.excerpt(last.snapshot);
+    const message = screen === undefined ? lines.join(`
+`) : `${lines.join(`
+`)}
+
+${screen}`;
+    return new E2eError("ASSERTION", message, screen);
+  }
+}
+function conditionHold(negate, holdMs, now) {
+  let since;
+  let asked = false;
+  let quiet = false;
+  const broken = () => {
+    since = undefined;
+    quiet = false;
+  };
+  return {
+    broken,
+    async next(holds, driver) {
+      if (!holds) {
+        broken();
+        return { wakeMs: undefined };
+      }
+      since ??= now();
+      if (!negate || quiet || now() - since >= holdMs)
+        return "pass";
+      if (!asked && driver.capabilities.nativeSettle && noRecentInput(driver)) {
+        asked = true;
+        quiet = await settledQuiet(driver, since + holdMs - now());
+      }
+      return { wakeMs: quiet ? 0 : since + holdMs - now() };
+    }
+  };
+}
+function noRecentInput(driver) {
+  const previous = canObserve(driver) ? driver.previous?.() : undefined;
+  if (previous === undefined)
+    return false;
+  return previous.sinceInputMs === undefined || previous.sinceInputMs >= NEGATION_GRACE_MS;
+}
+async function settledQuiet(driver, timeoutMs) {
+  if (timeoutMs <= 0)
+    return false;
+  const settled = await driver.settle({ quietMs: NEGATION_QUIET_MS, timeoutMs });
+  return settled.success && settled.data.quiet;
+}
+
+// ../../packages/e2e/src/expect/expect.ts
+function softSinkFor(session) {
+  const failures = session.attempt?.softFailures;
+  return failures === undefined ? undefined : (error) => void failures.push(error);
+}
+function currentSoftSink() {
+  try {
+    return softSinkFor(getSession());
+  } catch {
+    return;
+  }
+}
+var valueExpect = bunExpect;
+function asAssertion(error) {
+  if (error instanceof E2eError)
+    return error;
+  return new E2eError("ASSERTION", error instanceof Error ? error.message : String(error));
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function softMatchers(target, sink) {
+  return new Proxy(target, {
+    get(object, property) {
+      const value = Reflect.get(object, property, object);
+      if (typeof value === "function") {
+        return (...args) => {
+          try {
+            const result = Reflect.apply(value, object, args);
+            return isThenable(result) ? Promise.resolve(result).catch((e) => sink(asAssertion(e))) : result;
+          } catch (error) {
+            sink(asAssertion(error));
+            return;
+          }
+        };
+      }
+      if (typeof value === "object" && value !== null)
+        return softMatchers(value, sink);
+      return value;
+    }
+  });
+}
+var NOT_STATIC = new Set(["length", "name", "prototype"]);
+function createExpect(deps) {
+  const call = (actual, message) => isLocator(actual) ? new LocatorAssertions(actual, { negate: false }) : valueExpect(actual, message);
+  const soft = (actual, message) => {
+    const sink = deps.softSink();
+    if (isLocator(actual))
+      return new LocatorAssertions(actual, { negate: false, ...sink === undefined ? {} : { soft: sink } });
+    const matchers = valueExpect(actual, message);
+    return sink === undefined ? matchers : softMatchers(matchers, sink);
+  };
+  for (const key of Reflect.ownKeys(bunExpect)) {
+    if (NOT_STATIC.has(key))
+      continue;
+    Object.defineProperty(call, key, {
+      enumerable: true,
+      get() {
+        const value = Reflect.get(bunExpect, key);
+        return typeof value === "function" ? value.bind(bunExpect) : value;
+      }
+    });
+  }
+  Object.defineProperty(call, "soft", { enumerable: true, value: soft });
+  return call;
+}
+var expect = createExpect({ softSink: currentSoftSink });
+// ../../packages/e2e/src/runner/test.ts
+import { afterAll as bunAfterAll, beforeAll as bunBeforeAll, describe as bunDescribe, test as bunTest } from "bun:test";
+
+// ../../packages/e2e/src/runner/attempt.ts
+import { readdirSync } from "fs";
+import { join as join2 } from "path";
+
+// ../../packages/e2e/src/runner/failure.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+var FAILURE_PNG = "failure.png";
+var SCREEN_AT_FAILURE = "screen-at-failure.txt";
+var CONSOLE_JSONL = "console.jsonl";
+var NETWORK_JSONL = "network.jsonl";
+var CAPTURE_TIMEOUT_MS = 1e4;
+
+class CaptureTimeout extends Error {
+}
+function limited(promise, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new CaptureTimeout(`timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+var unlimited = () => Number.POSITIVE_INFINITY;
+var SPENT = "skipped, the post-deadline budget is used up";
+async function captureFailure(driver, dir, timeoutMs = CAPTURE_TIMEOUT_MS, budget = unlimited) {
+  const capture = { files: [], problems: [] };
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch (cause) {
+    capture.problems.push(`mkdir ${dir}: ${String(cause)}`);
+    return capture;
+  }
+  const shot = await captureScreenshot(driver, dir, Math.min(timeoutMs, budget()), capture);
+  if (shot === "unanswered") {
+    capture.problems.push("snapshot: skipped, the screenshot timed out (the device is not answering)");
+    return capture;
+  }
+  await captureSnapshot(driver, dir, Math.min(timeoutMs, budget()), capture);
+  return capture;
+}
+var message = (cause) => cause instanceof Error ? cause.message : String(cause);
+async function captureScreenshot(driver, dir, ms, capture) {
+  if (ms <= 0) {
+    capture.problems.push(`screenshot: ${SPENT}`);
+    return "answered";
+  }
+  try {
+    const shot = await limited(driver.screenshot({ path: join(dir, FAILURE_PNG) }), ms);
+    if (!shot.success) {
+      capture.problems.push(`screenshot: ${shot.error.code}: ${shot.error.message}`);
+      return "answered";
+    }
+    if (shot.data.path === undefined && shot.data.png !== undefined) {
+      writeFileSync(join(dir, FAILURE_PNG), shot.data.png);
+    }
+    capture.files.push(FAILURE_PNG);
+  } catch (cause) {
+    capture.problems.push(`screenshot: ${message(cause)}`);
+    if (cause instanceof CaptureTimeout)
+      return "unanswered";
+  }
+  return "answered";
+}
+async function captureSnapshot(driver, dir, ms, capture) {
+  if (ms <= 0) {
+    capture.problems.push(`snapshot: ${SPENT}`);
+    return;
+  }
+  try {
+    const result = await limited(driver.snapshot(), ms);
+    if (!result.success) {
+      capture.problems.push(`snapshot: ${result.error.code}: ${result.error.message}`);
+      return;
+    }
+    const rendered = renderSnapshot(result.data, { interactiveOnly: false, refs: new Map });
+    const header = renderHeader({ snapshot: result.data, rendered, interactiveOnly: false });
+    writeFileSync(join(dir, SCREEN_AT_FAILURE), `${[header, ...rendered.lines].join(`
+`)}
+`);
+    capture.files.push(SCREEN_AT_FAILURE);
+  } catch (cause) {
+    capture.problems.push(`snapshot: ${message(cause)}`);
+  }
+}
+async function captureDevtoolsArtifacts(facet, dir, timeoutMs = CAPTURE_TIMEOUT_MS, budget = unlimited) {
+  const capture = { files: [], problems: [] };
+  const ms = Math.min(timeoutMs, budget());
+  if (ms <= 0) {
+    capture.problems.push(`devtools artifacts: ${SPENT}`);
+    return capture;
+  }
+  try {
+    const written = await limited(facet.attachArtifacts(dir), ms);
+    if (written.success)
+      capture.files.push(CONSOLE_JSONL, NETWORK_JSONL);
+    else
+      capture.problems.push(`devtools artifacts: ${written.error.code}: ${written.error.message}`);
+  } catch (cause) {
+    capture.problems.push(`devtools artifacts: ${cause instanceof Error ? cause.message : String(cause)}`);
+  }
+  return capture;
+}
+
+// ../../packages/e2e/src/runner/trace.ts
+import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+import { z } from "zod";
+var base = { ts: z.number(), kind: z.string(), label: z.string() };
+var traceEventSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("step-start"), ...base }),
+  z.object({
+    type: z.literal("step-end"),
+    ...base,
+    status: z.enum(["passed", "failed"]),
+    ms: z.number(),
+    error: z.string().optional()
+  }),
+  z.object({ type: z.literal("screenshot"), ...base, path: z.string() }),
+  z.object({ type: z.literal("note"), ...base }),
+  z.object({
+    type: z.literal("span"),
+    ts: z.number(),
+    op: z.string(),
+    ms: z.number(),
+    ok: z.boolean(),
+    code: z.string().optional(),
+    detail: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional()
+  })
+]);
+var SPAN_BUFFER_MAX = 256;
+function openTrace(path, mirror) {
+  let ready = false;
+  let pending = [];
+  const append = (lines) => {
+    if (!ready) {
+      mkdirSync2(dirname(path), { recursive: true });
+      ready = true;
+    }
+    appendFileSync(path, lines.join(""));
+  };
+  const flush = () => {
+    if (pending.length === 0)
+      return;
+    const lines = pending;
+    pending = [];
+    append(lines);
+  };
+  return {
+    path,
+    write(event) {
+      const line = `${JSON.stringify(event)}
+`;
+      if (event.type === "span") {
+        pending.push(line);
+        if (pending.length >= SPAN_BUFFER_MAX)
+          flush();
+      } else {
+        const lines = pending;
+        pending = [];
+        append([...lines, line]);
+      }
+      mirror?.(event);
+    },
+    flush
+  };
+}
+var pad = (n, width = 2) => String(n).padStart(width, "0");
+function clockOf(ts) {
+  const d = new Date(ts);
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+function shortName(file) {
+  return (file.split("/").pop() ?? file).replace(/\.e2e\.[cm]?[jt]sx?$/, "").replace(/\.[cm]?[jt]sx?$/, "");
+}
+var deviceLabel = (device) => device.name ?? (device.udid.length > 9 ? `${device.udid.slice(0, 9)}\u2026` : device.udid);
+var testName = (test) => `${test.file} \u203A ${test.title.join(" \u203A ")}`;
+function lineOf(event, opts) {
+  const short = opts.short ?? "test";
+  const indent = "  ".repeat((opts.depth ?? 0) + 1);
+  switch (event.type) {
+    case "test-start":
+      return { ts: event.test.startedAt, text: `\u25B6 test |${event.test.device.platform}| ${testName(event.test)}` };
+    case "test-end": {
+      const r = event.result;
+      return {
+        ts: r.startedAt + r.durationMs,
+        text: `\u25A0 test |${r.device.platform}| ${testName(r)} ${r.status} ${(r.durationMs / 1000).toFixed(2)}s on ${deviceLabel(r.device)}`
+      };
+    }
+    case "step-start":
+      return { ts: event.ts, text: `${indent}\u25B8 ${short} \u203A ${event.kind} ${event.label}` };
+    case "step-end": {
+      const error = event.error ? ` \u2014 ${event.error}` : "";
+      return {
+        ts: event.ts,
+        text: `${indent}\u25AA ${short} \u203A ${event.kind} ${event.label} ${event.status} ${event.ms}ms${error}`
+      };
+    }
+    default:
+      return;
+  }
+}
+function formatConsoleLine(event, opts) {
+  const line = lineOf(event, opts);
+  if (line === undefined)
+    return;
+  return opts.clock ? `[${clockOf(line.ts)}] ${line.text}` : line.text;
+}
+
+// ../../packages/e2e/src/runner/attempt.ts
+var CLEANUP_TIMEOUT_MS = 1e4;
+var POST_DEADLINE_RESERVE_MS = 5000;
+var DEFAULT_TIMING = {
+  cleanupTimeoutMs: CLEANUP_TIMEOUT_MS,
+  captureTimeoutMs: CAPTURE_TIMEOUT_MS,
+  bunMarginMs: BUN_TIMEOUT_MARGIN_MS,
+  reserveMs: POST_DEADLINE_RESERVE_MS
+};
+var timing = { ...DEFAULT_TIMING };
+function runnerTiming() {
+  return timing;
+}
+function unavailable(name) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol" || prop === "then")
+        return;
+      throw new E2eError("SESSION", `the \`${name}\` fixture is not available: no fixture factory is registered on the session`);
+    }
+  });
+}
+async function buildBaseFixtures(session, signal, use) {
+  if (session.fixtures === undefined) {
+    return {
+      app: unavailable("app"),
+      device: unavailable("device"),
+      screen: unavailable("screen"),
+      platform: session.env.platform
+    };
+  }
+  return session.fixtures({
+    session,
+    signal,
+    launch: use.launch,
+    actionTimeoutMs: use.actionTimeoutMs,
+    assertionTimeoutMs: use.assertionTimeoutMs,
+    systemAlerts: use.systemAlerts
+  });
+}
+async function startFixture(entry, bag) {
+  let provide = () => {
+    return;
+  };
+  let fail = () => {
+    return;
+  };
+  let release = () => {
+    return;
+  };
+  let used = false;
+  const value = new Promise((resolve2, reject) => {
+    provide = resolve2;
+    fail = reject;
+  });
+  const released = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const finished = entry.setup(bag, async (v) => {
+    used = true;
+    provide(v);
+    await released;
+  }).then(() => {
+    if (!used)
+      fail(new E2eError("INVALID_ARGUMENT", `fixture \`${entry.name}\` finished without calling use()`));
+  }, (error) => {
+    if (!used)
+      fail(error);
+    else
+      throw error;
+  });
+  finished.catch(() => {
+    return;
+  });
+  const resolved = await value;
+  return {
+    value: resolved,
+    teardown: async () => {
+      release();
+      await finished;
+    }
+  };
+}
+function cleanupDeadline(startedAt, timeoutMs, bunTimeoutMs) {
+  const t = runnerTiming();
+  return startedAt + Math.min(timeoutMs + t.bunMarginMs, bunTimeoutMs ?? Number.POSITIVE_INFINITY) - t.reserveMs;
+}
+function limited2(label, ms, fn) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new E2eError("TIMEOUT", `${label} timed out after ${ms}ms`)), ms);
+  });
+  return Promise.race([fn(), timeout]).finally(() => clearTimeout(timer));
+}
+function listScreenshots(dir) {
+  try {
+    return readdirSync(join2(dir, "screenshots")).map((name) => `screenshots/${name}`);
+  } catch {
+    return [];
+  }
+}
+function errorInfo(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      ...error instanceof E2eError ? { code: error.code } : {},
+      ...error.stack !== undefined ? { stack: error.stack } : {}
+    };
+  }
+  return { message: String(error) };
+}
+async function runAttempt(session, spec) {
+  const { env } = session;
+  const use = resolveUse(spec.scope, { timeoutMs: env.timeoutMs, actionTimeoutMs: env.actionTimeoutMs, assertionTimeoutMs: env.assertionTimeoutMs }, spec.timeout);
+  const startedAt = Date.now();
+  const cleanupBy = cleanupDeadline(startedAt, use.timeoutMs, spec.bunTimeoutMs);
+  const budget = () => cleanupBy - Date.now();
+  const device = { udid: env.udid, platform: env.platform };
+  const clock = !env.logTimestamps;
+  const short = shortName(spec.file);
+  const dir = attemptDir(session.out, flowIdOf(spec.file, env.flowsDir), spec.title, hash6(spec.file, ...spec.title));
+  const print = (line) => {
+    if (line !== undefined)
+      session.log(line);
+  };
+  const files = new Set;
+  let binding;
+  const trace = openTrace(join2(dir, "trace.jsonl"), (event) => {
+    files.add("trace.jsonl");
+    print(formatConsoleLine(event, { clock, short, depth: binding?.context.depth ?? 0 }));
+  });
+  const controller = new AbortController;
+  const ctx = {
+    signal: controller.signal,
+    dir,
+    short,
+    trace,
+    depth: 0,
+    files,
+    softFailures: []
+  };
+  binding = { context: ctx, finished: false };
+  const bound = attemptSession(session, () => binding ?? { context: ctx, finished: false });
+  print(formatConsoleLine({ type: "test-start", test: { file: spec.file, title: [...spec.title], startedAt, device } }, { clock }));
+  session.enterAttempt(ctx);
+  let deadlineHit = false;
+  const timer = setTimeout(() => {
+    deadlineHit = true;
+    controller.abort(new E2eError("TIMEOUT", `test timed out after ${use.timeoutMs}ms`));
+  }, use.timeoutMs);
+  const deadline = new Promise((_, reject) => {
+    controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+  });
+  deadline.catch(() => {
+    return;
+  });
+  const teardowns = [];
+  const state = {};
+  let failed = false;
+  let failure;
+  try {
+    await Promise.race([setUpAndRun(bound, spec, use, controller.signal, state, teardowns), deadline]);
+  } catch (error) {
+    failed = true;
+    failure = error;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!failed && ctx.softFailures.length > 0) {
+    failed = true;
+    failure = softFailureError(ctx.softFailures);
+  }
+  if (failed)
+    await captureFailureArtifacts(session, ctx, budget);
+  const cleanupErrors = await runCleanup(session, spec, ctx, state.bag, teardowns, budget, (context) => {
+    binding = { context, finished: false };
+  });
+  const finished = new E2eError("SESSION", "attempt finished");
+  if (!controller.signal.aborted)
+    controller.abort(finished);
+  binding = { context: { ...ctx, signal: AbortSignal.abort(finished), depth: 0 }, finished: true };
+  session.leaveAttempt(ctx);
+  trace.flush();
+  if (!failed && cleanupErrors.length > 0) {
+    failed = true;
+    failure = cleanupErrors[0];
+  }
+  for (const shot of listScreenshots(dir))
+    files.add(shot);
+  const outcome = failed ? { failed: true, error: failure, timedOut: deadlineHit } : { failed: false };
+  const result = buildResult(spec, ctx, { startedAt, device }, outcome);
+  print(formatConsoleLine({ type: "test-end", result }, { clock }));
+  if (!failed || spec.final)
+    session.results.append(result);
+  if (failed)
+    throw failure instanceof Error ? failure : new Error(String(failure));
+}
+function softFailureError(failures) {
+  if (failures.length === 1 && failures[0] !== undefined)
+    return failures[0];
+  const body = failures.map((failure, index) => `${index + 1}) ${failure.message}`).join(`
+
+`);
+  return new E2eError("ASSERTION", `${failures.length} soft assertions failed:
+
+${body}`, failures[0]?.screen);
+}
+function buildResult(spec, ctx, run, outcome) {
+  const status = !outcome.failed ? "passed" : outcome.timedOut ? "timed-out" : "failed";
+  return {
+    file: spec.file,
+    title: [...spec.title],
+    status,
+    durationMs: Date.now() - run.startedAt,
+    startedAt: run.startedAt,
+    ...spec.only ? { only: true } : {},
+    ...outcome.failed ? { error: errorInfo(outcome.error) } : {},
+    ...ctx.files.size > 0 ? { artifacts: { dir: ctx.dir, files: [...ctx.files].sort() } } : {},
+    device: run.device
+  };
+}
+async function setUpAndRun(session, spec, use, signal, state, teardowns) {
+  const base2 = await buildBaseFixtures(session, signal, use);
+  const built = { ...base2 };
+  state.bag = built;
+  if (use.launch === "fresh")
+    await session.step("app", "app.open", () => base2.app.open());
+  for (const entry of spec.fixtures) {
+    const started = await session.step("fixture", entry.name, () => startFixture(entry, built));
+    built[entry.name] = started.value;
+    teardowns.push({ name: entry.name, run: started.teardown });
+  }
+  for (const hook of hooksFor(spec.scope, "beforeEach")) {
+    await session.step("hook", "beforeEach", async () => hook(built));
+  }
+  await spec.body(built);
+}
+async function captureFailureArtifacts(session, ctx, budget) {
+  const driver = session.peekDriver();
+  const facet = session.peekDevtools();
+  const { captureTimeoutMs } = runnerTiming();
+  const captures = [
+    ...driver === undefined ? [] : [await captureFailure(driver, ctx.dir, captureTimeoutMs, budget)],
+    ...facet === undefined ? [] : [await captureDevtoolsArtifacts(facet, ctx.dir, captureTimeoutMs, budget)]
+  ];
+  for (const capture of captures) {
+    for (const file of capture.files)
+      ctx.files.add(file);
+    for (const problem of capture.problems) {
+      ctx.trace.write({ type: "note", ts: Date.now(), kind: "note", label: `failure capture: ${problem}` });
+    }
+  }
+}
+async function runCleanup(session, spec, ctx, built, teardowns, budget, bind) {
+  const cleanup = new AbortController;
+  const cleanupCtx = { ...ctx, signal: cleanup.signal, depth: 0 };
+  session.enterAttempt(cleanupCtx, ctx);
+  bind(cleanupCtx);
+  const step = (kind, label, fn) => runStep(cleanupCtx, kind, label, fn);
+  const errors = [];
+  const attempt = async (label, fn) => {
+    try {
+      const left = budget();
+      if (left <= 0)
+        throw new E2eError("TIMEOUT", `${label} skipped: the cleanup budget after the test is used up`);
+      await limited2(label, Math.min(timing.cleanupTimeoutMs, left), fn);
+    } catch (error) {
+      errors.push(error);
+    }
+  };
+  if (built !== undefined) {
+    for (const hook of hooksFor(spec.scope, "afterEach")) {
+      await attempt("afterEach", () => step("hook", "afterEach", async () => hook(built)));
+    }
+  }
+  for (const fixture of [...teardowns].reverse()) {
+    await attempt(`fixture ${fixture.name} teardown`, () => step("fixture", `${fixture.name} teardown`, fixture.run));
+  }
+  cleanup.abort(new E2eError("SESSION", "attempt finished"));
+  session.leaveAttempt(cleanupCtx);
+  return errors;
+}
+
+// ../../packages/e2e/src/runner/fixtures.types.ts
+var SYSTEM_ALERTS = ["accept", "dismiss", "off"];
+
+// ../../packages/e2e/src/runner/test.ts
+var registered = new WeakSet;
+function markRegistered(scope) {
+  for (let s = scope;s !== undefined; s = s.parent)
+    registered.add(s);
+}
+function registerTest(fixtures, mode, title, second, third) {
+  const options = typeof second === "function" ? {} : second;
+  const body = typeof second === "function" ? second : third;
+  if (body === undefined) {
+    throw new E2eError("INVALID_ARGUMENT", `test("${title}"): the test body is missing`);
+  }
+  const scope = currentScope();
+  const file = callerFile();
+  const path = [...scope.title, title];
+  const defaults = registrationDefaults();
+  const use = resolveUse(scope, defaults, options.timeout);
+  const retry = options.retry ?? 0;
+  const wrongPlatform = options.platforms !== undefined && defaults.platform !== undefined && !options.platforms.includes(defaults.platform);
+  const only = mode === "only" || options.only === true;
+  if (only)
+    markOnly();
+  markRegistered(scope);
+  const bunTimeoutMs = use.timeoutMs + runnerTiming().bunMarginMs;
+  let attempts = 0;
+  const run = async () => {
+    attempts += 1;
+    await runAttempt(getSession(), {
+      file,
+      title: path,
+      scope,
+      fixtures,
+      body,
+      ...options.timeout !== undefined ? { timeout: options.timeout } : {},
+      only,
+      final: attempts > retry,
+      bunTimeoutMs
+    });
+  };
+  const bunOptions = { timeout: bunTimeoutMs, retry };
+  if (mode === "skip" || options.skip === true || wrongPlatform)
+    bunTest.skip(title, run, bunOptions);
+  else if (only)
+    bunTest.only(title, run, bunOptions);
+  else
+    bunTest(title, run, bunOptions);
+}
+function eraseSetup(setup) {
+  return (base2, use) => setup(base2, use);
+}
+function isKeyOf(object, key) {
+  return key in object;
+}
+function makeCallable(fixtures, mode) {
+  return (title, second, third) => registerTest(fixtures, mode, title, second, third);
+}
+function makeTest(fixtures) {
+  const base2 = makeCallable(fixtures, "run");
+  return Object.assign(base2, {
+    skip: makeCallable(fixtures, "skip"),
+    only: makeCallable(fixtures, "only"),
+    todo(title) {
+      bunTest.todo(title, () => {
+        throw new E2eError("INVALID_ARGUMENT", `test.todo("${title}") is not implemented`);
+      });
+    },
+    skipIf(condition) {
+      return makeCallable(fixtures, condition ? "skip" : "run");
+    },
+    use(options) {
+      if (options.systemAlerts !== undefined && !SYSTEM_ALERTS.includes(options.systemAlerts)) {
+        throw new E2eError("INVALID_ARGUMENT", `test.use: systemAlerts must be one of ${SYSTEM_ALERTS.map((mode) => `"${mode}"`).join(", ")}, got ${JSON.stringify(options.systemAlerts)}`);
+      }
+      const scope = currentScope();
+      if (options.timeout !== undefined && registered.has(scope)) {
+        process.stderr.write(`warden: test.use({ timeout: ${options.timeout} }) comes after a test in the same scope; bun fixed that ` + `test's own timeout when it was registered, so put test.use above the tests it is for
+`);
+      }
+      scope.use = { ...scope.use, ...options };
+    },
+    extend(defs) {
+      const added = [];
+      for (const name of Object.keys(defs)) {
+        if (isKeyOf(defs, name))
+          added.push({ name, setup: eraseSetup(defs[name]) });
+      }
+      return makeTest([...fixtures, ...added]);
+    }
+  });
+}
+var test = makeTest([]);
+function describe(title, second, third) {
+  const body = typeof second === "function" ? second : third;
+  const options = typeof second === "function" ? {} : second;
+  if (body === undefined)
+    throw new E2eError("INVALID_ARGUMENT", `describe("${title}"): the body is missing`);
+  const scope = createScope(title, options.serial === true);
+  bunDescribe(title, () => runInScope(scope, body));
+}
+function beforeEach(hook) {
+  currentScope().beforeEach.push(hook);
+}
+function afterEach(hook) {
+  currentScope().afterEach.push(hook);
+}
+async function sharedFixtures(scope) {
+  const session = getSession();
+  const defaults = session.env;
+  const use = resolveUse(scope, {
+    timeoutMs: defaults.timeoutMs,
+    actionTimeoutMs: defaults.actionTimeoutMs,
+    assertionTimeoutMs: defaults.assertionTimeoutMs
+  });
+  return buildBaseFixtures(session, session.signal, use);
+}
+function beforeAll(hook) {
+  const scope = currentScope();
+  bunBeforeAll(async () => hook(await sharedFixtures(scope)));
+}
+function afterAll(hook) {
+  const scope = currentScope();
+  bunAfterAll(async () => hook(await sharedFixtures(scope)));
+}
+export {
+  test,
+  expect,
+  describe,
+  beforeEach,
+  beforeAll,
+  afterEach,
+  afterAll,
+  WARDEN_E2E_VERSION,
+  E2eError
+};