@flowriki/agent 0.1.0-beta.47 → 0.1.0-beta.48

package/dist/chunk-7X54JYUL.js

@@ -0,0 +1,4103 @@
+#!/usr/bin/env node
+
+// ../engine-appium/dist/index.js
+import { spawn } from "child_process";
+import net from "net";
+import { execFile } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import { spawn as spawn2 } from "child_process";
+import fs3 from "fs";
+import os3 from "os";
+import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
+
+// ../test-model/dist/chunk-QDXJLOQJ.js
+import { z as z2 } from "zod";
+import { z } from "zod";
+var PLATFORMS = ["web", "android", "ios"];
+var MOBILE_PLATFORMS = ["android", "ios"];
+var isMobile = (p) => p === "android" || p === "ios";
+var MOBILE_STEP_TYPES = ["swipe", "longPress", "hideKeyboard", "launchApp", "terminateApp", "resetApp", "background", "rotate", "permission"];
+var WEB_ONLY_STEP_TYPES = ["hover", "rightclick", "dblclick", "closePage", "forward", "upload", "drag", "setRange"];
+function stepRefusedOn(type, platform) {
+  if (platform === "web") return MOBILE_STEP_TYPES.includes(type) ? `"${type}" is a phone step; this flow runs in a browser.` : null;
+  if (WEB_ONLY_STEP_TYPES.includes(type)) return `"${type}" has no meaning on a phone.`;
+  if (type === "back" && platform === "ios") return "iPhones have no back button \u2014 tap the app's own Back instead.";
+  return null;
+}
+var ProjectPlatformsSchema = z.object({
+  web: z.boolean().default(true),
+  android: z.boolean().default(false),
+  ios: z.boolean().default(false)
+}).strict();
+var platformsOf = (config) => {
+  const parsed = ProjectPlatformsSchema.safeParse(config?.platforms ?? {});
+  return parsed.success ? parsed.data : { web: true, android: false, ios: false };
+};
+var BuildSchema = z.string().trim().max(2e3).refine(
+  (v) => /^https?:\/\//.test(v) || v.startsWith("/") || v.startsWith("~") || /^[A-Za-z]:[\\/]/.test(v),
+  "a build is a full path on the agent's computer, or an http(s) link"
+);
+var AndroidAppSchema = z.object({
+  /** The app's package, e.g. "com.shop.app" — how it is launched and reset. */
+  appPackage: z.string().trim().regex(/^[A-Za-z][\w]*(\.[A-Za-z][\w]*)+$/, "a package looks like com.company.app"),
+  /** The activity to start; absent means the app's launcher activity. */
+  appActivity: z.string().trim().max(300).optional(),
+  /** An .apk to install before a run; absent means it is already installed. */
+  build: BuildSchema.optional()
+}).strict();
+var IosAppSchema = z.object({
+  /** The app's bundle id, e.g. "com.shop.app". */
+  bundleId: z.string().trim().regex(/^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+$/, "a bundle id looks like com.company.app"),
+  /** An .ipa (real devices, cloud) or .app (simulators) to install; absent
+   *  means it is already installed. */
+  build: BuildSchema.optional(),
+  /** Real iPhones only: the Apple team that signs Appium's helper app. */
+  teamId: z.string().trim().regex(/^[A-Z0-9]{10}$/, "an Apple team id is 10 letters and digits").optional()
+}).strict();
+var CLOUD_PROVIDERS = ["browserstack", "saucelabs", "lambdatest"];
+var CLOUD_PROVIDER_NAME = { browserstack: "BrowserStack", saucelabs: "Sauce Labs", lambdatest: "LambdaTest" };
+var CloudAccountSchema = z.object({
+  provider: z.enum(CLOUD_PROVIDERS),
+  username: z.string().trim().min(1).max(200),
+  /** Sauce Labs data centre: "us-west-1", "eu-central-1", "us-east-4". */
+  region: z.string().trim().max(40).optional(),
+  keyRef: z.string().regex(/^[a-z][a-z0-9_]*$/)
+}).strict();
+var DeviceChoiceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("local"),
+    /** adb serial, AVD name, simulator or device UDID. */
+    id: z.string().min(1).max(200),
+    name: z.string().max(200).default("")
+  }).strict(),
+  z.object({
+    kind: z.literal("cloud"),
+    provider: z.enum(CLOUD_PROVIDERS),
+    /** The farm's device name, e.g. "Samsung Galaxy S23", "iPhone 15". */
+    device: z.string().min(1).max(200),
+    osVersion: z.string().max(40).optional()
+  }).strict()
+]);
+var MobileConfigSchema = z.object({
+  android: AndroidAppSchema.optional(),
+  ios: IosAppSchema.optional(),
+  /** Between runs: keep the app's data (stays signed in), or start clean. */
+  reset: z.enum(["keepData", "fresh"]).default("keepData"),
+  /** Where runs go when nobody says — absent means whatever is available. */
+  devices: z.object({ android: DeviceChoiceSchema.optional(), ios: DeviceChoiceSchema.optional() }).strict().default({}),
+  cloud: z.array(CloudAccountSchema).max(3).default([])
+}).strict();
+var mobileOf = (config) => {
+  const parsed = MobileConfigSchema.safeParse(config?.mobile ?? {});
+  return parsed.success ? parsed.data : MobileConfigSchema.parse({});
+};
+var DeviceInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  platform: z.enum(MOBILE_PLATFORMS),
+  kind: z.enum(["emulator", "simulator", "device"]),
+  /** Booted and reachable now, or one that can be started. */
+  state: z.enum(["ready", "off", "unauthorized", "offline"]),
+  osVersion: z.string().default("")
+}).strict();
+function pickDevice(devices, platform, chosen) {
+  if (chosen) return chosen;
+  const mine = devices.filter((d) => d.platform === platform);
+  const rank = (d) => (d.state === "ready" ? 0 : d.state === "off" ? 2 : 9) + (d.kind === "device" ? 0 : 1);
+  const best = [...mine].filter((d) => d.state === "ready" || d.state === "off").sort((a, b) => rank(a) - rank(b))[0];
+  return best ? { kind: "local", id: best.id, name: best.name } : null;
+}
+var describeDevice = (choice) => !choice ? "no device" : choice.kind === "local" ? choice.name || choice.id : `${CLOUD_PROVIDER_NAME[choice.provider]}: ${choice.device}${choice.osVersion ? ` (${choice.osVersion})` : ""}`;
+var LocatorOverrideSchema = z2.object({
+  strategy: z2.enum(["css", "xpath", "id", "testId", "text", "label", "placeholder", "altText", "title"]),
+  value: z2.string()
+}).strict();
+var CaptureModeSchema = z2.enum(["off", "on-failure", "always"]);
+var ArtifactPolicySchema = z2.object({
+  /** Masked before the shutter opens — password fields are covered. */
+  screenshot: CaptureModeSchema.optional(),
+  /** NOT maskable. A video shows every character typed, so a flow holding a
+   * secret is skipped unless allowUnmaskedArtifacts says otherwise. */
+  video: CaptureModeSchema.optional(),
+  /** Also not maskable: a Playwright trace embeds DOM snapshots containing
+   * whatever was typed into the page. */
+  trace: CaptureModeSchema.optional(),
+  /** Cheap, small, and the first thing anyone asks for when a step fails for
+   * no visible reason. */
+  console: z2.boolean().optional(),
+  /** How many runs keep their artifacts. Video is megabytes per run, so an
+   * unbounded history fills a disk quietly. */
+  retainRuns: z2.number().int().positive().max(1e4).optional(),
+  /** Deliberate opt-out of the secret guard, for a project with nothing to
+   * protect. Off by default: leaking a password into a video that nobody
+   * thinks of as sensitive is not a mistake worth making by accident. */
+  allowUnmaskedArtifacts: z2.boolean().optional()
+}).strict();
+var ExecutionEnvironmentSchema = z2.object({
+  browser: z2.enum(["chromium", "firefox", "webkit"]).optional(),
+  viewport: z2.object({ width: z2.number().int().positive(), height: z2.number().int().positive() }).optional(),
+  locale: z2.string().optional(),
+  timezoneId: z2.string().optional(),
+  colorScheme: z2.enum(["light", "dark", "no-preference"]).optional(),
+  /** How long a single step may take to find its target and act. */
+  timeoutMs: z2.number().int().positive().max(3e5).optional(),
+  /** How long a page load or history traversal may take. Separate from the
+   * step timeout on purpose: "this page is slow to load" and "this element
+   * does not exist" are different problems, and one number for both made
+   * every real site fail during load rather than during the assertion. */
+  navigationTimeoutMs: z2.number().int().positive().max(3e5).optional(),
+  /** How long an assertion may wait for the state it expects. Usually shorter
+   * than a step — an outcome that has not appeared quickly usually is not
+   * coming — but slow back ends need it raised. */
+  assertionTimeoutMs: z2.number().int().positive().max(3e5).optional(),
+  openClosedShadowRoots: z2.boolean().optional(),
+  /** Let the browser window take the whole screen, and the page take the whole
+   *  window.
+   *
+   * Off by default, deliberately: a FIXED viewport is what makes a run
+   * reproducible, and a maximised window is whatever size the machine that ran
+   * it happened to have. But a recording done at 1280x720 inside a large
+   * display is a small box in the middle of an empty screen, which is a
+   * miserable way to drive an app — so this is offered, with the trade stated.
+   *
+   * Recorded ON the flow, like the rest of the environment, so a run always
+   * says which of the two it was. */
+  fullWindow: z2.boolean().optional()
+}).strict();
+var RecordedTargetSchema = z2.object({
+  role: z2.string(),
+  name: z2.string(),
+  scope: z2.string().optional(),
+  scopeRole: z2.string().optional(),
+  frame: z2.array(z2.string()).optional(),
+  pageId: z2.string().optional(),
+  nameFrom: z2.enum(["adjacent-label", "text"]).optional(),
+  /** SET BY A PERSON, and exclusive.
+   *
+   * Somebody opened the editor and said "find it this way instead", which is
+   * a decision about semantics that were wrong for this element. Falling back
+   * to those semantics would undo it, so this replaces resolution entirely.
+   *
+   * Steps recorded before `candidates` existed also carry the recorder's own
+   * pick here, and are treated the same way: nothing in the document says
+   * which of the two put it there, and guessing wrong in the other direction
+   * would change what somebody's test does. */
+  locator: LocatorOverrideSchema.optional(),
+  /** WHAT THE RECORDER SAW, best first — preferences, not assertions.
+   *
+   * One locator is one way to be wrong. A test id is removed, a placeholder
+   * is reworded, a wrapper is added, and a step that had exactly one way to
+   * find its element has none — although the field is sitting in plain sight
+   * and two other things about it are unchanged.
+   *
+   * Tried in order, and ONLY where the one before did not identify a single
+   * element. EXACTLY ONE MATCH WINS: a locator matching several is
+   * disqualified rather than obeyed, so choosing between two elements never
+   * happens — and where nothing identifies one, the run stops and names the
+   * ambiguity. A step that resolves by anything other than its first choice
+   * says so in the result: a repair nobody can see is a repair nobody can
+   * trust. */
+  candidates: z2.array(LocatorOverrideSchema).max(4).optional(),
+  nth: z2.number().int().nonnegative().optional()
+});
+var RecordedAssertionKindSchema = z2.enum([
+  // Proposed automatically from a page-signature diff. Heuristic shapes, not
+  // things a person picks by name.
+  "screen",
+  "message",
+  "fields_visible",
+  // Element state.
+  "visible",
+  "hidden",
+  "attached",
+  "enabled",
+  "editable",
+  "focused",
+  "checked",
+  // Element content.
+  "text",
+  "value",
+  "attribute",
+  "class",
+  // Collections.
+  "count",
+  // The page itself.
+  "url",
+  "title",
+  "heading"
+]);
+var AssertionOpSchema = z2.enum(["equals", "contains", "matches", "gt", "gte", "lt", "lte"]);
+var RecordedAssertionSchema = z2.object({
+  kind: RecordedAssertionKindSchema,
+  value: z2.union([z2.string(), z2.array(z2.string())]),
+  /** Defaults to "equals" when absent, so older flows keep their meaning. */
+  op: AssertionOpSchema.optional(),
+  /** Negates the whole assertion, which is what gives every reading a mirror
+   *  without doubling the catalogue. `visible` + `not` IS `hidden`. */
+  not: z2.boolean().optional(),
+  /** Which attribute, for kind "attribute". Ignored otherwise. */
+  attr: z2.string().optional(),
+  /** A failure records the check and lets the run carry on, instead of
+   *  stopping the flow. Chosen by whoever authored the assertion: some checks
+   *  are the point of the test and some are worth knowing about. */
+  soft: z2.boolean().optional(),
+  why: z2.string().optional(),
+  enabled: z2.boolean().optional(),
+  confidence: z2.enum(["low", "high"]).optional(),
+  target: RecordedTargetSchema.optional()
+}).strict();
+var PageSignatureSchema = z2.object({
+  url: z2.string(),
+  title: z2.string(),
+  heading: z2.string(),
+  alerts: z2.array(z2.string()),
+  fields: z2.array(z2.string()),
+  /** Every short piece of visible text on the page, each tagged with enough
+   * identity to tell two elements apart.
+   *
+   * The generic net beneath `alerts`, which only sees a message when the page
+   * announced itself with role=alert or a class we happened to guess — so a
+   * bare <div id="error">Your username is invalid!</div> was invisible to it.
+   *
+   * `key` exists because comparing bare strings is not enough: a page that
+   * quotes its own error message in body copy (a docs page, help text, an
+   * empty state) already contains that string before anything happens, so the
+   * real message appearing looked like nothing had changed. The key is used
+   * ONLY to diff two snapshots of the same page a moment apart — never to
+   * find an element, which stays role + accessible name. */
+  texts: z2.array(z2.object({ key: z2.string(), text: z2.string() })).default([])
+});
+var AssertionKindSchema = z2.enum(["screen", "message", "heading", "fields_visible"]);
+var AssertionSchema = z2.object({
+  id: z2.string(),
+  kind: AssertionKindSchema,
+  value: z2.union([z2.string(), z2.array(z2.string())]),
+  /** Human-readable reason it was proposed — shown next to the tick box. */
+  why: z2.string().optional(),
+  /** Present only on INFERRED proposals — ones derived from a text diff rather
+   * than from something the page stated about itself. They arrive unticked,
+   * because a guess that silently becomes a passing assertion is worse than no
+   * assertion: it makes the suite look green for a reason nobody chose. */
+  confidence: z2.literal("low").optional(),
+  /** Unticked assertions stay in the file as a record of what was offered. */
+  enabled: z2.boolean().default(true),
+  source: z2.enum(["proposed", "manual"]).default("proposed")
+});
+var AssertionProposalSchema = AssertionSchema.omit({ id: true, enabled: true, source: true });
+var FeatureSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  id: z2.string(),
+  /** Directory name. Stable even when the display name is edited. */
+  slug: z2.string(),
+  name: z2.string(),
+  description: z2.string().default(""),
+  /** Manual ordering in the UI; ties break by name. */
+  order: z2.number().int().default(0),
+  createdAt: z2.string(),
+  createdBy: z2.string().default("")
+});
+var SECRET_REF_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+var isSecretRefName = (value) => SECRET_REF_PATTERN.test(value);
+var ScrollPrerequisiteSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  container: RecordedTargetSchema.optional(),
+  legacySelector: z2.string().optional()
+}).strict();
+var DialogAnswerSchema = z2.object({
+  type: z2.enum(["alert", "confirm", "prompt", "beforeunload"]),
+  message: z2.string(),
+  accept: z2.boolean(),
+  promptText: z2.string().optional()
+}).strict();
+var RecordedStepSchema = RecordedTargetSchema.extend({
+  id: z2.string().min(1),
+  type: z2.enum(["fill", "select", "click", "dblclick", "rightclick", "drag", "check", "press", "hover", "upload", "scroll", "back", "forward", "navigate", "closePage", "unsupported", "setRange", "assert", "signIn", "signOut", "useActor", "resetActor", "capture", "useHelper", ...MOBILE_STEP_TYPES]),
+  scope: z2.string(),
+  value: z2.string(),
+  secret: z2.boolean(),
+  legacySelector: z2.string(),
+  proposals: z2.array(RecordedAssertionSchema),
+  values: z2.array(z2.string()).optional(),
+  to: RecordedTargetSchema.optional(),
+  manual: z2.boolean().optional(),
+  verified: z2.boolean().optional(),
+  /** Skip this step without deleting it.
+   *
+   * There is a real gap between "this step is wrong" and "this field is broken
+   * today". Deleting is the only way to express the second without this, which
+   * loses the step's identity, its assertions and its place in the order — and
+   * the person then has to re-record it once the field is fixed.
+   *
+   * Absent means enabled, so every flow recorded before this stays enabled
+   * without a migration. */
+  disabled: z2.boolean().optional(),
+  /** How long a single step may take to find its target and act. */
+  timeoutMs: z2.number().int().positive().max(3e5).optional(),
+  /** How long a page load or history traversal may take. Separate from the
+   * step timeout on purpose: "this page is slow to load" and "this element
+   * does not exist" are different problems, and one number for both made
+   * every real site fail during load rather than during the assertion. */
+  navigationTimeoutMs: z2.number().int().positive().max(3e5).optional(),
+  /** How long an assertion may wait for the state it expects. Usually shorter
+   * than a step — an outcome that has not appeared quickly usually is not
+   * coming — but slow back ends need it raised. */
+  assertionTimeoutMs: z2.number().int().positive().max(3e5).optional(),
+  // Popups are bound to the action that created them; subsequent steps use pageId.
+  opensPage: z2.string().optional(),
+  dialogs: z2.array(DialogAnswerSchema).optional(),
+  downloads: z2.array(z2.string()).optional(),
+  warning: z2.string().optional(),
+  scroll: ScrollPrerequisiteSchema.optional(),
+  /** The NAME of a secret held outside this document.
+   *
+   * Explicit, because `secret: true` with the reference living in `value` made
+   * a reference and a password the same shape. Nothing could then tell an
+   * unresolvable reference from a leaked literal, and the code that tried
+   * guessed from whether the local secret store happened to contain the key —
+   * so on a machine that had never held the secret, a perfectly good reference
+   * was "healed" into a password whose value was its own name.
+   *
+   * When this is set, `value` is empty and carries nothing: the secret is
+   * looked up by this name at run time, and a name that is not on this machine
+   * stays unresolved and is reported, never invented. */
+  secretRef: z2.string().regex(SECRET_REF_PATTERN).optional(),
+  /** WHICH PROCEDURE AND WHICH IDENTITY, for `signIn` and `signOut`.
+   *
+   * A reference, never an expansion: the sign-in's own steps are not copied
+   * in here. That is deliberate and is the one exception to a case holding
+   * editable copies — a login procedure is shared infrastructure, and
+   * duplicating it into forty tests recreates exactly the problem this
+   * feature exists to remove. */
+  auth: z2.object({
+    profileId: z2.string().min(1),
+    accountId: z2.string().optional(),
+    /** WHERE THIS SIGN-IN BEGINS — and it belongs here, not on the procedure.
+     *
+     * The same login serves both: taken to the login page when signing in is
+     * the first thing that happens, and performed from wherever the browser
+     * already is when a guest fills a basket and signs in at checkout. Asking
+     * the procedure meant choosing once, for every test that would ever use
+     * it. Absent means the procedure's own starting page. */
+    from: z2.enum(["loginPage", "here"]).optional()
+  }).strict().optional(),
+  /** Which participant this step belongs to, for `useActor`.
+   *
+   * Selecting an actor RESUMES its session; it does not sign in again. A step
+   * that named an actor and re-authenticated would make moving between two
+   * participants cost a login each time, which is the cost this removes. */
+  actorId: z2.string().optional(),
+  navigationBase: z2.enum(["page", "application"]).optional(),
+  capture: z2.object({ name: z2.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/), source: z2.enum(["text", "value", "url"]) }).strict().optional(),
+  /** WHICH HELPER, for `useHelper`: the email code, the authenticator, the
+   *  text, the API call — set up on the Helpers screen and referred to here by
+   *  id, never copied, so fixing a helper fixes every test using it.
+   *
+   *  `inputs` fills the helper's `{{names}}` and may itself use a value read
+   *  earlier in the run (`{{email}}`). What comes back is kept under `saveAs`
+   *  for later steps, exactly as a captured value is; `then: "open"` also
+   *  takes the browser to it, which is what a verification link is for. */
+  helper: z2.object({
+    helperId: z2.string(),
+    inputs: z2.record(z2.string(), z2.string()).default({}),
+    saveAs: z2.string().regex(/^([a-zA-Z][a-zA-Z0-9_]*)?$/),
+    then: z2.enum(["remember", "open"]).default("remember")
+  }).strict().optional()
+}).strict();
+var DraftStepSchema = RecordedStepSchema.extend({
+  role: z2.string().default(""),
+  name: z2.string().default(""),
+  scope: z2.string().default(""),
+  value: z2.string().default(""),
+  secret: z2.boolean().default(false),
+  legacySelector: z2.string().default(""),
+  proposals: z2.array(RecordedAssertionSchema).default([])
+});
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var ActorDefinitionSchema = z2.object({
+  id: z2.string().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/),
+  name: z2.string().min(1),
+  startSignedIn: z2.object({ profileId: z2.string().min(1), accountId: z2.string().optional() }).strict().optional()
+}).strict();
+var FlowSignInSchema = z2.object({
+  profileId: z2.string().min(1),
+  accountId: z2.string().optional(),
+  from: z2.enum(["loginPage", "here"]).optional()
+}).strict();
+var FlowPrerequisitesSchema = z2.array(z2.object({ flowId: z2.string().min(1) }).strict());
+var CURRENT_SCHEMA_VERSION = 5;
+var FlowDocumentSchema = z2.object({
+  schemaVersion: z2.literal(CURRENT_SCHEMA_VERSION),
+  id: z2.string().min(1),
+  featureId: z2.string().min(1),
+  name: z2.string().min(1),
+  slug: z2.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  /** Where this flow starts, when it is pinned to somewhere of its own.
+   *
+   * OPTIONAL, and normally absent. The origin belongs to the project, not to
+   * each flow: a flow that carries its own hard-codes an environment into a
+   * git-tracked file, and the POC proved how that ends — an ephemeral port,
+   * `http://127.0.0.1:65226/`, committed and unrunnable on any other machine.
+   * Absent means "the project's base URL", which is what a flow recorded today
+   * stores. Present is honoured, so every flow recorded before this keeps
+   * working exactly as it did. */
+  baseUrl: z2.string().url().optional(),
+  /** The route, resolved against whichever base URL applies. On a phone, a
+   *  deep link the app opens at — or empty, the app's own first screen. */
+  startPath: z2.string(),
+  /** WHERE IT RUNS: a browser, or the project's Android or iOS app. Absent
+   *  means web — every flow recorded before phones. Fixed when the flow is
+   *  made: a run on the other kind is refused before it starts, never found
+   *  out as a step that cannot find its button. */
+  platform: z2.enum(PLATFORMS).optional(),
+  recordedAt: z2.string(),
+  recordedBy: z2.string(),
+  updatedAt: z2.string(),
+  steps: z2.array(RecordedStepSchema),
+  environment: ExecutionEnvironmentSchema.optional(),
+  /** WHICH DEPLOYMENT THIS WAS RECORDED AGAINST, by name — "staging",
+   *  "production", whatever the project calls them.
+   *
+   *  A record of fact, not a constraint: the flow can still be run against any
+   *  environment, which is the point of naming them. What it answers is the
+   *  question somebody asks of a test that fails only in one place — "where
+   *  was this made?" — which was previously unanswerable, because the address
+   *  it used belonged to a setting that had since moved on.
+   *
+   *  Deliberately NOT the address. An origin in a git-tracked file is the
+   *  mistake documented on `baseUrl` above; a name survives the deployment
+   *  moving. Absent on everything recorded before this, and on a project that
+   *  has never named its environments. */
+  recordedIn: z2.string().min(1).optional(),
+  path: z2.string().optional(),
+  actors: z2.array(ActorDefinitionSchema).optional(),
+  defaultActorId: z2.string().optional(),
+  /** SIGN IN FIRST: the account this flow starts as, before anything else runs.
+   *
+   * A setting rather than step one, which is what it used to be saved as. As a
+   * step it could not be switched off without deleting it, and a flow reused
+   * as somebody else's prerequisite could not tell "my own sign-in" from a
+   * sign-in that is part of what it tests. `parseFlowDocument` lifts an old
+   * step one into this field, so both spellings read the same. A reference to
+   * a profile, never a copy of its steps. */
+  signIn: FlowSignInSchema.optional(),
+  /** Flows replayed, in this order, after signing in and before this flow's
+   *  own steps — to reach the state it starts from.
+   *
+   *  LINKS, NOT COPIES: re-record "Save basic info" once and every flow that
+   *  starts after it follows. Each runs WITHOUT its own sign-in; this flow's
+   *  is the only one. Explicit and flat — nothing here pulls in a
+   *  prerequisite's prerequisites at run time, so what runs is exactly this
+   *  list. The editor fills those in when a flow is added. */
+  prerequisites: FlowPrerequisitesSchema.optional(),
+  /** Bumped on every save. An edit carries the revision it was made against,
+   *  so a save built on a stale copy is refused instead of overwriting work
+   *  somebody else — or a debug session on the same machine — has since done.
+   *  Documents written before this default to 0. */
+  revision: z2.number().int().nonnegative().default(0)
+}).strict().superRefine((flow, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  flow.steps.forEach((s, i) => {
+    if (ids.has(s.id)) ctx.addIssue({ code: "custom", path: ["steps", i, "id"], message: "Step IDs must be unique" });
+    ids.add(s.id);
+  });
+});
+var surfaceOf = (s) => JSON.stringify([s["pageId"] ?? "", s["frame"] ?? []]);
+var containerOf = (s) => JSON.stringify([targetOfStep(s), s["legacySelector"] ?? ""]);
+function targetOfStep(s) {
+  const t = { role: s["role"] ?? "", name: s["name"] ?? "", scope: s["scope"] ?? "" };
+  for (const key of ["scopeRole", "frame", "pageId", "nameFrom", "locator", "nth"]) {
+    if (s[key] !== void 0) t[key] = s[key];
+  }
+  return t;
+}
+function migrateScrollPrerequisites(doc) {
+  const steps = Array.isArray(doc.steps) ? doc.steps : [];
+  const out = [];
+  const pending = [];
+  const isScroll = (s) => s["type"] === "scroll" && s["scroll"] !== void 0 && s["scroll"] !== null;
+  const hasChecks = (s) => Array.isArray(s["proposals"]) && s["proposals"].length > 0;
+  const carry = (s) => {
+    const pos = s["scroll"] ?? {};
+    const prerequisite = { x: Number(pos.x ?? 0), y: Number(pos.y ?? 0), container: targetOfStep(s) };
+    if (typeof s["legacySelector"] === "string" && s["legacySelector"]) prerequisite["legacySelector"] = s["legacySelector"];
+    return prerequisite;
+  };
+  for (const step of steps) {
+    if (isScroll(step)) {
+      const previous = pending.at(-1);
+      const same = previous && !hasChecks(previous) && !hasChecks(step) && surfaceOf(previous) === surfaceOf(step) && containerOf(previous) === containerOf(step) && Boolean(previous["disabled"]) === Boolean(step["disabled"]);
+      if (same) pending[pending.length - 1] = step;
+      else pending.push(step);
+      continue;
+    }
+    const last = pending.at(-1);
+    if (last && !hasChecks(last) && !step["scroll"] && surfaceOf(last) === surfaceOf(step) && Boolean(last["disabled"]) === Boolean(step["disabled"])) {
+      step["scroll"] = carry(pending.pop());
+    }
+    for (const p of pending.splice(0)) out.push(p);
+    out.push(step);
+  }
+  for (const p of pending.splice(0)) out.push(p);
+  doc.steps = out;
+}
+function migrateRadioCheckedState(doc) {
+  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
+    if (step["type"] === "check" && step["role"] === "radio" && step["value"] === "") step["value"] = "true";
+  }
+}
+function migrateExplicitSecretRefs(doc) {
+  for (const step of Array.isArray(doc.steps) ? doc.steps : []) {
+    if (step["secret"] !== true) continue;
+    if (typeof step["secretRef"] === "string" && step["secretRef"]) continue;
+    const value = typeof step["value"] === "string" ? step["value"] : "";
+    if (value && isSecretRefName(value)) {
+      step["secretRef"] = value;
+      step["value"] = "";
+    }
+  }
+}
+function migrateBareModifierPresses(doc) {
+  const MODIFIERS = ["Meta", "Control", "Alt", "Shift"];
+  const invented = (step) => step["type"] === "press" && typeof step["value"] === "string" && MODIFIERS.some((m) => step["value"] === `${m}+${m}` || step["value"] === m);
+  doc.steps = (Array.isArray(doc.steps) ? doc.steps : []).filter((step) => !invented(step));
+}
+var MIGRATIONS = {
+  2: (doc) => {
+    migrateScrollPrerequisites(doc);
+    migrateRadioCheckedState(doc);
+  },
+  3: migrateExplicitSecretRefs,
+  4: migrateBareModifierPresses
+};
+function parseFlowDocument(input) {
+  const raw = structuredClone(input);
+  let version = typeof raw?.schemaVersion === "number" ? raw.schemaVersion : 2;
+  if (version > CURRENT_SCHEMA_VERSION) {
+    throw new Error(
+      `this flow was written by a newer version of Flowriki (schema ${version}, this build understands ${CURRENT_SCHEMA_VERSION}) \u2014 upgrade to open it`
+    );
+  }
+  while (version < CURRENT_SCHEMA_VERSION) {
+    const migrate = MIGRATIONS[version];
+    if (!migrate) throw new Error(`no migration path from schema version ${version}`);
+    migrate(raw);
+    version += 1;
+    raw.schemaVersion = version;
+  }
+  liftSignInFirst(raw);
+  if (Array.isArray(raw.steps)) raw.steps = mirrorCheckTargets(raw.steps);
+  return FlowDocumentSchema.parse(raw);
+}
+var SIGN_IN_FIRST_STEP_ID = "sign-in-first";
+function liftSignInFirst(raw) {
+  const first = raw.steps?.[0];
+  const auth = first?.auth;
+  if (!first || first.type !== "signIn" || first.disabled === true || first.actorId !== void 0) return;
+  if (!auth || typeof auth.profileId !== "string" || !auth.profileId) return;
+  if (raw["signIn"] !== void 0 || Array.isArray(raw["actors"]) && raw["actors"].length > 0) return;
+  raw["signIn"] = auth;
+  raw.steps = raw.steps.slice(1);
+}
+var CHECK_TARGET_FIELDS = [
+  "role",
+  "name",
+  "scope",
+  "scopeRole",
+  "frame",
+  "pageId",
+  "nameFrom",
+  "locator",
+  "candidates",
+  "nth"
+];
+var unset = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+function mirrorCheckTargets(steps) {
+  return steps.map((step) => {
+    const held = step;
+    if (held["type"] !== "assert") return step;
+    const proposals = held["proposals"];
+    if (!Array.isArray(proposals)) return step;
+    const first = proposals[0];
+    const target = first?.["target"];
+    if (!target) return step;
+    const fill = {};
+    for (const field of CHECK_TARGET_FIELDS) {
+      if (!unset(held[field]) || unset(target[field])) continue;
+      fill[field] = target[field];
+    }
+    return Object.keys(fill).length === 0 ? step : { ...held, ...fill };
+  });
+}
+
+// ../test-model/dist/index.js
+import { z as z3 } from "zod";
+import { z as z22 } from "zod";
+import { z as z32 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+var EngineSchema = z3.enum(["chromium", "firefox", "webkit", "android", "ios"]);
+var CapabilitySchema = z3.object({
+  id: z3.string(),
+  provider: z3.string().default("local"),
+  engine: EngineSchema,
+  /** Branded local builds: "chrome", "msedge". */
+  channel: z3.string().optional(),
+  browserVersion: z3.string().optional(),
+  os: z3.string().optional(),
+  osVersion: z3.string().optional(),
+  device: z3.string().optional(),
+  viewport: z3.object({ width: z3.number().int(), height: z3.number().int() }).optional()
+});
+var ExecutionConfigSchema = z3.object({
+  concurrency: z3.number().int().positive().default(4),
+  defaultBrowser: z3.string().default("chromium"),
+  retries: z3.number().int().nonnegative().default(0),
+  browsers: z3.record(z3.string(), CapabilitySchema.omit({ id: true }).partial({ provider: true })),
+  suites: z3.record(
+    z3.string(),
+    z3.object({
+      flows: z3.array(z3.string()).default([]),
+      browser: z3.string().optional(),
+      /** Opt-in cross-browser fan-out for this suite only. */
+      matrix: z3.array(z3.string()).optional()
+    })
+  ).default({})
+});
+var BUSINESS_KEYWORDS = ["Given", "When", "Then", "And", "But"];
+var BusinessStepSchema = z22.object({
+  keyword: z22.enum(BUSINESS_KEYWORDS),
+  text: z22.string().min(1).max(2e3)
+}).strict();
+var TestCaseOriginSchema = z22.object({
+  kind: z22.enum(["import", "assistant"]),
+  at: z22.string(),
+  by: z22.string().default(""),
+  /** The file it was imported from, and its row or id there. */
+  file: z22.string().max(300).optional(),
+  row: z22.string().max(200).optional()
+}).strict();
+var KEYWORD = /^\s*(given|when|then|and|but)\b[\s:]*(.*)$/i;
+var keywordOf = (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+function parseGherkin(text) {
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).filter((l) => !/^(scenario|scenario outline|feature|background|examples)\s*:/i.test(l) && !l.startsWith("|"));
+  if (!lines.length) return null;
+  const steps = [];
+  for (const line of lines) {
+    const m = KEYWORD.exec(line);
+    if (!m || !m[2].trim()) return null;
+    steps.push({ keyword: keywordOf(m[1]), text: m[2].trim() });
+  }
+  return steps;
+}
+var FlowOccurrenceSchema = z32.object({
+  /** This copy's own identity. Not the source flow's — a flow added twice is
+   *  two occurrences, and editing, breakpoints, results and deletion must be
+   *  able to tell them apart. */
+  occurrenceId: z32.string().min(1),
+  actorId: z32.string().optional(),
+  /** Editable, and initially the source flow's name. */
+  name: z32.string().min(1),
+  /** Where this copy starts, when it is told to navigate before running.
+   *  Absent means continue from wherever the previous row left the browser. */
+  startPath: z32.string().optional(),
+  baseUrl: z32.string().url().optional(),
+  /** GO SOMEWHERE FIRST, or carry on where the last row ended.
+   *
+   * SUPERSEDED BY `start`, and still read so that every case written before
+   * it keeps running unchanged. `startOf` answers for both shapes; nothing
+   * should consult this field directly.
+   *
+   * Off by default, because a case is a sequence in one browser: re-entering
+   * each flow's original starting URL would sign the tester out between rows
+   * and is exactly the behaviour composing flows is meant to avoid. */
+  navigateFirst: z32.boolean().default(false),
+  /** WHICH BROWSER THIS ROW RUNS IN.
+   *
+   * Two answers, because there are two: carry on in the browser this
+   * participant already has, or open them a new one. Where the page goes is a
+   * different question with its own field — folding them together produced a
+   * three-way choice in which two of the answers differed by something most
+   * people never set.
+   *
+   * A case is a sequence of flows performed by participants, and until now
+   * the only question a row could answer was whether to navigate. Whether it
+   * ran in the participant's EXISTING browser or a fresh one could not be
+   * said at all — it was implied (always the existing one) and could only be
+   * overridden by burying a `resetActor` step inside the flow.
+   *
+   *   continue — the participant's browser, exactly where they left it
+   *   navigate — the participant's browser, back at this flow's start path
+   *   fresh    — a new browser for them, signed in again if they start signed
+   *              in, then the start path
+   *
+   * A participant's FIRST row is always fresh in effect: there is nothing to
+   * continue from. That is not stored, because it is a fact about the order
+   * rather than about the row — moving the row changes the answer. */
+  start: z32.enum(["continue", "navigate", "fresh"]).optional(),
+  /** WHETHER THIS COPY DOES ITS OWN SIGNING IN.
+   *
+   * A flow recorded with "sign in before recording" keeps that sign-in as its
+   * first step, because that is how it readies ITSELF when it runs alone.
+   * Inside a case the identity belongs to the person, so the same step is
+   * usually a second answer to a question already answered.
+   *
+   *   skip — the person's account is the one used; this copy's own sign-ins
+   *          lie dormant, and the run confirms the session rather than
+   *          assuming it
+   *   run  — perform them anyway, whoever they name. Signing in as somebody
+   *          else on this person's browser is a real thing to want, and
+   *          before this there was no way to say it.
+   *
+   * ABSENT IS NOT "run". It is "nobody has said", which behaves as skip where
+   * the two agree on the account and is refused where they do not — so a case
+   * written before this keeps its meaning, and a contradiction stays a
+   * contradiction until somebody actually resolves it. */
+  ownSignIn: z32.enum(["skip", "run"]).optional(),
+  /** WHERE THIS ROW RUNS — copied from its flow. Absent is a browser; a
+   *  phone row runs on a device, and its `actorId` names that device. */
+  platform: z32.enum(PLATFORMS).optional(),
+  steps: z32.array(RecordedStepSchema),
+  environment: ExecutionEnvironmentSchema.optional(),
+  /** Where this copy came from, so the editor can say whether the source has
+   *  moved on — informational only, never a trigger to rewrite anything. */
+  origin: z32.object({
+    flowId: z32.string(),
+    /** The schema the source was written in, which may be older than today's. */
+    schemaVersion: z32.number().int().nonnegative(),
+    /** The source's own revision counter at the moment it was copied. */
+    revision: z32.number().int().nonnegative(),
+    /** The commit the copy was taken from, when one was known. */
+    commit: z32.string().optional(),
+    featureId: z32.string(),
+    /** Names as they were, so an old case still reads correctly after the
+     *  source is renamed, moved or deleted. */
+    featureName: z32.string(),
+    flowName: z32.string(),
+    /** Source step id → the id it was given here. Kept so a later comparison
+     *  against the source can line the two up; nothing depends on it to run. */
+    stepIds: z32.record(z32.string(), z32.string()).default({}),
+    copiedAt: z32.string()
+  }),
+  /** WHICH OF THIS ROW'S STEPS ARE WHAT RUNS BEFORE ITS FLOW — the flow's
+   *  sign-in and the prerequisites copied in with it — so the row can be shown
+   *  folded, the way the Flows screen shows the same flow.
+   *
+   *  A description of steps the row already holds, and nothing more: they are
+   *  ordinary copies in `steps` and run in order whatever this says. Kept by
+   *  id, so editing or deleting one of them leaves the rest still grouped.
+   *  Absent on every row copied before this existed, which simply show flat.
+   *  Never sent to a machine — see `withoutFolding`. */
+  before: z32.object({
+    /** The flow's own sign-in, when the copy brought one. */
+    signInStepId: z32.string().optional(),
+    flows: z32.array(z32.object({
+      flowId: z32.string(),
+      name: z32.string(),
+      stepIds: z32.array(z32.string())
+    }).strict()).default([])
+  }).strict().optional()
+}).strict();
+var CASE_SCHEMA_VERSION = 1;
+var TestCaseSchema = z32.object({
+  schemaVersion: z32.literal(CASE_SCHEMA_VERSION),
+  id: z32.string().min(1),
+  folderId: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
+  /** NO LONGER USED, and kept only so that a case written while they were
+   *  parses.
+   *
+   * These overrode the FIRST row's start path — whichever row that happened
+   * to be. A case is reordered by dragging, so the override silently moved to
+   * whatever was dragged to the top, carrying a path chosen for a different
+   * flow. Nothing said so, and the row it landed on looked like every other
+   * row. A positional override of a list people reorder is a setting that
+   * cannot stay correct.
+   *
+   * Every row now starts where its own flow says, which is the same answer
+   * whatever the order. */
+  startPath: z32.string().default("/"),
+  useStartPath: z32.boolean().default(false),
+  baseUrl: z32.string().url().optional(),
+  environment: ExecutionEnvironmentSchema.optional(),
+  actors: z32.array(ActorDefinitionSchema).optional(),
+  defaultActorId: z32.string().optional(),
+  occurrences: z32.array(FlowOccurrenceSchema).default([]),
+  /** WHAT IT CHECKS, IN WORDS: Given / When / Then. Written for a case that is
+   *  not automated yet — imported, or written by the assistant — and kept when
+   *  it is. Never sent to a machine — see `withoutFolding`. */
+  businessSteps: z32.array(BusinessStepSchema).optional(),
+  /** Where it came from, when not recorded here. */
+  origin: TestCaseOriginSchema.optional(),
+  /** WHEN ITS STEPS CHANGED AFTER IT WAS AUTOMATED: the automation may no
+   *  longer check what the words now say. Cleared when its flows are saved
+   *  again, or somebody confirms the automation still matches. */
+  stepsChangedAt: z32.string().optional(),
+  createdAt: z32.string(),
+  createdBy: z32.string().default(""),
+  updatedAt: z32.string(),
+  /** The same optimistic-concurrency counter a flow carries, so an edit made
+   *  against a stale copy is refused rather than overwriting. */
+  revision: z32.number().int().nonnegative().default(0)
+}).strict().superRefine((testCase, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  testCase.occurrences.forEach((occurrence, i) => {
+    if (seen.has(occurrence.occurrenceId)) {
+      ctx.addIssue({ code: "custom", path: ["occurrences", i, "occurrenceId"], message: "Occurrence IDs must be unique" });
+    }
+    seen.add(occurrence.occurrenceId);
+    const steps = /* @__PURE__ */ new Set();
+    occurrence.steps.forEach((step, s) => {
+      if (steps.has(step.id)) {
+        ctx.addIssue({ code: "custom", path: ["occurrences", i, "steps", s, "id"], message: "Step IDs must be unique within an occurrence" });
+      }
+      steps.add(step.id);
+    });
+  });
+}).transform((testCase) => {
+  const occurrences = testCase.occurrences.map((occurrence) => {
+    const steps = mirrorCheckTargets(occurrence.steps);
+    return steps.some((step, at) => step !== occurrence.steps[at]) ? { ...occurrence, steps } : occurrence;
+  });
+  if (occurrences.some((occurrence, at) => occurrence !== testCase.occurrences[at])) {
+    testCase = { ...testCase, occurrences };
+  }
+  if (!testCase.defaultActorId || testCase.defaultActorId === "default") return testCase;
+  if (testCase.actors?.some((actor) => actor.id === testCase.defaultActorId)) return testCase;
+  const { defaultActorId: _gone, ...rest } = testCase;
+  return rest;
+});
+var CaseFolderSchema = z32.object({
+  schemaVersion: z32.literal(1),
+  id: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
+  order: z32.number().int().default(0),
+  createdAt: z32.string(),
+  createdBy: z32.string().default("")
+}).strict();
+var SUITE_SCHEMA_VERSION = 1;
+var SuiteEntrySchema = z32.object({
+  entryId: z32.string().min(1),
+  kind: z32.enum(["flow", "testCase"]),
+  /** The document's ID — never its name or path, so renaming or moving what it
+   *  points at cannot break the reference. */
+  ref: z32.string().min(1),
+  enabled: z32.boolean().default(true),
+  order: z32.number().int().nonnegative(),
+  /** What it was called when it was added, so a result stays readable after the
+   *  source is renamed or deleted. */
+  nameSnapshot: z32.string().default("")
+}).strict();
+var SuiteSchema = z32.object({
+  schemaVersion: z32.literal(SUITE_SCHEMA_VERSION),
+  id: z32.string().min(1),
+  slug: z32.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z32.string().min(1),
+  description: z32.string().default(""),
+  entries: z32.array(SuiteEntrySchema).default([]),
+  defaults: z32.object({
+    headless: z32.boolean().optional(),
+    /** Carry on through the remaining entries, or stop at the first failure.
+     *  Continuing is the default: a suite is a list of independent things and
+     *  one failure rarely invalidates the rest. */
+    failurePolicy: z32.enum(["continue", "stop"]).default("continue")
+  }).default({ failurePolicy: "continue" }),
+  createdAt: z32.string(),
+  createdBy: z32.string().default(""),
+  updatedAt: z32.string(),
+  revision: z32.number().int().nonnegative().default(0)
+}).strict().superRefine((suite, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  suite.entries.forEach((entry, i) => {
+    if (seen.has(entry.entryId)) {
+      ctx.addIssue({ code: "custom", path: ["entries", i, "entryId"], message: "Entry IDs must be unique" });
+    }
+    seen.add(entry.entryId);
+  });
+});
+function startOf(occurrence) {
+  return occurrence.start === "fresh" ? "fresh" : "continue";
+}
+function navigatesFirst(occurrence) {
+  return occurrence.start === "navigate" || occurrence.navigateFirst;
+}
+function sessionLanes(occurrences, defaultActorId) {
+  const mine = /* @__PURE__ */ new Map();
+  const owner = /* @__PURE__ */ new Map();
+  const incarnations = /* @__PURE__ */ new Map();
+  const lanes = /* @__PURE__ */ new Map();
+  const last = /* @__PURE__ */ new Map();
+  const rows = [];
+  let previous = null;
+  const open = (actorId) => {
+    const next = (incarnations.get(actorId) ?? -1) + 1;
+    incarnations.set(actorId, next);
+    const sessionId = `${actorId}#${next}`;
+    mine.set(actorId, sessionId);
+    owner.set(sessionId, actorId);
+    if (!lanes.has(sessionId)) lanes.set(sessionId, lanes.size);
+    return sessionId;
+  };
+  for (const occurrence of occurrences) {
+    const person = occurrence.actorId || defaultActorId || "default";
+    const phone = occurrence.platform === "android" || occurrence.platform === "ios" ? occurrence.platform : void 0;
+    const actorId = phone ? `${phone}:${person}` : person;
+    const continues = startOf(occurrence) === "continue";
+    const asked = occurrence.start === "continue";
+    const theirs = mine.get(actorId);
+    const adoptable = !phone && previous !== null && owner.get(previous) === "default" && actorId !== "default";
+    let sessionId;
+    if (continues && theirs) sessionId = theirs;
+    else if (asked && adoptable) {
+      sessionId = previous;
+      owner.set(sessionId, actorId);
+      mine.set(actorId, sessionId);
+      mine.delete("default");
+    } else sessionId = open(actorId);
+    const continuesFrom = last.get(sessionId) ?? null;
+    rows.push({
+      occurrenceId: occurrence.occurrenceId,
+      actorId: person,
+      ...phone ? { phone } : {},
+      incarnation: Number(sessionId.split("#")[1]),
+      sessionId,
+      lane: lanes.get(sessionId),
+      continuesFrom,
+      opens: continuesFrom === null,
+      // WHETHER THERE IS A CHOICE TO MAKE. A row with nothing to continue —
+      // no browser of their own and no guest's to take over — is told so
+      // rather than offered an answer that cannot mean anything.
+      mayContinue: Boolean(theirs) || adoptable
+    });
+    last.set(sessionId, occurrence.occurrenceId);
+    previous = sessionId;
+  }
+  return rows;
+}
+function randomUUID() {
+  const crypto = globalThis.crypto;
+  if (crypto?.randomUUID) return crypto.randomUUID();
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2, 14)}`;
+}
+var mintPage = (remap, pageId) => {
+  if (pageId === "main") return "main";
+  const existing = remap.pages.get(pageId);
+  if (existing) return existing;
+  const fresh = `pg_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+  remap.pages.set(pageId, fresh);
+  return fresh;
+};
+function retarget(target, remap) {
+  if (!target.pageId) return target;
+  return { ...target, pageId: mintPage(remap, target.pageId) };
+}
+function copyStep(step, remap) {
+  const copied = retarget({ ...step, id: remap.steps.get(step.id) }, remap);
+  if (copied.opensPage) copied.opensPage = mintPage(remap, copied.opensPage);
+  if (copied.to) copied.to = retarget({ ...copied.to }, remap);
+  if (copied.scroll?.container) {
+    copied.scroll = { ...copied.scroll, container: retarget({ ...copied.scroll.container }, remap) };
+  }
+  copied.proposals = step.proposals.map((assertion) => ({ ...assertion }));
+  return copied;
+}
+function copyFlowIntoCase(flow, context) {
+  const remap = { steps: /* @__PURE__ */ new Map(), pages: /* @__PURE__ */ new Map() };
+  for (const step of flow.steps) {
+    remap.steps.set(step.id, `st_${randomUUID().replace(/-/g, "").slice(0, 12)}`);
+  }
+  const steps = flow.steps.map((step) => copyStep(step, remap));
+  return {
+    occurrenceId: `occ_${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+    name: flow.name,
+    // WHO RUNS THIS COPY. The flow said which of its participants it belongs
+    // to; dropping that here made every copy run as the main participant, so a
+    // flow recorded as the approver silently became the buyer doing approvals.
+    // The case has to be given the participant too — see `mergeParticipants`.
+    ...flow.defaultActorId && flow.defaultActorId !== "default" ? { actorId: flow.defaultActorId } : {},
+    ...flow.baseUrl ? { baseUrl: flow.baseUrl } : {},
+    // A phone flow stays a phone row: it runs on a device, not in a browser.
+    ...flow.platform && flow.platform !== "web" ? { platform: flow.platform } : {},
+    startPath: flow.startPath,
+    navigateFirst: false,
+    steps,
+    ...flow.environment ? { environment: flow.environment } : {},
+    origin: {
+      flowId: flow.id,
+      schemaVersion: flow.schemaVersion,
+      revision: flow.revision,
+      ...context.commit ? { commit: context.commit } : {},
+      featureId: flow.featureId,
+      featureName: context.featureName,
+      flowName: flow.name,
+      stepIds: Object.fromEntries(remap.steps),
+      copiedAt: (context.at ?? /* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function caseDebugPlan(testCase, baseUrl) {
+  const owners = {};
+  const steps = [];
+  const occurrences = testCase.occurrences;
+  for (const [index, item] of occurrences.entries()) {
+    if (testCase.actors?.length) {
+      const id = `case-actor:${encodeURIComponent(item.occurrenceId)}`;
+      owners[id] = { occurrenceId: item.occurrenceId, stepId: null };
+      steps.push({ id, type: "useActor", actorId: item.actorId ?? testCase.defaultActorId ?? "default", role: "", name: "Select participant", scope: "", value: "", secret: false, legacySelector: "", proposals: [] });
+    }
+    if (index > 0 && item.navigateFirst) {
+      const id = `case-nav:${encodeURIComponent(item.occurrenceId)}`;
+      owners[id] = { occurrenceId: item.occurrenceId, stepId: null };
+      steps.push({ id, type: "navigate", role: "", name: `Go to ${item.name}`, scope: "", value: new URL(item.startPath ?? "/", item.baseUrl ?? testCase.baseUrl ?? baseUrl).href, secret: false, legacySelector: "", proposals: [] });
+    }
+    for (const step of item.steps) {
+      const id = `case-step:${encodeURIComponent(item.occurrenceId)}:${encodeURIComponent(step.id)}`;
+      owners[id] = { occurrenceId: item.occurrenceId, stepId: step.id };
+      steps.push({ ...step, id });
+    }
+  }
+  const first = occurrences[0];
+  const flow = FlowDocumentSchema.parse({
+    schemaVersion: 5,
+    id: testCase.id,
+    featureId: testCase.folderId,
+    slug: testCase.slug,
+    name: testCase.name,
+    revision: testCase.revision,
+    recordedAt: testCase.createdAt,
+    recordedBy: testCase.createdBy,
+    updatedAt: testCase.updatedAt,
+    steps,
+    startPath: new URL(first?.startPath ?? "/", first?.baseUrl ?? testCase.baseUrl ?? baseUrl).href,
+    ...testCase.actors ? { actors: testCase.actors } : {},
+    ...testCase.defaultActorId ? { defaultActorId: testCase.defaultActorId } : {},
+    ...testCase.environment ? { environment: testCase.environment } : {}
+  });
+  return { flow, owners };
+}
+function restoreDebugCase(testCase, owners, steps) {
+  const occurrences = testCase.occurrences.map((item) => ({ ...item, steps: [] }));
+  const byId = new Map(occurrences.map((item) => [item.occurrenceId, item]));
+  let current = occurrences[0];
+  const present = new Set(steps.map((step) => step.id));
+  for (const [id, owner] of Object.entries(owners)) {
+    if (id.startsWith("case-nav:") && owner.stepId === null && !present.has(id)) byId.get(owner.occurrenceId).navigateFirst = false;
+  }
+  for (const step of steps) {
+    const owner = owners[step.id];
+    if (owner) current = byId.get(owner.occurrenceId);
+    if (!current) throw new Error("debug step has no case occurrence");
+    if (owner?.stepId === null) {
+      if (step.id.startsWith("case-actor:")) {
+        if (step.type !== "useActor") throw new Error("a participant boundary must remain a participant step");
+        current.actorId = step.actorId;
+        continue;
+      }
+      if (step.type !== "navigate") throw new Error("a case boundary must remain a navigation step");
+      current.startPath = step.value;
+      continue;
+    }
+    current.steps.push({ ...step, id: owner?.stepId ?? step.id });
+  }
+  return { ...testCase, occurrences };
+}
+var AuthNavigationSchema = z4.discriminatedUnion("kind", [
+  /** Act from wherever the browser already is — a "Log in" link in the header.
+   *  The only kind that is safe part-way through a journey. */
+  z4.object({ kind: z4.literal("continue") }),
+  /** Open the procedure's own starting page first. Right when signing in is
+   *  the first thing that happens; it abandons a journey in progress. */
+  z4.object({ kind: z4.literal("open"), path: z4.string().min(1) })
+]);
+var AuthFieldSchema = z4.object({
+  /** The step in the recorded procedure this value is typed into. Where a
+   *  recording types into the same box more than once, this is the FIRST of
+   *  them — the one an account's values are keyed by. */
+  stepId: z4.string().min(1),
+  /** EVERY step that types into this box, when there is more than one.
+   *
+   * A login typed twice — a first attempt with a typo, a page that re-rendered
+   * and was filled again — records two steps for one field, because keystrokes
+   * coalesce only with the step immediately before them. Asking an account for
+   * "Username" twice is the visible half of that; the dangerous half is that
+   * substituting only the first leaves the second typing whatever was
+   * recorded, so a run signs in as the person who made the recording.
+   *
+   * Empty means the one step in `stepId`, so every profile written before this
+   * reads correctly without being migrated. */
+  stepIds: z4.array(z4.string().min(1)).default([]),
+  /** What it is called where somebody fills it in — the field's own name on
+   *  the page, so an account form reads "Username" rather than "st_9f2a". */
+  label: z4.string().min(1),
+  /** A secret arrives as a reference and is never written into a document. */
+  secret: z4.boolean().default(false),
+  /** What the recording typed. Empty for a secret, whose value never travels.
+   *  Kept so the first account can be made from what was recorded, with
+   *  nothing to fill in. */
+  recorded: z4.string().default("")
+}).strict();
+var AUTH_PROFILE_SCHEMA_VERSION = 2;
+var AuthProfileSchema = z4.object({
+  schemaVersion: z4.literal(AUTH_PROFILE_SCHEMA_VERSION),
+  id: z4.string().min(1),
+  slug: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z4.string().min(1),
+  description: z4.string().default(""),
+  /** The recorded sign-in. A flow like any other, so it is edited, debugged
+   *  and replayed by everything that already knows how. */
+  flowId: z4.string().min(1),
+  /** Which of the values it types differ per identity. */
+  fields: z4.array(AuthFieldSchema).default([]),
+  /** Optional, and its own procedure with its own proof — most profiles will
+   *  not have one at first. The proof is read off that flow, the same way. */
+  signOutFlowId: z4.string().optional(),
+  /** Descriptive only — "admin", "staff". Never used to decide anything, so
+   *  two profiles may share a tag without becoming interchangeable. */
+  tags: z4.array(z4.string()).default([]),
+  createdAt: z4.string(),
+  createdBy: z4.string().default(""),
+  updatedAt: z4.string(),
+  revision: z4.number().int().nonnegative().default(0)
+}).strict();
+var ACCOUNT_BINDING_SCHEMA_VERSION = 3;
+var AccountBindingSchema = z4.object({
+  schemaVersion: z4.literal(ACCOUNT_BINDING_SCHEMA_VERSION),
+  id: z4.string().min(1),
+  slug: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z4.string().min(1),
+  profileId: z4.string().min(1),
+  /** Which environments of the APPLICATION UNDER TEST these credentials work
+   *  in — never Flowriki's own dev or staging.
+   *
+   * EMPTY MEANS EVERY ONE, which is what a project with a single deployment
+   * wants and what most accounts will always say.
+   *
+   * A LIST because the same person usually exists in more than one place. One
+   * environment per account was the shape until version 3, and it forced a
+   * duplicate account — same name, same password, same everything — for each
+   * deployment the identity existed in, or a blank "works anywhere" that also
+   * claimed environments it had never been created in. Neither was true. */
+  environments: z4.array(z4.string().min(1)).default([]),
+  /** Step id → what this identity types there. Ordinary values: a username is
+   *  not a credential, and keeping it here is what lets somebody read an
+   *  account and know who it is. */
+  values: z4.record(z4.string(), z4.string()).default({}),
+  /** Step id → secret REFERENCE. The value is sealed in the vault and never
+   *  enters the repository, whatever form it was typed into. */
+  secrets: z4.record(z4.string(), z4.string().regex(/^[a-z][a-z0-9_]*$/i)).default({}),
+  /** What this identity should look like once signed in — a displayed name, a
+   *  tenant. Not secret, and checked so that an already-authenticated browser
+   *  holding the WRONG account is reported rather than accepted. */
+  identity: z4.object({
+    label: z4.string().optional(),
+    tenant: z4.string().optional()
+  }).default({}),
+  createdAt: z4.string(),
+  createdBy: z4.string().default(""),
+  updatedAt: z4.string(),
+  revision: z4.number().int().nonnegative().default(0)
+}).strict();
+var AuthReferenceSchema = z4.object({
+  profileId: z4.string().min(1),
+  /** Where this use of it begins. See the step's own field. */
+  from: z4.enum(["loginPage", "here"]).optional(),
+  /** Absent means "the only account bound to this profile for the selected
+   *  environment", which is resolved before a browser opens and refused when
+   *  it is ambiguous — a silent choice between two identities is the failure
+   *  this field exists to prevent. */
+  accountId: z4.string().optional()
+}).strict();
+var ActorSchema = ActorDefinitionSchema;
+var DeliveredAuthSchema = z4.object({
+  profileId: z4.string().min(1),
+  accountId: z4.string().min(1),
+  name: z4.string(),
+  accountName: z4.string(),
+  steps: z4.array(RecordedStepSchema),
+  navigation: AuthNavigationSchema,
+  success: z4.array(RecordedAssertionSchema),
+  secretRefs: z4.record(z4.string(), z4.string()),
+  signOut: z4.object({ steps: z4.array(RecordedStepSchema), success: z4.array(RecordedAssertionSchema) }).optional()
+}).strict();
+function actorPreparations(actors = []) {
+  return actors.flatMap((actor) => actor.startSignedIn ? [{
+    id: `prepare:${actor.id}`,
+    type: "signIn",
+    auth: actor.startSignedIn,
+    name: `Prepare ${actor.name}`,
+    role: "",
+    scope: "",
+    value: "",
+    secret: false,
+    legacySelector: "",
+    proposals: []
+  }] : []);
+}
+function validateActors(actors = [], defaultId = "default", used = []) {
+  ActorSchema.array().parse(actors);
+  const ids = /* @__PURE__ */ new Set(["default"]);
+  for (const actor of actors) {
+    if (ids.has(actor.id)) throw new Error(`Duplicate or reserved actor: ${actor.id}`);
+    ids.add(actor.id);
+  }
+  for (const id of [defaultId, ...used]) {
+    if (id === UNSET_ACTOR) throw new Error("A step does not say who it is for \u2014 choose somebody before running");
+    if (id && !ids.has(id)) throw new Error(`This test names somebody it does not have (${id}) \u2014 choose who runs that row before running`);
+  }
+}
+var UNSET_ACTOR = "\0unset";
+function actorIdsUsed(steps) {
+  return steps.flatMap((step) => step.disabled ? [] : step.type === "useActor" ? [step.actorId ?? UNSET_ACTOR] : step.type === "resetActor" && step.actorId ? [step.actorId] : []);
+}
+function sameIdentity(a, b) {
+  if (a.profileId !== b.profileId) return false;
+  if (a.accountId && b.accountId) return a.accountId === b.accountId;
+  return true;
+}
+var PrerequisiteProblem = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PrerequisiteProblem";
+  }
+};
+function signInFirstStep(flow, id = SIGN_IN_FIRST_STEP_ID) {
+  if (!flow.signIn) return null;
+  return {
+    id,
+    type: "signIn",
+    auth: flow.signIn,
+    name: "Sign in first",
+    role: "",
+    scope: "",
+    value: "",
+    secret: false,
+    legacySelector: "",
+    proposals: []
+  };
+}
+function stepsWithoutSignIn(flow) {
+  const first = flow.steps[0];
+  return first && first.type === "signIn" && !first.disabled ? flow.steps.slice(1) : flow.steps;
+}
+var idsOf = (flow) => (flow.prerequisites ?? []).map((p) => p.flowId);
+function prerequisiteProblems(flow, lookup) {
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of idsOf(flow)) {
+    if (id === flow.id) {
+      problems.push(`"${flow.name}" cannot run before itself`);
+      continue;
+    }
+    if (seen.has(id)) {
+      problems.push(`"${lookup(id)?.name ?? id}" is listed twice before "${flow.name}"`);
+      continue;
+    }
+    seen.add(id);
+    const prerequisite = lookup(id);
+    if (!prerequisite) {
+      problems.push(`a flow "${flow.name}" runs after no longer exists \u2014 remove it from the list`);
+      continue;
+    }
+    if (reaches(prerequisite, flow.id, lookup, /* @__PURE__ */ new Set())) {
+      problems.push(`"${prerequisite.name}" already runs after "${flow.name}", so it cannot also run before it`);
+    }
+  }
+  return problems;
+}
+function reaches(from, target, lookup, visited) {
+  if (visited.has(from.id)) return false;
+  visited.add(from.id);
+  return idsOf(from).some((id) => {
+    if (id === target) return true;
+    const next = lookup(id);
+    return next ? reaches(next, target, lookup, visited) : false;
+  });
+}
+function prerequisitesOf(flow, lookup) {
+  const problems = prerequisiteProblems(flow, lookup);
+  if (problems.length > 0) throw new PrerequisiteProblem(problems.join("; "));
+  return idsOf(flow).map((id) => lookup(id));
+}
+function stepsForHost(prerequisite) {
+  return copyFlowIntoCase({ ...prerequisite, steps: stepsWithoutSignIn(prerequisite) }, { featureName: "" }).steps;
+}
+function preparationFor(flow, lookup) {
+  return {
+    signIn: signInFirstStep(flow),
+    steps: prerequisitesOf(flow, lookup).flatMap(stepsForHost)
+  };
+}
+function expandForRun(flow, lookup) {
+  const { signIn: _signIn, prerequisites: _prerequisites, ...rest } = flow;
+  if (!flow.signIn && idsOf(flow).length === 0) return rest;
+  const { signIn, steps } = preparationFor(flow, lookup);
+  return { ...rest, steps: [...signIn ? [signIn] : [], ...steps, ...flow.steps] };
+}
+var HELPER_SCHEMA_VERSION = 1;
+var SecretRef = z5.string().regex(/^[a-z][a-z0-9_]*$/i);
+var PatternSchema = z5.string().max(500).refine((source) => {
+  try {
+    new RegExp(source);
+    return true;
+  } catch {
+    return false;
+  }
+}, "that is not a valid pattern");
+var MailboxHelperSchema = z5.object({
+  kind: z5.literal("mailbox"),
+  /** IMAP, which every provider offers: Gmail, Outlook, Zoho, Fastmail… */
+  host: z5.string().min(1),
+  port: z5.number().int().positive().default(993),
+  secure: z5.boolean().default(true),
+  username: z5.string().min(1),
+  passwordRef: SecretRef,
+  folder: z5.string().min(1).default("INBOX"),
+  /** Which email. All optional; the newest that matches every one given. */
+  match: z5.object({
+    to: z5.string().default(""),
+    from: z5.string().default(""),
+    subject: z5.string().default("")
+  }).strict().default({}),
+  /** What to take out of it. */
+  extract: z5.object({
+    take: z5.enum(["code", "link", "subject", "body"]).default("code"),
+    /** For a code: the pattern, first group if it has one. Default: 4–8 digits.
+     *  For a link: only links containing this text. */
+    pattern: z5.string().max(500).default("")
+  }).strict().default({}),
+  /** How long to wait for the email to arrive. */
+  waitSeconds: z5.number().int().min(0).max(300).default(60)
+}).strict();
+var TotpHelperSchema = z5.object({
+  kind: z5.literal("totp"),
+  /** The authenticator secret (base32, from the QR code's "manual entry"). */
+  secretRef: SecretRef,
+  digits: z5.union([z5.literal(6), z5.literal(8)]).default(6),
+  period: z5.number().int().min(10).max(120).default(30),
+  algorithm: z5.enum(["SHA1", "SHA256", "SHA512"]).default("SHA1")
+}).strict();
+var SmsHelperSchema = z5.object({
+  kind: z5.literal("sms"),
+  provider: z5.literal("twilio").default("twilio"),
+  accountSid: z5.string().regex(/^AC[0-9a-f]{32}$/i, "a Twilio account SID starts with AC followed by 32 characters"),
+  authTokenRef: SecretRef,
+  /** The Twilio number the application texts. */
+  to: z5.string().min(3),
+  match: z5.object({
+    from: z5.string().default(""),
+    contains: z5.string().default("")
+  }).strict().default({}),
+  extract: z5.object({ pattern: z5.string().max(500).default("") }).strict().default({}),
+  waitSeconds: z5.number().int().min(0).max(300).default(60)
+}).strict();
+var HttpHelperSchema = z5.object({
+  kind: z5.literal("http"),
+  method: z5.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("POST"),
+  url: z5.string().min(1),
+  /** Plain headers, in the repository. */
+  headers: z5.record(z5.string(), z5.string()).default({}),
+  /** Header name → vault reference, for tokens and keys. */
+  secretHeaders: z5.record(z5.string(), SecretRef).default({}),
+  body: z5.string().max(2e4).default(""),
+  /** Refused unless the response has this status. 0 means any 2xx. */
+  expectStatus: z5.number().int().min(0).max(599).default(0),
+  extract: z5.object({
+    take: z5.enum(["json", "pattern", "status", "nothing"]).default("nothing"),
+    /** For json: a dot path — `data.order.id`, `items.0.code`. */
+    path: z5.string().max(300).default(""),
+    pattern: z5.string().max(500).default("")
+  }).strict().default({})
+}).strict();
+var HelperConfigSchema = z5.discriminatedUnion("kind", [
+  MailboxHelperSchema,
+  TotpHelperSchema,
+  SmsHelperSchema,
+  HttpHelperSchema
+]);
+var HelperSchema = z5.object({
+  schemaVersion: z5.literal(HELPER_SCHEMA_VERSION),
+  id: z5.string().min(1),
+  slug: z5.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  name: z5.string().min(1).max(120),
+  description: z5.string().max(1e3).default(""),
+  config: HelperConfigSchema,
+  createdAt: z5.string(),
+  createdBy: z5.string().default(""),
+  updatedAt: z5.string(),
+  revision: z5.number().int().nonnegative().default(0)
+}).strict().superRefine((helper, ctx) => {
+  const patterns = [
+    helper.config.kind === "mailbox" && helper.config.extract.take === "code" ? helper.config.extract.pattern : "",
+    helper.config.kind === "sms" ? helper.config.extract.pattern : "",
+    helper.config.kind === "http" && helper.config.extract.take === "pattern" ? helper.config.extract.pattern : ""
+  ];
+  for (const pattern of patterns) {
+    if (pattern && !PatternSchema.safeParse(pattern).success) {
+      ctx.addIssue({ code: "custom", path: ["config", "extract", "pattern"], message: "that is not a valid pattern" });
+    }
+  }
+});
+var DeliveredHelperSchema = z5.object({
+  id: z5.string().min(1),
+  name: z5.string(),
+  config: HelperConfigSchema
+}).strict();
+var LIBRARY_CASE_SCHEMA_VERSION = 1;
+var TEST_TYPES = ["functional", "negative", "edge", "regression", "smoke", "accessibility", "other"];
+var PRIORITIES = ["P0", "P1", "P2", "P3"];
+var CASE_STATUSES = ["draft", "ready", "deprecated"];
+var AUTOMATION_STATES = ["none", "planned", "automated", "not-automatable"];
+var LibraryStepSchema = z6.object({
+  id: z6.string().min(1),
+  action: z6.string().min(1),
+  /** What to type or choose, when the action needs it. */
+  data: z6.string().optional(),
+  /** What should happen. Absent for a step that only gets somewhere. */
+  expected: z6.string().optional()
+}).strict();
+var AutomationLinkSchema = z6.object({
+  automationId: z6.string().min(1),
+  caseRevision: z6.number().int().nonnegative(),
+  /** The automation's revision when the link was made or last confirmed —
+   *  an automation edited since may no longer check what the case says. */
+  automationRevision: z6.number().int().nonnegative().optional(),
+  at: z6.string(),
+  by: z6.string().default("")
+}).strict();
+var CaseOriginSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("manual") }).strict(),
+  z6.object({
+    kind: z6.literal("import"),
+    /** "csv", "xlsx", "testrail", "zephyr", "xray", "text"… */
+    format: z6.string().min(1),
+    file: z6.string().min(1),
+    /** Row or item in that file, to find it again. */
+    row: z6.string().optional()
+  }).strict(),
+  z6.object({
+    kind: z6.literal("generated"),
+    sourceId: z6.string().min(1),
+    sourceVersion: z6.number().int().positive(),
+    requirementIds: z6.array(z6.string().min(1)).default([])
+  }).strict()
+]);
+var TestDataSchema = z6.object({
+  name: z6.string().min(1),
+  value: z6.string().optional(),
+  secretRef: z6.string().regex(/^[a-z][a-z0-9_]*$/i).optional()
+}).strict();
+var LibraryCaseSchema = z6.object({
+  schemaVersion: z6.literal(LIBRARY_CASE_SCHEMA_VERSION),
+  id: z6.string().regex(/^tcs_[A-Za-z0-9]+$/),
+  /** "TC-142": what people say out loud. The id is what links point at. */
+  key: z6.string().regex(/^TC-[1-9][0-9]*$/),
+  /** The same features flows are filed under (`f_<slug>`), so one feature
+   *  holds both what to test and what tests it. */
+  featureId: z6.string().min(1),
+  slug: z6.string().regex(/^[a-z0-9][a-z0-9-]*$/),
+  title: z6.string().min(1).max(300),
+  description: z6.string().default(""),
+  type: z6.enum(TEST_TYPES).default("functional"),
+  priority: z6.enum(PRIORITIES).default("P2"),
+  status: z6.enum(CASE_STATUSES).default("draft"),
+  preconditions: z6.array(z6.string().min(1)).default([]),
+  steps: z6.array(LibraryStepSchema).default([]),
+  testData: z6.array(TestDataSchema).default([]),
+  tags: z6.array(z6.string().min(1)).default([]),
+  /** Requirement ids (Flowriki storage). The text is not copied here. */
+  covers: z6.array(z6.string().min(1)).default([]),
+  automation: z6.object({
+    state: z6.enum(AUTOMATION_STATES).default("none"),
+    /** Why it cannot be automated, when it cannot. */
+    reason: z6.string().optional(),
+    /** The plan for automating it: flows to reuse, flows to record, checks to
+     *  switch on, accounts and helpers it needs, and what cannot be automated.
+     *  Written (usually by the assistant) and approved before anything is
+     *  recorded. */
+    plan: z6.string().max(2e4).optional(),
+    planApproved: z6.boolean().optional(),
+    links: z6.array(AutomationLinkSchema).default([])
+  }).strict().default({}),
+  origin: CaseOriginSchema.default({ kind: "manual" }),
+  createdAt: z6.string(),
+  createdBy: z6.string().default(""),
+  updatedAt: z6.string(),
+  updatedBy: z6.string().default(""),
+  revision: z6.number().int().nonnegative().default(0)
+}).strict().superRefine((doc, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  doc.steps.forEach((step, i) => {
+    if (seen.has(step.id)) ctx.addIssue({ code: "custom", path: ["steps", i, "id"], message: "Step IDs must be unique" });
+    seen.add(step.id);
+  });
+  const linked = /* @__PURE__ */ new Set();
+  doc.automation.links.forEach((link, i) => {
+    if (linked.has(link.automationId)) {
+      ctx.addIssue({ code: "custom", path: ["automation", "links", i], message: "An automation is linked once" });
+    }
+    linked.add(link.automationId);
+  });
+  if (doc.automation.state === "not-automatable" && !doc.automation.reason?.trim()) {
+    ctx.addIssue({ code: "custom", path: ["automation", "reason"], message: "Say why it cannot be automated" });
+  }
+});
+var SOURCE_KINDS = ["upload", "jira", "figma", "confluence", "linear", "github-issue", "notion", "url"];
+var SourceVersionSchema = z6.object({
+  v: z6.number().int().positive(),
+  hash: z6.string().min(1),
+  extractedText: z6.string(),
+  /** Where an uploaded file WAS kept. Only text is kept since 2026-10-11;
+   *  read so older records still parse, and cleared at start-up. */
+  originalKey: z6.string().optional(),
+  mediaType: z6.string().optional(),
+  at: z6.string(),
+  by: z6.string().default("")
+}).strict();
+var SourceSchema = z6.object({
+  id: z6.string().regex(/^src_[A-Za-z0-9]+$/),
+  projectId: z6.string().min(1),
+  title: z6.string().min(1).max(300),
+  kind: z6.enum(SOURCE_KINDS),
+  versions: z6.array(SourceVersionSchema).min(1),
+  integrationId: z6.string().optional(),
+  externalId: z6.string().optional(),
+  externalUrl: z6.string().url().optional(),
+  createdAt: z6.string(),
+  createdBy: z6.string().default("")
+}).strict();
+var RequirementSchema = z6.object({
+  id: z6.string().regex(/^req_[A-Za-z0-9]+$/),
+  projectId: z6.string().min(1),
+  sourceId: z6.string().min(1),
+  sourceVersion: z6.number().int().positive(),
+  /** Where in the source: a heading path, a Jira key, a Figma node. */
+  anchor: z6.string().min(1),
+  text: z6.string().min(1),
+  featureId: z6.string().optional(),
+  /** As of the source's latest version: new in it, changed by it, unchanged
+   *  ("active"), or gone from it. */
+  state: z6.enum(["new", "active", "changed", "removed"]).default("new"),
+  history: z6.array(z6.object({
+    sourceVersion: z6.number().int().positive(),
+    text: z6.string(),
+    state: z6.enum(["new", "active", "changed", "removed"])
+  }).strict()).default([])
+}).strict();
+var MANUAL_OUTCOMES = ["untested", "passed", "failed", "blocked", "skipped"];
+var EvidenceSchema = z7.object({
+  id: z7.string().regex(/^ev_[A-Za-z0-9]+$/),
+  /** A file kept in Flowriki's evidence storage, or a link to one elsewhere. */
+  kind: z7.enum(["file", "link"]),
+  name: z7.string().min(1).max(200),
+  mediaType: z7.string().optional(),
+  size: z7.number().int().nonnegative().optional(),
+  url: z7.string().url().optional(),
+  /** The step it shows, when it belongs to one. */
+  stepId: z7.string().optional(),
+  at: z7.string(),
+  by: z7.string().default("")
+}).strict();
+var StepOutcomeSchema = z7.object({
+  stepId: z7.string().min(1),
+  outcome: z7.enum(MANUAL_OUTCOMES),
+  /** What actually happened, when it was not what was expected. */
+  actual: z7.string().max(4e3).optional()
+}).strict();
+var ManualResultSchema = z7.object({
+  outcome: z7.enum(MANUAL_OUTCOMES),
+  steps: z7.array(StepOutcomeSchema).default([]),
+  note: z7.string().max(8e3).default(""),
+  evidence: z7.array(EvidenceSchema).default([]),
+  bugIds: z7.array(z7.string().min(1)).default([]),
+  tester: z7.string().default(""),
+  at: z7.string()
+}).strict();
+var CycleEntrySchema = z7.object({
+  testCaseId: z7.string().min(1),
+  key: z7.string().min(1),
+  title: z7.string().min(1),
+  featureId: z7.string().min(1),
+  priority: z7.enum(PRIORITIES),
+  /** The case revision snapshot, so "the case changed since" is answerable. */
+  caseRevision: z7.number().int().nonnegative(),
+  preconditions: z7.array(z7.string()).default([]),
+  steps: z7.array(z7.object({ id: z7.string(), action: z7.string(), data: z7.string().optional(), expected: z7.string().optional() }).strict()).default([]),
+  assignee: z7.string().optional(),
+  result: ManualResultSchema.nullable().default(null),
+  /** Earlier results for this case in this cycle, newest last — a retest
+   *  keeps what the first attempt found. */
+  history: z7.array(ManualResultSchema).default([])
+}).strict();
+var TestCycleSchema = z7.object({
+  id: z7.string().regex(/^cyc_[A-Za-z0-9]+$/),
+  projectId: z7.string().min(1),
+  name: z7.string().min(1).max(200),
+  description: z7.string().max(4e3).default(""),
+  status: z7.enum(["open", "closed"]).default("open"),
+  /** Which branch the cases were read from; null for the published tests. */
+  changeId: z7.string().nullable().default(null),
+  entries: z7.array(CycleEntrySchema).default([]),
+  createdAt: z7.string(),
+  createdBy: z7.string().default(""),
+  updatedAt: z7.string(),
+  closedAt: z7.string().nullable().default(null)
+}).strict();
+var BUG_STATUSES = ["open", "in-progress", "fixed", "verified", "closed", "wont-fix"];
+var SEVERITIES = ["critical", "major", "minor", "trivial"];
+var BugSchema = z7.object({
+  id: z7.string().regex(/^bug_[A-Za-z0-9]+$/),
+  key: z7.string().regex(/^BUG-[1-9][0-9]*$/),
+  projectId: z7.string().min(1),
+  title: z7.string().min(1).max(300),
+  description: z7.string().max(2e4).default(""),
+  severity: z7.enum(SEVERITIES).default("major"),
+  status: z7.enum(BUG_STATUSES).default("open"),
+  tracker: z7.enum(["flowriki", "jira", "linear", "github"]).default("flowriki"),
+  externalKey: z7.string().optional(),
+  url: z7.string().url().optional(),
+  /** Where it was found: a case, the step in it, the cycle that ran it. */
+  testCaseIds: z7.array(z7.string()).default([]),
+  cycleIds: z7.array(z7.string()).default([]),
+  runIds: z7.array(z7.string()).default([]),
+  automationIds: z7.array(z7.string()).default([]),
+  foundAt: z7.object({ cycleId: z7.string(), testCaseId: z7.string(), stepId: z7.string().optional() }).strict().optional(),
+  createdAt: z7.string(),
+  createdBy: z7.string().default(""),
+  updatedAt: z7.string()
+}).strict();
+var STOP = new Set("a an the and or of to in on for with by is are be as at it this that from user users can should must shall will when then given".split(" "));
+var ConversationSchema = z8.object({
+  id: z8.string().regex(/^conv_[A-Za-z0-9]+$/),
+  projectId: z8.string().min(1),
+  /** Whose: conversations are personal. */
+  userId: z8.string().min(1),
+  title: z8.string().min(1).max(200),
+  mode: z8.enum(["ask", "do"]).default("ask"),
+  /** The assistant's own session, to continue where it left off. */
+  sessionId: z8.string().optional(),
+  /** The conversation as the dashboard draws it. Kept as given: the shape
+   *  belongs to the screen, and the service only stores and returns it. */
+  lines: z8.array(z8.unknown()).max(2e3).default([]),
+  createdAt: z8.string(),
+  updatedAt: z8.string()
+}).strict();
+var IMPORT_DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
+var ImportDraftCaseSchema = z9.object({
+  name: z9.string().min(1).max(120),
+  description: z9.string().max(4e3).default(""),
+  businessSteps: z9.array(BusinessStepSchema).max(200),
+  /** Its id or row in the file. */
+  row: z9.string().max(200).default("")
+}).strict();
+var ImportDraftSchema = z9.object({
+  id: z9.string().regex(/^imp_[A-Za-z0-9]+$/),
+  projectId: z9.string().min(1),
+  userId: z9.string().min(1),
+  file: z9.string().max(300),
+  /** Every sheet, every cell as text. */
+  sheets: z9.array(z9.object({ name: z9.string().max(200), rows: z9.array(z9.array(z9.string())) }).strict()).max(200),
+  status: z9.enum(["waiting", "converting", "done", "failed"]).default("waiting"),
+  /** What the assistant made of it: features, each with its cases. */
+  result: z9.array(z9.object({ feature: z9.string().min(1).max(120), cases: z9.array(ImportDraftCaseSchema) }).strict()).default([]),
+  /** The assistant's word on anything it could not convert. */
+  note: z9.string().max(4e3).default(""),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
+}).strict();
+var CaseUpdateRequestSchema = z9.object({
+  id: z9.string().regex(/^upd_[A-Za-z0-9]+$/),
+  projectId: z9.string().min(1),
+  userId: z9.string().min(1),
+  instruction: z9.string().min(1).max(4e3),
+  cases: z9.array(z9.object({
+    id: z9.string().min(1),
+    name: z9.string(),
+    feature: z9.string(),
+    businessSteps: z9.array(BusinessStepSchema)
+  }).strict()).min(1).max(500),
+  status: z9.enum(["waiting", "working", "done", "failed"]).default("waiting"),
+  proposals: z9.array(z9.object({
+    caseId: z9.string().min(1),
+    businessSteps: z9.array(BusinessStepSchema).max(200),
+    note: z9.string().max(2e3).default("")
+  }).strict()).default([]),
+  note: z9.string().max(4e3).default(""),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
+}).strict();
+
+// ../engine-appium/dist/index.js
+import path5 from "path";
+
+// ../core/dist/index.js
+function proposeAssertions(before, after) {
+  const out = [];
+  if (!before || !after) return out;
+  if (before.url !== after.url)
+    out.push({
+      kind: "screen",
+      value: after.heading || after.title,
+      why: "navigated to a new screen"
+    });
+  for (const a of after.alerts.filter((x) => !before.alerts.includes(x)))
+    out.push({ kind: "message", value: a, why: "a message appeared that was not there before" });
+  if (before.url === after.url && before.heading !== after.heading && after.heading)
+    out.push({ kind: "heading", value: after.heading, why: "the heading changed in place" });
+  const newFields = after.fields.filter((f) => !before.fields.includes(f));
+  if (newFields.length)
+    out.push({ kind: "fields_visible", value: newFields, why: "new fields became visible" });
+  if (before.url === after.url) {
+    const seenKeys = new Set(before.texts.map((t) => t.key));
+    const covered = /* @__PURE__ */ new Set([after.heading, ...after.alerts]);
+    const appeared = after.texts.filter((t) => !seenKeys.has(t.key) && !covered.has(t.text));
+    for (const t of appeared.slice(0, 2))
+      out.push({
+        kind: "message",
+        value: t.text,
+        why: "this text appeared after the action",
+        confidence: "low"
+      });
+  }
+  return out;
+}
+function hasObservableChange(before, after) {
+  return proposeAssertions(before, after).some((p) => p.confidence !== "low");
+}
+function isLocalHost(host) {
+  const h = host.toLowerCase();
+  return h === "localhost" || h.endsWith(".localhost") || h === "127.0.0.1" || h === "[::1]" || h === "0.0.0.0";
+}
+function hasScheme(raw) {
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)) return true;
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:(?!\d)/.test(raw);
+}
+function normalizeStartUrl(input) {
+  const raw = (input ?? "").trim();
+  if (!raw) throw new Error("enter a URL to record against");
+  let candidate;
+  if (hasScheme(raw)) {
+    candidate = raw;
+  } else {
+    const bare = raw.replace(/^\/+/, "");
+    const host = bare.split(/[/?#]/)[0] ?? "";
+    candidate = `${isLocalHost(host.split(":")[0] ?? "") ? "http" : "https"}://${bare}`;
+  }
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    throw new Error(`"${raw}" is not a valid URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`only http:// and https:// URLs can be recorded (got ${parsed.protocol}//)`);
+  }
+  if (!parsed.hostname) throw new Error(`"${raw}" has no host`);
+  return parsed.toString();
+}
+function resolveStartUrl(baseUrl, startPath) {
+  const base = normalizeStartUrl(baseUrl);
+  return new URL(startPath || "/", base).toString();
+}
+var INPUT_ROLES = /* @__PURE__ */ new Set(["textbox", "combobox", "checkbox", "radio", "spinbutton", "searchbox"]);
+var NAVIGATIONS = /* @__PURE__ */ new Set(["back", "forward"]);
+function planForOverride(o, overridden) {
+  if (o && o.value.trim()) {
+    const value = o.value.trim();
+    switch (o.strategy) {
+      // Playwright reads a leading `xpath=` prefix, and also bare paths that
+      // start with `/` or `//`. Normalising here means the QA can paste either.
+      case "xpath":
+        return { method: "locator", arg: value.startsWith("xpath=") ? value : `xpath=${value}`, overridden };
+      // Typed as a bare id, so nobody has to remember the `#`.
+      case "id":
+        return { method: "locator", arg: /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(value.replace(/^#/, "")) ? `#${value.replace(/^#/, "")}` : `[id=${JSON.stringify(value.replace(/^#/, ""))}]`, overridden };
+      case "css":
+        return { method: "locator", arg: value, overridden };
+      case "testId":
+        return { method: "getByTestId", arg: value, overridden };
+      case "text":
+        return { method: "getByText", arg: value, exact: true, overridden };
+      case "label":
+        return { method: "getByLabel", arg: value, exact: true, overridden };
+      case "placeholder":
+        return { method: "getByPlaceholder", arg: value, exact: true, overridden };
+      case "altText":
+        return { method: "getByAltText", arg: value, exact: true, overridden };
+      case "title":
+        return { method: "getByTitle", arg: value, exact: true, overridden };
+    }
+  }
+  return null;
+}
+function semanticPlan(step) {
+  if (NAVIGATIONS.has(step.type)) {
+    return { method: step.type === "back" ? "goBack" : "goForward", arg: "", overridden: false };
+  }
+  if (!step.name.trim()) return { method: "none", arg: "", overridden: false };
+  if (step.nameFrom === "adjacent-label") {
+    return {
+      method: "getByText",
+      arg: step.name,
+      exact: true,
+      overridden: false,
+      viaAdjacentLabel: true
+    };
+  }
+  if (step.nameFrom === "text") {
+    return {
+      method: "getByText",
+      arg: step.name,
+      exact: step.type !== "hover",
+      overridden: false,
+      visible: true
+    };
+  }
+  return INPUT_ROLES.has(step.role) ? { method: "getByLabel", arg: step.name, exact: true, overridden: false, inputRole: step.role } : step.role ? { method: "getByRole", arg: step.role, name: step.name, exact: true, overridden: false } : { method: "getByText", arg: step.name, exact: step.type !== "hover", overridden: false, visible: true };
+}
+function locatorPlans(step) {
+  const chosen = planForOverride(step.locator, true);
+  if (chosen) return [chosen];
+  const candidates = step.candidates ?? [];
+  const plans = [
+    ...candidates.filter((each) => each.strategy === "testId"),
+    ...candidates.filter((each) => each.strategy !== "testId")
+  ];
+  const first = plans.findIndex((each) => each.strategy !== "testId");
+  const before = first === -1 ? plans : plans.slice(0, first);
+  const after = first === -1 ? [] : plans.slice(first);
+  const semantic = semanticPlan(step);
+  const ordered = [
+    ...before.map((each) => planForOverride(each, false)),
+    // Below a test id and above everything else. A name is what somebody
+    // reading the test understands the step to be about, so a step that
+    // resolves by it is the step still meaning what it says.
+    semantic.method === "none" ? null : semantic,
+    ...after.map((each) => planForOverride(each, false))
+  ].filter((plan) => plan !== null);
+  return ordered.length ? ordered : [semantic];
+}
+var quote = (s) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+function locatorPlan(step) {
+  return locatorPlans(step)[0];
+}
+function describeLocators(step) {
+  return locatorPlans(step).map((plan) => describePlan(step, plan));
+}
+function describePlan(step, p) {
+  if (p.method === "none") return "(nothing to resolve \u2014 no accessible name)";
+  if (p.method === "goBack") return "page.goBack()";
+  if (p.method === "goForward") return "page.goForward()";
+  let root = "page";
+  for (const frame of step.frame ?? []) root += `.frameLocator(${quote(frameSelector(frame))})`;
+  if (!p.overridden && (step.scope || step.scopeRole)) root = scopeExpression(root, step.scope ?? "", step.scopeRole);
+  let base = p.viaAdjacentLabel ? `${root}.getByText(${adjacentLabelPattern(p.arg)}).locator('xpath=..').getByRole(${quote(step.role || "textbox")})` : p.method === "getByRole" ? `${root}.getByRole(${quote(p.arg)}, { name: ${quote(p.name ?? "")}, exact: true })` : `${root}.${p.method}(${quote(p.arg)}${p.exact !== void 0 ? `, { exact: ${p.exact} }` : ""})`;
+  if (p.inputRole) base = `${root}.getByRole(${quote(p.inputRole)}, { name: ${quote(p.arg)}, exact: true }).or(${base}.and(${root}.locator(${quote(inputSelector(p.inputRole))})))`;
+  if (p.visible) base += ".filter({ visible: true })";
+  if (step.nth !== void 0) base += `.nth(${step.nth})`;
+  if (step.pageId && step.pageId !== "main") base += `  // page ${quote(step.pageId)}`;
+  return base;
+}
+function adjacentLabelPattern(name) {
+  const bare = name.trim().replace(/\s*\*+$/, "");
+  return new RegExp(`^${bare.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&")}(\\s*\\*)?$`);
+}
+function frameSelector(name) {
+  const positional = /^nth:(\d+)$/.exec(name);
+  if (positional) return `iframe, frame >> nth=${positional[1]}`;
+  const v = JSON.stringify(name);
+  return `iframe[title=${v}], iframe[name=${v}], iframe[id=${v}], frame[title=${v}], frame[name=${v}], frame[id=${v}]`;
+}
+function inputSelector(role) {
+  return role === "textbox" ? 'input, textarea, [contenteditable="true"], [role="textbox"]' : `input, select, [role="${role}"]`;
+}
+var SCOPE_ROLES = ["form", "group", "region", "dialog", "alertdialog"];
+function scopeExpression(root, name, role) {
+  const parts = (role ? [role] : SCOPE_ROLES).map(
+    (r) => name ? `${root}.getByRole(${quote(r)}, { name: ${quote(name)}, exact: ${!role} })` : `${root}.getByRole(${quote(r)})`
+  );
+  return parts.reduce((a, b) => `${a}.or(${b})`);
+}
+var CHECKS = [
+  { id: "visible", label: "is visible", kind: "visible", group: "state" },
+  { id: "not-visible", label: "is not visible", kind: "visible", not: true, group: "state" },
+  { id: "attached", label: "exists on the page", kind: "attached", group: "state" },
+  { id: "not-attached", label: "does not exist", kind: "attached", not: true, group: "state" },
+  { id: "enabled", label: "is enabled", kind: "enabled", group: "state" },
+  { id: "disabled", label: "is disabled", kind: "enabled", not: true, group: "state" },
+  { id: "editable", label: "is editable", kind: "editable", group: "state" },
+  { id: "readonly", label: "is read-only", kind: "editable", not: true, group: "state" },
+  { id: "focused", label: "is focused", kind: "focused", group: "state" },
+  { id: "checked", label: "is checked", kind: "checked", value: "true", group: "state" },
+  { id: "unchecked", label: "is not checked", kind: "checked", value: "false", group: "state" },
+  { id: "text", label: "text is exactly", kind: "text", input: true, group: "text" },
+  { id: "text-contains", label: "text contains", kind: "text", op: "contains", input: true, group: "text" },
+  { id: "text-matches", label: "text matches pattern", kind: "text", op: "matches", input: true, group: "text" },
+  { id: "text-not", label: "text is not", kind: "text", not: true, input: true, group: "text" },
+  { id: "text-not-contains", label: "text does not contain", kind: "text", op: "contains", not: true, input: true, group: "text" },
+  { id: "value", label: "value is exactly", kind: "value", input: true, group: "value" },
+  { id: "value-contains", label: "value contains", kind: "value", op: "contains", input: true, group: "value" },
+  { id: "value-not", label: "value is not", kind: "value", not: true, input: true, group: "value" },
+  { id: "attr", label: "attribute is", kind: "attribute", input: true, attr: true, group: "attributes" },
+  { id: "attr-contains", label: "attribute contains", kind: "attribute", op: "contains", input: true, attr: true, group: "attributes" },
+  { id: "attr-not", label: "attribute is not", kind: "attribute", not: true, input: true, attr: true, group: "attributes" },
+  { id: "class", label: "has class", kind: "class", input: true, group: "attributes" },
+  { id: "not-class", label: "does not have class", kind: "class", not: true, input: true, group: "attributes" },
+  { id: "count", label: "how many \xB7 is exactly", kind: "count", input: true, roleOnly: true, group: "count" },
+  { id: "count-gte", label: "how many \xB7 is at least", kind: "count", op: "gte", input: true, roleOnly: true, group: "count" },
+  { id: "count-lte", label: "how many \xB7 is at most", kind: "count", op: "lte", input: true, roleOnly: true, group: "count" },
+  { id: "url", label: "page URL is", kind: "url", input: true, page: true, group: "page" },
+  { id: "url-contains", label: "page URL contains", kind: "url", op: "contains", input: true, page: true, group: "page" },
+  { id: "title", label: "page title is", kind: "title", input: true, page: true, group: "page" },
+  { id: "title-contains", label: "page title contains", kind: "title", op: "contains", input: true, page: true, group: "page" }
+];
+function matchCheck(a) {
+  const op = a.op ?? "equals";
+  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
+  return CHECKS.find(
+    (c) => c.kind === a.kind && (c.op ?? "equals") === op && Boolean(c.not) === Boolean(a.not) && // A fixed-value entry (is checked / is not checked) only matches its own
+    // value, or the two would be indistinguishable.
+    (c.value === void 0 || c.value === value)
+  );
+}
+var PROPOSED_LABELS = {
+  screen: (v) => `screen is \u201C${v}\u201D`,
+  heading: (v) => `heading is \u201C${v}\u201D`,
+  message: (v) => `message \u201C${v}\u201D is shown`,
+  fields_visible: (v) => `fields visible: ${v}`
+};
+function describeAssertion(a, subject) {
+  const value = Array.isArray(a.value) ? a.value.join(", ") : a.value;
+  const proposed = PROPOSED_LABELS[a.kind];
+  if (proposed && !a.target) return proposed(value);
+  const check = matchCheck(a);
+  const who = a.target?.name || subject || "";
+  if (!check) {
+    return `${a.kind}${a.op && a.op !== "equals" ? ` ${a.op}` : ""}${a.not ? " not" : ""}${value ? ` \u201C${value}\u201D` : ""}`;
+  }
+  const attr = check.attr && a.attr ? ` ${a.attr}` : "";
+  const expects = check.input ? ` \u201C${value}\u201D` : "";
+  if (check.page) return `${check.label}${expects}`;
+  if (check.roleOnly) {
+    const role = a.target?.role || "element";
+    return `${role}s \xB7 ${check.label.replace("how many \xB7 ", "")}${expects}`;
+  }
+  const label = check.label.replace("attribute", `attribute${attr}`);
+  return who ? `\u201C${who}\u201D ${label}${expects}` : `${label}${expects}`;
+}
+var NAME_FROM_CONTENT = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "heading",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "option",
+  "tab",
+  "treeitem",
+  "gridcell",
+  "switch",
+  "checkbox",
+  "radio"
+]);
+function identifiedByOwnWords(target) {
+  if (!target || target.locator || !target.name) return false;
+  return target.nameFrom === "text" || NAME_FROM_CONTENT.has(target.role ?? "");
+}
+function textIndependent(candidates) {
+  if (!candidates?.length) return void 0;
+  const order = ["testId", "css", "id", "title", "altText"];
+  for (const strategy of order) {
+    const found = candidates.find((each) => each.strategy === strategy && each.value.trim());
+    if (found) return found;
+  }
+  return void 0;
+}
+var STEP_PRESENTATION = {
+  fill: { label: "Fill", tone: "accent" },
+  select: { label: "Select", tone: "accent" },
+  // Click, press and the double/right variants share a tone: all of them
+  // commit the page and can produce an outcome.
+  click: { label: "Click", tone: "pass" },
+  press: { label: "Press", tone: "pass" },
+  dblclick: { label: "Double-click", tone: "pass" },
+  rightclick: { label: "Right-click", tone: "pass" },
+  check: { label: "Check", tone: "warn" },
+  hover: { label: "Hover", tone: "warn" },
+  drag: { label: "Drag", tone: "accent" },
+  upload: { label: "Upload", tone: "accent" },
+  scroll: { label: "Scroll", tone: "skip" },
+  setRange: { label: "Set", tone: "accent" },
+  // A check, not an action. "assert" is the schema's word; "Check" is the
+  // word the product uses everywhere a person reads it.
+  assert: { label: "Check", tone: "accent" },
+  back: { label: "Back", tone: "skip" },
+  forward: { label: "Forward", tone: "skip" },
+  navigate: { label: "Go to", tone: "skip" },
+  closePage: { label: "Close tab", tone: "skip" },
+  // Steps that act on the SESSION rather than on the page. Drawn apart from
+  // the actions on purpose: these are the rows that explain why a later step
+  // saw what it saw, and falling through to "Click" drew a sign-in as a mouse
+  // click on a button nobody could find in the recording.
+  signIn: { label: "Sign in", tone: "accent" },
+  signOut: { label: "Sign out", tone: "accent" },
+  useActor: { label: "Continue as", tone: "accent" },
+  resetActor: { label: "Start over as", tone: "skip" },
+  capture: { label: "Capture", tone: "warn" },
+  unsupported: { label: "Unsupported", tone: "warn" },
+  // On a phone. A tap is a `click`; these have no web equivalent.
+  swipe: { label: "Swipe", tone: "skip" },
+  longPress: { label: "Long press", tone: "pass" },
+  hideKeyboard: { label: "Hide keyboard", tone: "skip" },
+  launchApp: { label: "Open app", tone: "accent" },
+  terminateApp: { label: "Close app", tone: "skip" },
+  resetApp: { label: "Reset app", tone: "skip" },
+  background: { label: "Background", tone: "skip" },
+  rotate: { label: "Rotate", tone: "skip" },
+  permission: { label: "Permission", tone: "warn" }
+};
+
+// ../engine-appium/dist/index.js
+import path6 from "path";
+import fs5 from "fs";
+import path7 from "path";
+import { spawn as spawn3 } from "child_process";
+var WebDriverError = class extends Error {
+  constructor(message, error, status) {
+    super(message);
+    this.error = error;
+    this.status = status;
+  }
+  error;
+  status;
+};
+var ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecc";
+async function call(endpoint, method, path8, body, timeoutMs = 12e4) {
+  const headers = { "content-type": "application/json; charset=utf-8" };
+  if (endpoint.username) headers["authorization"] = `Basic ${Buffer.from(`${endpoint.username}:${endpoint.password ?? ""}`).toString("base64")}`;
+  const res = await fetch(`${endpoint.url.replace(/\/+$/, "")}${path8}`, {
+    method,
+    headers,
+    ...method === "POST" ? { body: JSON.stringify(body ?? {}) } : {},
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  const text = await res.text();
+  let json = {};
+  try {
+    json = text ? JSON.parse(text) : {};
+  } catch {
+  }
+  const value = json.value;
+  if (!res.ok || value && typeof value === "object" && typeof value.error === "string") {
+    const message = value?.message?.split("\n")[0] || text.slice(0, 300) || res.statusText;
+    throw new WebDriverError(message, value?.error ?? "unknown error", res.status);
+  }
+  return json.value;
+}
+var WebDriverSession = class _WebDriverSession {
+  constructor(endpoint, id, capabilities) {
+    this.endpoint = endpoint;
+    this.id = id;
+    this.capabilities = capabilities;
+  }
+  endpoint;
+  id;
+  capabilities;
+  static async create(endpoint, capabilities, timeoutMs = 6e5) {
+    const value = await call(
+      endpoint,
+      "POST",
+      "/session",
+      { capabilities: { alwaysMatch: capabilities, firstMatch: [{}] } },
+      timeoutMs
+    );
+    return new _WebDriverSession(endpoint, value.sessionId, value.capabilities ?? {});
+  }
+  /** Any other command — Appium's own extensions live under /appium/. */
+  raw(method, path8, body, timeoutMs) {
+    return this.req(method, path8, body, timeoutMs);
+  }
+  req(method, path8, body, timeoutMs) {
+    return call(this.endpoint, method, `/session/${this.id}${path8}`, body, timeoutMs);
+  }
+  source() {
+    return this.req("GET", "/source");
+  }
+  screenshot() {
+    return this.req("GET", "/screenshot");
+  }
+  windowRect() {
+    return this.req("GET", "/window/rect");
+  }
+  async find(using, value) {
+    const found = await this.req("POST", "/elements", { using, value });
+    return found.map((e) => e[ELEMENT_KEY] ?? Object.values(e)[0]).filter(Boolean);
+  }
+  click(element) {
+    return this.req("POST", `/element/${element}/click`);
+  }
+  clear(element) {
+    return this.req("POST", `/element/${element}/clear`);
+  }
+  type(element, text) {
+    return this.req("POST", `/element/${element}/value`, { text, value: [...text] });
+  }
+  text(element) {
+    return this.req("GET", `/element/${element}/text`);
+  }
+  execute(script, args = {}) {
+    return this.req("POST", "/execute/sync", { script, args: [args] });
+  }
+  back() {
+    return this.req("POST", "/back");
+  }
+  url(url) {
+    return this.req("POST", "/url", { url });
+  }
+  setOrientation(orientation) {
+    return this.req("POST", "/orientation", { orientation });
+  }
+  /** One finger, as a sequence of W3C pointer actions. */
+  touch(actions) {
+    return this.req("POST", "/actions", {
+      actions: [{ type: "pointer", id: "finger1", parameters: { pointerType: "touch" }, actions: actions.map((a) => ({ origin: "viewport", ...a, ...a.type === "pointerDown" || a.type === "pointerUp" ? { button: 0 } : {} })) }]
+    });
+  }
+  keys(text) {
+    return this.req("POST", "/actions", { actions: [{ type: "key", id: "keyboard", actions: [...text].flatMap((ch) => [{ type: "keyDown", value: ch }, { type: "keyUp", value: ch }]) }] });
+  }
+  async close() {
+    await this.req("DELETE", "", void 0, 3e4).catch(() => {
+    });
+  }
+};
+async function serverReady(endpoint) {
+  try {
+    await call(endpoint, "GET", "/status", void 0, 3e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AGENT_HOME = process.env["FLOWRIKI_HOME"] || path.join(os.homedir(), ".flowriki");
+var APPIUM_DIR = path.join(AGENT_HOME, "appium");
+var exists = (p) => Boolean(p && fs.existsSync(p));
+var exe = (name) => process.platform === "win32" ? `${name}.exe` : name;
+function androidHome() {
+  const candidates = [
+    process.env["ANDROID_HOME"],
+    process.env["ANDROID_SDK_ROOT"],
+    process.platform === "darwin" ? path.join(os.homedir(), "Library/Android/sdk") : null,
+    process.platform === "linux" ? path.join(os.homedir(), "Android/Sdk") : null,
+    process.platform === "win32" && process.env["LOCALAPPDATA"] ? path.join(process.env["LOCALAPPDATA"], "Android", "Sdk") : null
+  ];
+  return candidates.find((c) => exists(c) && exists(path.join(c, "platform-tools"))) ?? null;
+}
+function adbPath() {
+  const home = androidHome();
+  const inSdk = home ? path.join(home, "platform-tools", exe("adb")) : null;
+  return exists(inSdk) ? inSdk : onPath("adb");
+}
+function emulatorPath() {
+  const home = androidHome();
+  const inSdk = home ? path.join(home, "emulator", exe("emulator")) : null;
+  return exists(inSdk) ? inSdk : onPath("emulator");
+}
+function onPath(name) {
+  for (const dir of (process.env["PATH"] ?? "").split(path.delimiter)) {
+    for (const candidate of process.platform === "win32" ? [`${name}.exe`, `${name}.cmd`, name] : [name]) {
+      const full = path.join(dir, candidate);
+      if (exists(full)) return full;
+    }
+  }
+  return null;
+}
+function appiumPath() {
+  if (exists(process.env["FLOWRIKI_APPIUM"])) return { bin: process.env["FLOWRIKI_APPIUM"], home: process.env["APPIUM_HOME"] ?? null };
+  const own = path.join(APPIUM_DIR, "node_modules", ".bin", process.platform === "win32" ? "appium.cmd" : "appium");
+  if (exists(own)) return { bin: own, home: path.join(APPIUM_DIR, "home") };
+  const global = onPath("appium");
+  return global ? { bin: global, home: process.env["APPIUM_HOME"] ?? null } : null;
+}
+function javaMajor(home) {
+  try {
+    const release = fs.readFileSync(path.join(home, "release"), "utf8");
+    const v = /JAVA_VERSION="(\d+)(?:\.(\d+))?/.exec(release);
+    if (!v) return 0;
+    return v[1] === "1" ? Number(v[2] ?? 0) : Number(v[1]);
+  } catch {
+    return 0;
+  }
+}
+async function javaHome() {
+  const candidates = [];
+  if (process.env["JAVA_HOME"]) candidates.push(process.env["JAVA_HOME"]);
+  const onPathJava = onPath(exe("java"));
+  if (onPathJava) {
+    try {
+      candidates.push(path.dirname(path.dirname(fs.realpathSync(onPathJava))));
+    } catch {
+    }
+  }
+  if (process.platform === "darwin") candidates.push("/Applications/Android Studio.app/Contents/jbr/Contents/Home");
+  if (process.platform === "win32" && process.env["ProgramFiles"]) candidates.push(path.join(process.env["ProgramFiles"], "Android", "Android Studio", "jbr"));
+  if (process.platform === "linux") candidates.push(path.join(os.homedir(), "android-studio", "jbr"), "/opt/android-studio/jbr");
+  if (process.platform === "darwin" && exists("/usr/libexec/java_home")) {
+    const out = (await run("/usr/libexec/java_home", [], 5e3).catch(() => "")).trim();
+    if (out) candidates.push(out);
+  }
+  const homes = candidates.filter((c) => exists(c));
+  return homes.find((h) => javaMajor(h) >= 11) ?? homes[0] ?? null;
+}
+async function toolEnv() {
+  const env = { ...process.env };
+  const sdk = androidHome();
+  if (sdk) {
+    env["ANDROID_HOME"] = sdk;
+    env["ANDROID_SDK_ROOT"] = sdk;
+  }
+  const java = await javaHome();
+  if (java) env["JAVA_HOME"] = java;
+  const appium = appiumPath();
+  if (appium?.home) env["APPIUM_HOME"] = appium.home;
+  return env;
+}
+function run(file, args, timeoutMs = 2e4, env) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, { timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024, ...env ? { env } : {} }, (error, stdout, stderr) => {
+      if (error) reject(Object.assign(error, { stderr: String(stderr) }));
+      else resolve(String(stdout));
+    });
+  });
+}
+var running = null;
+var starting = null;
+var AppiumMissing = class extends Error {
+  constructor() {
+    super("Appium is not installed on this computer. Run `flowriki-agent mobile setup` once to install it.");
+  }
+};
+var freePort = () => new Promise((resolve, reject) => {
+  const server = net.createServer();
+  server.unref();
+  server.on("error", reject);
+  server.listen(0, "127.0.0.1", () => {
+    const { port } = server.address();
+    server.close(() => resolve(port));
+  });
+});
+async function appiumServer() {
+  if (running && running.child.exitCode === null) return running.endpoint;
+  if (starting) return starting;
+  starting = (async () => {
+    const appium = appiumPath();
+    if (!appium) throw new AppiumMissing();
+    const port = await freePort();
+    const env = await toolEnv();
+    const child = spawn(appium.bin, ["--address", "127.0.0.1", "--port", String(port), "--log-level", "warn", "--log-no-colors"], {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    const log = [];
+    const keep = (chunk) => {
+      log.push(...String(chunk).split("\n").filter(Boolean));
+      if (log.length > 400) log.splice(0, log.length - 400);
+    };
+    child.stdout?.on("data", keep);
+    child.stderr?.on("data", keep);
+    child.unref();
+    child.stdout?.unref?.();
+    child.stderr?.unref?.();
+    const endpoint = { url: `http://127.0.0.1:${port}` };
+    const deadline = Date.now() + 6e4;
+    while (Date.now() < deadline) {
+      if (child.exitCode !== null) throw new Error(`Appium stopped while starting: ${log.slice(-5).join(" ") || `exit ${child.exitCode}`}`);
+      if (await serverReady(endpoint)) {
+        running = { endpoint, child, log };
+        return endpoint;
+      }
+      await new Promise((r) => setTimeout(r, 400));
+    }
+    child.kill();
+    throw new Error("Appium did not start within a minute.");
+  })().finally(() => {
+    starting = null;
+  });
+  return starting;
+}
+var appiumLog = () => running?.log.slice(-20) ?? [];
+function stopAppium() {
+  running?.child.kill();
+  running = null;
+}
+process.once("exit", stopAppium);
+async function androidDevices() {
+  const adb = adbPath();
+  const out = [];
+  const runningAvds = /* @__PURE__ */ new Set();
+  if (adb) {
+    const listed = await run(adb, ["devices", "-l"], 1e4).catch(() => "");
+    for (const line of listed.split("\n").slice(1)) {
+      const m = /^(\S+)\s+(device|unauthorized|offline)\b(.*)$/.exec(line.trim());
+      if (!m) continue;
+      const [, serial, status, rest] = m;
+      const emulator2 = serial.startsWith("emulator-");
+      let name = /model:(\S+)/.exec(rest)?.[1]?.replace(/_/g, " ") ?? serial;
+      let osVersion = "";
+      if (status === "device") {
+        osVersion = (await run(adb, ["-s", serial, "shell", "getprop", "ro.build.version.release"], 8e3).catch(() => "")).trim();
+        if (emulator2) {
+          const avd = (await run(adb, ["-s", serial, "emu", "avd", "name"], 8e3).catch(() => "")).split("\n")[0]?.trim();
+          if (avd && avd !== "OK") {
+            runningAvds.add(avd);
+            name = avd.replace(/_/g, " ");
+          }
+        } else {
+          const model = (await run(adb, ["-s", serial, "shell", "getprop", "ro.product.model"], 8e3).catch(() => "")).trim();
+          if (model) name = model;
+        }
+      }
+      out.push({
+        id: serial,
+        name,
+        platform: "android",
+        kind: emulator2 ? "emulator" : "device",
+        state: status === "device" ? "ready" : status === "unauthorized" ? "unauthorized" : "offline",
+        osVersion
+      });
+    }
+  }
+  const emulator = emulatorPath();
+  if (emulator) {
+    const avds = await run(emulator, ["-list-avds"], 1e4, await toolEnv()).catch(() => "");
+    for (const avd of avds.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("INFO"))) {
+      if (runningAvds.has(avd)) continue;
+      out.push({ id: `avd:${avd}`, name: avd.replace(/_/g, " "), platform: "android", kind: "emulator", state: "off", osVersion: "" });
+    }
+  }
+  return out;
+}
+async function iosDevices() {
+  if (process.platform !== "darwin") return [];
+  const out = [];
+  const sims = await run("xcrun", ["simctl", "list", "devices", "available", "--json"], 15e3).catch(() => "");
+  try {
+    const parsed = JSON.parse(sims);
+    for (const [runtime, list] of Object.entries(parsed.devices)) {
+      const m = /SimRuntime\.iOS-(\d+)-(\d+)/.exec(runtime);
+      if (!m) continue;
+      for (const d of list) {
+        if (d.isAvailable === false) continue;
+        out.push({ id: d.udid, name: d.name, platform: "ios", kind: "simulator", state: d.state === "Booted" ? "ready" : "off", osVersion: `${m[1]}.${m[2]}` });
+      }
+    }
+  } catch {
+  }
+  const file = path2.join(os2.tmpdir(), `flowriki-devicectl-${process.pid}.json`);
+  await run("xcrun", ["devicectl", "list", "devices", "--json-output", file], 2e4).catch(() => "");
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+    for (const d of parsed.result?.devices ?? []) {
+      const udid = d.hardwareProperties?.udid;
+      if (!udid || d.hardwareProperties?.platform !== "iOS" || d.hardwareProperties?.reality !== "physical") continue;
+      const paired = d.connectionProperties?.pairingState === "paired";
+      const connected = d.connectionProperties?.tunnelState !== "unavailable";
+      out.push({
+        id: udid,
+        name: d.deviceProperties?.name ?? "iPhone",
+        platform: "ios",
+        kind: "device",
+        state: !paired ? "unauthorized" : connected ? "ready" : "offline",
+        osVersion: d.deviceProperties?.osVersionNumber ?? ""
+      });
+    }
+  } catch {
+  } finally {
+    fs2.rmSync(file, { force: true });
+  }
+  return out.sort((a, b) => (a.state === b.state ? 0 : a.state === "ready" ? -1 : 1) || b.osVersion.localeCompare(a.osVersion, void 0, { numeric: true }));
+}
+async function listDevices() {
+  const [android, ios] = await Promise.all([androidDevices(), iosDevices()]);
+  return [...android, ...ios];
+}
+async function bootDevice(device, timeoutMs = 18e4) {
+  if (device.state === "ready") return device.id;
+  if (device.state !== "off") throw new Error(`${device.name} is ${device.state === "unauthorized" ? "not trusted yet \u2014 unlock it and allow this computer" : "not reachable"}.`);
+  const deadline = Date.now() + timeoutMs;
+  if (device.platform === "ios") {
+    await run("xcrun", ["simctl", "boot", device.id], 12e4).catch((e) => {
+      if (!/current state: Booted/.test(e.stderr ?? "")) throw new Error(`Could not start ${device.name}: ${(e.stderr ?? "").trim().split("\n")[0]}`);
+    });
+    await run("xcrun", ["simctl", "bootstatus", device.id, "-b"], timeoutMs).catch(() => {
+    });
+    spawn2("open", ["-a", "Simulator", "--args", "-CurrentDeviceUDID", device.id], { detached: true, stdio: "ignore" }).unref();
+    return device.id;
+  }
+  const emulator = emulatorPath();
+  const adb = adbPath();
+  if (!emulator || !adb) throw new Error("The Android emulator is not installed \u2014 install Android Studio, or plug in a phone.");
+  const avd = device.id.replace(/^avd:/, "");
+  const before = new Set((await listDevices()).filter((d) => d.platform === "android" && d.state === "ready").map((d) => d.id));
+  spawn2(emulator, ["-avd", avd, "-no-snapshot-save"], { env: await toolEnv(), detached: true, stdio: "ignore" }).unref();
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    const listed = await run(adb, ["devices"], 1e4).catch(() => "");
+    for (const serial of listed.split("\n").map((l) => /^(emulator-\d+)\s+device/.exec(l.trim())?.[1]).filter((s) => Boolean(s))) {
+      if (before.has(serial)) continue;
+      const booted = (await run(adb, ["-s", serial, "shell", "getprop", "sys.boot_completed"], 8e3).catch(() => "")).trim();
+      if (booted === "1") return serial;
+    }
+  }
+  throw new Error(`${device.name} did not finish starting within ${Math.round(timeoutMs / 1e3)} seconds.`);
+}
+var CLOUD_HUBS = {
+  browserstack: () => "https://hub-cloud.browserstack.com/wd/hub",
+  saucelabs: (a) => `https://ondemand.${a.region || "us-west-1"}.saucelabs.com/wd/hub`,
+  lambdatest: () => "https://mobile-hub.lambdatest.com/wd/hub"
+};
+function appOf(target) {
+  if (target.platform === "android") {
+    const app2 = target.mobile.android;
+    if (!app2) throw new Error("This project has no Android app set up \u2014 add it in Settings \u2192 Mobile.");
+    return { id: app2.appPackage, ...app2.appActivity ? { activity: app2.appActivity } : {}, ...app2.build ? { build: app2.build } : {} };
+  }
+  const app = target.mobile.ios;
+  if (!app) throw new Error("This project has no iOS app set up \u2014 add it in Settings \u2192 Mobile.");
+  return { id: app.bundleId, ...app.build ? { build: app.build } : {} };
+}
+async function localBuild(build) {
+  if (!/^https?:\/\//.test(build)) {
+    const file2 = build.startsWith("~") ? path3.join(os3.homedir(), build.slice(1)) : build;
+    if (!fs3.existsSync(file2)) throw new Error(`The app build ${file2} is not on this computer.`);
+    return file2;
+  }
+  const res = await fetch(build, { signal: AbortSignal.timeout(6e5) });
+  if (!res.ok) throw new Error(`Could not download the app build (${res.status} ${res.statusText}).`);
+  const name = decodeURIComponent(new URL(build).pathname.split("/").pop() || "app") || "app";
+  const file = path3.join(fs3.mkdtempSync(path3.join(os3.tmpdir(), "flowriki-build-")), name);
+  fs3.writeFileSync(file, Buffer.from(await res.arrayBuffer()));
+  return file;
+}
+async function localCapabilities(target, udid, opts = {}) {
+  const app = appOf(target);
+  const fresh = target.fresh || target.mobile.reset === "fresh";
+  const common = {
+    "appium:udid": udid,
+    "appium:newCommandTimeout": 600,
+    "appium:noReset": !fresh,
+    "appium:fullReset": false,
+    ...opts.buildFile ? { "appium:app": opts.buildFile } : {}
+  };
+  if (target.platform === "android") {
+    return {
+      platformName: "Android",
+      "appium:automationName": "UiAutomator2",
+      ...common,
+      "appium:appPackage": app.id,
+      ...app.activity ? { "appium:appActivity": app.activity } : {},
+      "appium:appWaitActivity": "*",
+      "appium:autoGrantPermissions": false,
+      "appium:disableWindowAnimation": true,
+      "appium:uiautomator2ServerLaunchTimeout": 12e4,
+      "appium:adbExecTimeout": 6e4,
+      // Compose and some RecyclerViews hide nodes from the default dump.
+      "appium:settings[allowInvisibleElements]": false,
+      "appium:settings[ignoreUnimportantViews]": false
+    };
+  }
+  return {
+    platformName: "iOS",
+    "appium:automationName": "XCUITest",
+    ...common,
+    "appium:bundleId": app.id,
+    "appium:wdaLaunchTimeout": 24e4,
+    "appium:wdaConnectionTimeout": 24e4,
+    ...target.mobile.ios?.teamId ? { "appium:xcodeOrgId": target.mobile.ios.teamId, "appium:xcodeSigningId": "Apple Development" } : {}
+  };
+}
+function cloudCapabilities(target, account, key, appRef) {
+  if (target.device.kind !== "cloud") throw new Error("not a cloud device");
+  const app = appOf(target);
+  const device = target.device;
+  const android = target.platform === "android";
+  const base = {
+    platformName: android ? "Android" : "iOS",
+    "appium:automationName": android ? "UiAutomator2" : "XCUITest",
+    "appium:deviceName": device.device,
+    ...device.osVersion ? { "appium:platformVersion": device.osVersion } : {},
+    "appium:noReset": !(target.fresh || target.mobile.reset === "fresh"),
+    ...appRef ? { "appium:app": appRef } : android ? { "appium:appPackage": app.id, ...app.activity ? { "appium:appActivity": app.activity } : {} } : { "appium:bundleId": app.id }
+  };
+  const build = `Flowriki ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
+  const endpoint = { url: CLOUD_HUBS[account.provider](account), username: account.username, password: key };
+  if (account.provider === "browserstack") {
+    return { endpoint, capabilities: { ...base, "bstack:options": { userName: account.username, accessKey: key, projectName: "Flowriki", buildName: build, deviceName: device.device, ...device.osVersion ? { osVersion: device.osVersion } : {}, appiumVersion: "2.12.1" } } };
+  }
+  if (account.provider === "saucelabs") {
+    return { endpoint, capabilities: { ...base, "sauce:options": { username: account.username, accessKey: key, build, appiumVersion: "latest" } } };
+  }
+  return { endpoint, capabilities: { ...base, "lt:options": { username: account.username, accessKey: key, build, project: "Flowriki", isRealMobile: true, platformName: base["platformName"], deviceName: device.device, ...device.osVersion ? { platformVersion: device.osVersion } : {}, w3c: true } } };
+}
+async function uploadToCloud(account, key, file) {
+  const auth = `Basic ${Buffer.from(`${account.username}:${key}`).toString("base64")}`;
+  const form = new FormData();
+  form.append("file", new Blob([fs3.readFileSync(file)]), path3.basename(file));
+  const post = async (url, body, headers = {}) => {
+    const res = await fetch(url, { method: "POST", headers: { authorization: auth, ...headers }, body, signal: AbortSignal.timeout(9e5) });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`Uploading the app to ${account.provider} failed (${res.status}): ${text.slice(0, 200)}`);
+    return JSON.parse(text);
+  };
+  if (account.provider === "browserstack") {
+    const out2 = await post("https://api-cloud.browserstack.com/app-automate/upload", form);
+    return String(out2["app_url"]);
+  }
+  if (account.provider === "lambdatest") {
+    form.append("name", path3.basename(file));
+    const out2 = await post("https://manual-api.lambdatest.com/app/upload/realDevice", form);
+    return String(out2["app_url"]);
+  }
+  const region = account.region || "us-west-1";
+  const out = await post(`https://api.${region}.saucelabs.com/v1/storage/upload`, form);
+  return `storage:${out.item?.id}`;
+}
+async function cloudDevices(account, key) {
+  const auth = `Basic ${Buffer.from(`${account.username}:${key}`).toString("base64")}`;
+  const get = async (url) => {
+    const res = await fetch(url, { headers: { authorization: auth }, signal: AbortSignal.timeout(3e4) });
+    if (res.status === 401 || res.status === 403) throw new Error(`${account.provider} did not accept that user name and key.`);
+    if (!res.ok) throw new Error(`${account.provider} answered ${res.status}.`);
+    return res.json();
+  };
+  const platformOf = (os4) => /android/i.test(os4) ? "android" : /ios/i.test(os4) ? "ios" : null;
+  const out = [];
+  if (account.provider === "browserstack") {
+    for (const d of await get("https://api-cloud.browserstack.com/app-automate/devices.json")) {
+      const p = platformOf(d.os);
+      if (p) out.push({ name: d.device, platform: p, osVersion: d.os_version });
+    }
+  } else if (account.provider === "saucelabs") {
+    const region = account.region || "us-west-1";
+    for (const d of await get(`https://api.${region}.saucelabs.com/v1/rdc/devices`)) {
+      const p = platformOf(d.os);
+      if (p) out.push({ name: d.name, platform: p, osVersion: d.osVersion });
+    }
+  } else {
+    for (const os4 of ["android", "ios"]) {
+      const listed = await get(`https://mobile-api.lambdatest.com/mobile-automation/api/v1/list?region=us&os=${os4}`);
+      for (const [, devices] of Object.entries(listed)) {
+        if (!Array.isArray(devices)) continue;
+        for (const d of devices) out.push({ name: d.deviceName, platform: os4, osVersion: d.platformVersion });
+      }
+    }
+  }
+  return out;
+}
+var ENTITY = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+var decode = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => e[0] === "#" ? String.fromCodePoint(e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10)) : ENTITY[e] ?? m);
+function parseXml(xml) {
+  const root = { tag: "#root", attrs: {}, children: [] };
+  const stack = [root];
+  const tag = /<(\/?)([A-Za-z_][\w.:-]*)((?:\s+[\w:.-]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|<\?[\s\S]*?\?>|<!--[\s\S]*?-->/g;
+  const attr = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  for (let m = tag.exec(xml); m; m = tag.exec(xml)) {
+    if (!m[2]) continue;
+    if (m[1]) {
+      if (stack.length > 1) stack.pop();
+      continue;
+    }
+    const attrs = {};
+    for (let a = attr.exec(m[3] ?? ""); a; a = attr.exec(m[3] ?? "")) attrs[a[1]] = decode(a[2] ?? a[3] ?? "");
+    attr.lastIndex = 0;
+    const el = { tag: m[2], attrs, children: [] };
+    stack[stack.length - 1].children.push(el);
+    if (!m[4]) stack.push(el);
+  }
+  return root.children[0] ?? root;
+}
+var ANDROID_ROLES = [
+  [/EditText|AutoCompleteTextView|SearchView\$SearchAutoComplete/, "textbox"],
+  [/Switch/, "switch"],
+  [/ToggleButton/, "switch"],
+  [/RadioButton/, "radio"],
+  [/CheckBox|CheckedTextView/, "checkbox"],
+  [/ImageButton|FloatingActionButton|(^|\.)Button$|MaterialButton|Chip$/, "button"],
+  [/Spinner/, "combobox"],
+  [/SeekBar|Slider|RatingBar/, "slider"],
+  [/ProgressBar/, "progressbar"],
+  [/ImageView/, "image"],
+  [/TabWidget|TabLayout/, "tablist"],
+  [/TabView|TabLayout\$TabView/, "tab"],
+  [/Toolbar|ActionBar/, "toolbar"],
+  [/WebView/, "webview"],
+  [/RecyclerView|ListView|GridView|ScrollView|ViewPager/, "list"],
+  [/TextView/, "text"]
+];
+var IOS_ROLES = {
+  Button: "button",
+  TextField: "textbox",
+  SecureTextField: "textbox",
+  SearchField: "textbox",
+  TextView: "textbox",
+  Switch: "switch",
+  Toggle: "switch",
+  CheckBox: "checkbox",
+  StaticText: "text",
+  Image: "image",
+  Icon: "image",
+  Cell: "cell",
+  Link: "link",
+  Tab: "tab",
+  TabBar: "tablist",
+  SegmentedControl: "tablist",
+  Slider: "slider",
+  PickerWheel: "combobox",
+  Picker: "combobox",
+  DatePicker: "combobox",
+  NavigationBar: "navigation",
+  Toolbar: "toolbar",
+  Alert: "alertdialog",
+  Sheet: "dialog",
+  Table: "list",
+  CollectionView: "list",
+  ScrollView: "list",
+  ProgressIndicator: "progressbar",
+  ActivityIndicator: "progressbar",
+  WebView: "webview",
+  MenuItem: "menuitem",
+  RadioButton: "radio",
+  Keyboard: "keyboard",
+  Key: "key",
+  PageIndicator: "text"
+};
+var ROLE_CARRIERS = /* @__PURE__ */ new Set(["button", "checkbox", "switch", "radio"]);
+function androidRole(cls, a) {
+  for (const [re, role] of ANDROID_ROLES) if (re.test(cls)) return role;
+  if (a.checkable) return "checkbox";
+  if (a.clickable) return "button";
+  if (a.scrollable) return "list";
+  return "";
+}
+function iosRole(type) {
+  return IOS_ROLES[type.replace(/^XCUIElementType/, "")] ?? "";
+}
+var flag = (v) => v === "true";
+var parseBounds = (b) => {
+  const m = /\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]/.exec(b ?? "");
+  if (!m) return { x: 0, y: 0, width: 0, height: 0 };
+  const [x1, y1, x2, y2] = m.slice(1).map(Number);
+  return { x: x1, y: y1, width: Math.max(0, x2 - x1), height: Math.max(0, y2 - y1) };
+};
+var shortId = (id) => id.replace(/^[\w.]+:id\//, "");
+var clean = (s) => s.replace(/\s+/g, " ").trim();
+function readScreen(source, platform) {
+  const xml = parseXml(source);
+  const size = { width: Number(xml.attrs["width"]) || 0, height: Number(xml.attrs["height"]) || 0 };
+  let app = "";
+  const build = (el, parent, xpath) => {
+    const a = el.attrs;
+    let node;
+    if (platform === "android") {
+      const cls = a["class"] ?? el.tag;
+      if (!app && a["package"]) app = a["package"];
+      const clickable = flag(a["clickable"]) || flag(a["long-clickable"]);
+      const checkable = flag(a["checkable"]);
+      const scrollable = flag(a["scrollable"]);
+      const role = androidRole(cls, { clickable, checkable, scrollable });
+      const text = a["text"] ?? "";
+      const isField = role === "textbox";
+      const hint = a["hint"] ?? "";
+      node = {
+        role,
+        name: "",
+        value: isField && text !== hint ? text : "",
+        id: shortId(a["resource-id"] ?? ""),
+        label: a["content-desc"] ?? "",
+        text: isField ? "" : text,
+        hint,
+        bounds: parseBounds(a["bounds"]),
+        enabled: a["enabled"] !== "false",
+        checked: checkable || /Switch|CheckBox|RadioButton|ToggleButton/.test(cls) ? flag(a["checked"]) : null,
+        selected: flag(a["selected"]),
+        focused: flag(a["focused"]),
+        password: flag(a["password"]),
+        scrollable,
+        clickable,
+        xpath,
+        kind: cls,
+        children: [],
+        parent
+      };
+      if (a["displayed"] === "false") node.bounds = { x: 0, y: 0, width: 0, height: 0 };
+    } else {
+      const type = a["type"] ?? el.tag;
+      const role = iosRole(type);
+      const isField = role === "textbox";
+      const placeholder = a["placeholderValue"] ?? "";
+      const value = a["value"] ?? "";
+      if (!app && type === "XCUIElementTypeApplication") app = a["name"] ?? "";
+      node = {
+        role,
+        name: "",
+        value: isField && value !== placeholder ? value : role === "switch" || role === "checkbox" || role === "slider" ? value : "",
+        id: a["name"] && a["name"] !== a["label"] ? a["name"] : "",
+        label: a["label"] ?? "",
+        text: role === "text" ? a["label"] || value : "",
+        hint: placeholder,
+        bounds: { x: Number(a["x"]) || 0, y: Number(a["y"]) || 0, width: Number(a["width"]) || 0, height: Number(a["height"]) || 0 },
+        enabled: a["enabled"] !== "false",
+        checked: role === "switch" || role === "checkbox" ? value === "1" || value === "true" : null,
+        selected: flag(a["selected"]),
+        focused: flag(a["focused"]) || flag(a["hasFocus"]),
+        password: type === "XCUIElementTypeSecureTextField",
+        scrollable: role === "list",
+        clickable: role === "button" || role === "cell" || role === "link" || role === "tab",
+        xpath,
+        kind: type,
+        children: [],
+        parent
+      };
+      if (a["visible"] === "false") node.bounds = { x: 0, y: 0, width: 0, height: 0 };
+      if (type === "XCUIElementTypeApplication" || type === "XCUIElementTypeWindow") Object.assign(size, size.width ? {} : { width: node.bounds.width, height: node.bounds.height });
+    }
+    const seen = /* @__PURE__ */ new Map();
+    for (const child of el.children) {
+      const t = child.tag;
+      const n = (seen.get(t) ?? 0) + 1;
+      seen.set(t, n);
+      node.children.push(build(child, node, `${xpath}/${t}[${n}]`));
+    }
+    return node;
+  };
+  const top = build({ tag: xml.tag, attrs: {}, children: xml.children }, null, `/${xml.tag}`);
+  top.role = "";
+  const fold = (node) => {
+    node.children.forEach(fold);
+    if (platform === "android" && node.clickable && (node.role === "button" || node.role === "")) {
+      const carrier = node.children.find((c) => !c.clickable && ROLE_CARRIERS.has(c.role) && !c.text && !c.label && c.children.length === 0);
+      if (carrier) {
+        node.role = carrier.role;
+        if (carrier.checked !== null) node.checked = carrier.checked;
+        node.children = node.children.filter((c) => c !== carrier);
+      }
+    }
+  };
+  fold(top);
+  const nodes = [];
+  const visible = (n) => n.bounds.width > 0 && n.bounds.height > 0 && (!size.width || n.bounds.x < size.width && n.bounds.y < size.height && n.bounds.x + n.bounds.width > 0 && n.bounds.y + n.bounds.height > 0);
+  const descendantText = (n) => n.children.flatMap((c) => visible(c) && !c.clickable ? [c.label || c.text, ...c.label ? [] : descendantText(c)].filter(Boolean) : []);
+  const name = (n) => {
+    if (n.role === "textbox") return clean(n.label || descendantText(n).filter((t) => t !== n.value).join(" ") || n.hint || labelBefore(n) || n.id.replace(/[_-]+/g, " "));
+    const own = n.label || n.text;
+    if (own) return clean(own);
+    if (n.clickable || ROLE_CARRIERS.has(n.role) || n.role === "cell" || n.role === "tab") return clean(descendantText(n).join(" "));
+    return "";
+  };
+  const walk = (n) => {
+    n.name = name(n);
+    n.children.forEach(walk);
+  };
+  walk(top);
+  const collect = (n) => {
+    const emptyRow = n.role === "cell" && !n.name;
+    if (n.role && visible(n) && !absorbed(n) && !emptyRow) nodes.push(n);
+    n.children.forEach(collect);
+  };
+  collect(top);
+  return { platform, root: top, nodes, size, app, source };
+}
+function labelBefore(field) {
+  const siblings = field.parent?.children ?? [];
+  const at = siblings.indexOf(field);
+  for (let i = at - 1; i >= 0 && i >= at - 2; i--) {
+    const s = siblings[i];
+    if (s.role === "text" && s.text && s.bounds.y + s.bounds.height <= field.bounds.y + 4) return s.text;
+  }
+  return "";
+}
+var absorbed = (n) => {
+  for (let p = n.parent; p; p = p.parent) {
+    if (p.role && p.clickable && p.name && (n.role === "text" || n.role === "image") && !n.clickable) return true;
+    if (p.role && p.role !== "list") break;
+  }
+  return false;
+};
+var quote2 = (s) => JSON.stringify(s);
+function screenLines(screen, opts = {}) {
+  const out = [];
+  const visible = new Set(screen.nodes);
+  const emit = (n, depth) => {
+    let next = depth;
+    if (visible.has(n) && !(n.role === "text" && !n.name) && n.role !== "keyboard" && n.role !== "key") {
+      const states = [
+        !n.enabled && "disabled",
+        n.checked === true && "checked",
+        n.checked === false && n.role !== "button" && "unchecked",
+        n.selected && "selected",
+        n.focused && "focused",
+        n.password && "secret",
+        opts.ids !== false && n.id && `id=${n.id}`
+      ].filter(Boolean);
+      const value = n.role === "textbox" && n.value ? `: ${quote2(n.password ? "\u2022\u2022\u2022" : n.value)}` : "";
+      const tail = states.length ? ` [${states.join("] [")}]` : "";
+      const hasKids = n.role === "list" || n.role === "dialog" || n.role === "alertdialog" || n.role === "toolbar" || n.role === "navigation" || n.role === "tablist";
+      out.push(`${"  ".repeat(depth)}- ${n.role}${n.name ? ` ${quote2(n.name)}` : ""}${value}${tail}${n.scrollable ? " (scrolls)" : ""}${hasKids ? ":" : ""}`);
+      if (hasKids) next = depth + 1;
+      else if (n.clickable && n.name && n.role !== "textbox") return;
+    }
+    for (const c of n.children) emit(c, next);
+  };
+  emit(screen.root, 0);
+  return out.join("\n");
+}
+function nodeAt(screen, x, y) {
+  const inside = (n) => x >= n.bounds.x && y >= n.bounds.y && x <= n.bounds.x + n.bounds.width && y <= n.bounds.y + n.bounds.height;
+  const hits = screen.nodes.filter((n) => inside(n) && n.role !== "list");
+  hits.sort((a, b) => a.bounds.width * a.bounds.height - b.bounds.width * b.bounds.height || Number(b.clickable) - Number(a.clickable));
+  const best = hits[0] ?? null;
+  if (!best) return null;
+  for (let p = best.parent; p; p = p.parent) if (p.clickable && p.role && p.name && screen.nodes.includes(p)) return p;
+  return best;
+}
+var centre = (b) => ({ x: Math.round(b.x + b.width / 2), y: Math.round(b.y + b.height / 2) });
+var LocateError = class extends Error {
+  constructor(message, kind) {
+    super(message);
+    this.kind = kind;
+  }
+  kind;
+};
+var norm = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
+function matchStrategy(screen, strategy, value, role) {
+  const nodes = screen.nodes;
+  switch (strategy) {
+    case "role": {
+      const exact = nodes.filter((n) => n.role === role && n.name === value);
+      if (exact.length) return exact;
+      return nodes.filter((n) => n.role === role && norm(n.name) === norm(value));
+    }
+    case "testId":
+    case "id":
+      return nodes.filter((n) => n.id && (n.id === value || n.id === value.replace(/^[\w.]+:id\//, "")));
+    case "label":
+      return nodes.filter((n) => n.label === value || n.role === "textbox" && n.name === value);
+    case "text":
+      return nodes.filter((n) => n.text === value || n.clickable && n.name === value);
+    case "placeholder":
+      return nodes.filter((n) => n.hint === value);
+    case "title":
+    case "altText":
+      return nodes.filter((n) => n.label === value);
+    case "css":
+    case "xpath":
+      return [];
+  }
+}
+function within(screen, target) {
+  if (!target.scope && !target.scopeRole) return null;
+  const containers = screen.nodes.filter((n) => (target.scopeRole ? n.role === target.scopeRole : true) && (!target.scope || n.name === target.scope));
+  if (!containers.length) return [];
+  const inside = /* @__PURE__ */ new Set();
+  const add = (n) => {
+    inside.add(n);
+    n.children.forEach(add);
+  };
+  containers.forEach((c) => c.children.forEach(add));
+  return [...inside];
+}
+function resolveOn(screen, target) {
+  const scoped = within(screen, target);
+  const pool = scoped ? { ...screen, nodes: screen.nodes.filter((n) => scoped.includes(n)) } : screen;
+  const pick = (matches, how, first) => {
+    if (!matches.length) return null;
+    if (target.nth !== void 0) {
+      const node = matches[target.nth];
+      if (!node) return null;
+      return { node, screen, ...first ? {} : { foundBy: how } };
+    }
+    if (matches.length > 1) throw new LocateError(`${matches.length} elements match ${how} \u2014 say which one (nth) or choose a more specific name.`, "ambiguous");
+    return { node: matches[0], screen, ...first ? {} : { foundBy: how } };
+  };
+  if (target.locator) {
+    const found = pick(matchStrategy(pool, target.locator.strategy, target.locator.value), `${target.locator.strategy} "${target.locator.value}"`, true);
+    if (found) return found;
+    throw new LocateError(`Nothing on the screen has ${target.locator.strategy} "${target.locator.value}".`, "not_found");
+  }
+  const ways = [];
+  if (target.role && (target.name || target.nth !== void 0)) {
+    ways.push({ how: `${target.role} "${target.name}"`, matches: () => target.name ? matchStrategy(pool, "role", target.name, target.role) : pool.nodes.filter((n) => n.role === target.role && !n.name) });
+  }
+  for (const c of target.candidates ?? []) ways.push({ how: `${c.strategy} "${c.value}"`, matches: () => matchStrategy(pool, c.strategy, c.value) });
+  if (target.name) ways.push({ how: `anything named "${target.name}"`, matches: () => pool.nodes.filter((n) => n.name === target.name && n.clickable) });
+  let ambiguous = null;
+  for (const [i, way] of ways.entries()) {
+    try {
+      const found = pick(way.matches(), way.how, i === 0);
+      if (found) return found;
+    } catch (e) {
+      if (e instanceof LocateError && e.kind === "ambiguous") {
+        ambiguous ??= e;
+        continue;
+      }
+      throw e;
+    }
+  }
+  if (ambiguous) throw ambiguous;
+  throw new LocateError(`Nothing on the screen is ${describeTarget(target)}.`, "not_found");
+}
+var describeTarget = (t) => t.locator ? `${t.locator.strategy} "${t.locator.value}"` : `${t.role || "element"}${t.name ? ` "${t.name}"` : ""}${t.nth !== void 0 ? ` (number ${t.nth + 1})` : ""}`;
+async function locate(session, target, timeoutMs, opts = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  let scrolls = 0;
+  let lastSource = "";
+  let uncovered = false;
+  for (; ; ) {
+    const screen = await session.screen();
+    try {
+      return resolveOn(screen, target);
+    } catch (e) {
+      last = e;
+      if (e instanceof LocateError && e.kind === "ambiguous") throw e;
+    }
+    if (Date.now() > deadline) break;
+    if (!uncovered) {
+      uncovered = true;
+      if (await session.uncover()) continue;
+    }
+    const scroller = opts.scroll !== false && Date.now() > deadline - timeoutMs / 2 ? screen.nodes.filter((n) => n.scrollable).sort((a, b) => b.bounds.height * b.bounds.width - a.bounds.height * a.bounds.width)[0] : void 0;
+    if (scroller && scrolls < 8 && screen.source !== lastSource) {
+      lastSource = screen.source;
+      scrolls++;
+      await session.swipe("up", scroller.bounds, 0.6);
+    } else {
+      await new Promise((r) => setTimeout(r, 350));
+    }
+  }
+  throw last instanceof Error ? last : new LocateError(`Nothing on the screen is ${describeTarget(target)}.`, "not_found");
+}
+function targetFor(screen, node) {
+  const candidates = [];
+  if (node.id) candidates.push({ strategy: "testId", value: node.id });
+  if (node.label && node.label !== node.name) candidates.push({ strategy: "label", value: node.label });
+  if (node.text && node.text !== node.name) candidates.push({ strategy: "text", value: node.text });
+  if (node.hint && node.hint !== node.name) candidates.push({ strategy: "placeholder", value: node.hint });
+  const same = screen.nodes.filter((n) => n.role === node.role && n.name === node.name);
+  return {
+    role: node.role || "element",
+    name: node.name,
+    ...same.length > 1 ? { nth: same.indexOf(node) } : {},
+    ...node.name && !node.label && node.role !== "textbox" ? { nameFrom: "text" } : {},
+    ...candidates.length ? { candidates: candidates.slice(0, 4) } : {}
+  };
+}
+var CheckError = class extends Error {
+  constructor(message, kind) {
+    super(message);
+    this.kind = kind;
+  }
+  kind;
+};
+var STATE_KINDS = /* @__PURE__ */ new Set(["visible", "hidden", "attached", "enabled", "editable", "focused", "checked"]);
+var NEEDS_TARGET = /* @__PURE__ */ new Set(["count", "attribute", "class", "value", "text", ...STATE_KINDS]);
+var NOT_ON_A_PHONE = {
+  url: "A phone app has no web address \u2014 check something on the screen, or the screen name.",
+  title: "A phone app has no page title \u2014 check a heading or text on the screen instead.",
+  class: "A phone screen has no CSS classes \u2014 check text, state or an id instead."
+};
+function compare(actual, expected, op) {
+  switch (op) {
+    case "contains":
+      return actual.includes(expected);
+    case "matches":
+      return new RegExp(expected).test(actual);
+    case "gt":
+      return Number(actual) > Number(expected);
+    case "gte":
+      return Number(actual) >= Number(expected);
+    case "lt":
+      return Number(actual) < Number(expected);
+    case "lte":
+      return Number(actual) <= Number(expected);
+    default:
+      return actual === expected;
+  }
+}
+function textOf(node) {
+  const parts = [];
+  const walk = (n) => {
+    const own = n.text || (n.role === "text" ? n.label : "");
+    if (own) parts.push(own);
+    n.children.forEach(walk);
+  };
+  walk(node);
+  return (parts.join(" ") || node.name).replace(/\s+/g, " ").trim();
+}
+function state(node, kind) {
+  switch (kind) {
+    case "enabled":
+      return node.enabled;
+    case "editable":
+      return node.enabled && node.role === "textbox";
+    case "focused":
+      return node.focused;
+    case "checked":
+      return node.checked === true || node.checked === null && node.selected;
+    default:
+      return true;
+  }
+}
+function evaluate(screen, a, extra) {
+  const op = a.op ?? (a.kind === "message" ? "contains" : "equals");
+  const negated = a.not === true;
+  const expected = Array.isArray(a.value) ? a.value.join(", ") : String(a.value);
+  if (NOT_ON_A_PHONE[a.kind]) throw new CheckError(NOT_ON_A_PHONE[a.kind], "unknown");
+  if (NEEDS_TARGET.has(a.kind) && !a.target) throw new CheckError(`a ${a.kind} check needs an element`, "unknown");
+  const holds = (ok, detail) => {
+    if (ok !== negated) return detail;
+    throw new CheckError(negated ? `${detail} \u2014 expected it not to be` : detail, "assertion");
+  };
+  if (a.kind === "count") {
+    const t = a.target;
+    const n = screen.nodes.filter((x) => x.role === t.role && (!t.name || x.name === t.name)).length;
+    return holds(compare(String(n), expected, op), `${n} on screen`);
+  }
+  if (a.kind === "fields_visible") {
+    const missing = (Array.isArray(a.value) ? a.value : [a.value]).filter((name) => !screen.nodes.some((n) => n.role === "textbox" && n.name === name));
+    return holds(!missing.length, missing.length ? `not on screen: ${missing.join(", ")}` : "all on screen");
+  }
+  if (a.kind === "screen" && !a.target) {
+    if (extra.screenName && /^[.\w$]+$/.test(expected) && /[.$]|Activity|Screen/.test(expected)) {
+      return holds(compare(extra.screenName, expected, op === "equals" ? "contains" : op), `on ${extra.screenName}`);
+    }
+  }
+  if (!a.target) {
+    const all = screen.nodes.map((n) => n.text || n.label || n.name).filter(Boolean);
+    const found = all.some((t) => compare(t, expected, op === "equals" ? "equals" : op));
+    return holds(found, found ? `"${expected}" is on the screen` : `"${expected}" is not on the screen`);
+  }
+  let node = null;
+  try {
+    node = resolveOn(screen, a.target).node;
+  } catch (e) {
+    if (e instanceof LocateError && e.kind === "ambiguous") throw new CheckError(e.message, "ambiguous");
+    node = null;
+  }
+  const what = describeTarget(a.target);
+  if (a.kind === "visible" || a.kind === "hidden" || a.kind === "attached") {
+    const want = a.kind !== "hidden";
+    const present = node !== null;
+    return holds(present === want, present ? `${what} is on the screen` : `${what} is not on the screen`);
+  }
+  if (!node) throw new CheckError(`${what} is not on the screen`, "not_found");
+  if (STATE_KINDS.has(a.kind)) {
+    const want = expected !== "false";
+    const actual2 = state(node, a.kind);
+    return holds(actual2 === want, `${what} is ${actual2 ? "" : "not "}${a.kind}`);
+  }
+  if (a.kind === "value") {
+    const actual2 = node.value;
+    return holds(compare(actual2, expected, op), `${what} holds "${actual2}"`);
+  }
+  if (a.kind === "attribute") {
+    const attrs = { id: node.id, label: node.label, text: node.text, hint: node.hint, value: node.value, "content-desc": node.label, "resource-id": node.id };
+    const actual2 = attrs[a.attr ?? ""] ?? "";
+    return holds(compare(actual2, expected, op), `${a.attr} is "${actual2}"`);
+  }
+  const actual = textOf(node);
+  return holds(compare(actual, expected, op), `${what} says "${actual}"`);
+}
+async function checkMobileAssertion(session, a, timeoutMs = 3e3) {
+  const deadline = Date.now() + timeoutMs;
+  const screenName = a.kind === "screen" ? await session.currentScreenName() : "";
+  let last;
+  let uncovered = false;
+  for (; ; ) {
+    session.changed();
+    const screen = await session.screen();
+    try {
+      return evaluate(screen, a, { screenName });
+    } catch (e) {
+      last = e;
+      if (e instanceof CheckError && (e.kind === "unknown" || e.kind === "ambiguous")) throw e;
+    }
+    if (!uncovered) {
+      uncovered = true;
+      if (await session.uncover()) continue;
+    }
+    if (Date.now() > deadline) break;
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  throw last;
+}
+var uploaded = /* @__PURE__ */ new Map();
+var MobileSession = class _MobileSession {
+  constructor(driver, platform, appId, deviceName, cloud) {
+    this.driver = driver;
+    this.platform = platform;
+    this.appId = appId;
+    this.deviceName = deviceName;
+    this.cloud = cloud;
+  }
+  driver;
+  platform;
+  appId;
+  deviceName;
+  cloud;
+  cached = null;
+  static async open(target, opts = {}) {
+    const app = appOf(target);
+    const say = opts.onProgress ?? (() => {
+    });
+    if (target.device.kind === "cloud") {
+      const choice2 = target.device;
+      const account = target.mobile.cloud.find((c) => c.provider === choice2.provider);
+      if (!account) throw new Error(`${CLOUD_PROVIDER_NAME[choice2.provider]} is not connected \u2014 add it in Settings \u2192 Mobile.`);
+      const key = opts.resolveSecret?.(account.keyRef);
+      if (!key) throw new Error(`The ${CLOUD_PROVIDER_NAME[choice2.provider]} access key is not available to this run.`);
+      let appRef = null;
+      if (app.build) {
+        const cacheKey = `${account.provider}|${app.build}`;
+        appRef = uploaded.get(cacheKey) ?? null;
+        if (!appRef) {
+          say(`Uploading the app to ${CLOUD_PROVIDER_NAME[choice2.provider]}\u2026`);
+          appRef = await uploadToCloud(account, key, await localBuild(app.build));
+          uploaded.set(cacheKey, appRef);
+        }
+      }
+      say(`Opening ${choice2.device} on ${CLOUD_PROVIDER_NAME[choice2.provider]}\u2026`);
+      const { endpoint: endpoint2, capabilities: capabilities2 } = cloudCapabilities(target, account, key, appRef);
+      const driver2 = await WebDriverSession.create(endpoint2, capabilities2).catch((e) => {
+        throw new Error(`${CLOUD_PROVIDER_NAME[choice2.provider]} could not open ${choice2.device}: ${e.message}`);
+      });
+      const cloudSession = new _MobileSession(driver2, target.platform, app.id, choice2.device, true);
+      await cloudSession.settle(2e4);
+      return cloudSession;
+    }
+    const choice = target.device;
+    const devices = opts.devices ?? await listDevices();
+    const known = devices.find((d) => d.id === choice.id || d.id === `avd:${choice.id}` || choice.name && d.name === choice.name && d.platform === target.platform);
+    if (!known) throw new Error(`${choice.name || choice.id} is not connected to this computer.`);
+    if (known.platform !== target.platform) throw new Error(`${known.name} is ${known.platform === "ios" ? "an iOS" : "an Android"} device; this flow runs on ${target.platform === "ios" ? "iOS" : "Android"}.`);
+    if (known.state !== "ready") say(`Starting ${known.name}\u2026`);
+    const udid = await bootDevice(known);
+    const endpoint = await appiumServer();
+    const buildFile = app.build ? await localBuild(app.build) : null;
+    say(`Opening the app on ${known.name}\u2026`);
+    const capabilities = await localCapabilities(target, udid, { buildFile });
+    const driver = await WebDriverSession.create(endpoint, capabilities).catch((e) => {
+      const tail = appiumLog().filter((l) => /error/i.test(l)).slice(-2).join(" ");
+      throw new Error(explainStartFailure(e.message, target.platform) + (tail ? ` (${tail.slice(0, 300)})` : ""));
+    });
+    const session = new _MobileSession(driver, target.platform, app.id, known.name, false);
+    await session.terminateApp().catch(() => {
+    });
+    await session.launchApp().catch(() => {
+    });
+    return session;
+  }
+  // ── Reading ────────────────────────────────────────────────────────────
+  async screen() {
+    if (this.cached) return this.cached;
+    const source = await this.driver.source();
+    this.cached = readScreen(source, this.platform);
+    return this.cached;
+  }
+  /** Anything that changes the screen forgets the copy we had. */
+  changed() {
+    this.cached = null;
+  }
+  /** WAIT FOR THE SCREEN TO SETTLE: something on it, and the same twice in a
+   *  row — a splash screen or a screen still animating in has neither. */
+  async settle(timeoutMs = 15e3) {
+    const deadline = Date.now() + timeoutMs;
+    let last = "";
+    for (; ; ) {
+      this.changed();
+      const screen = await this.screen();
+      const loading = screen.nodes.some((n) => n.role === "progressbar") || screen.nodes.length > 0 && screen.nodes.every((n) => n.role === "text" && /^(loading|please wait|just a moment)\b/i.test(n.name));
+      if (screen.nodes.length > 0 && !loading && screen.source === last) return screen;
+      last = screen.source;
+      if (Date.now() > deadline) return screen;
+      await new Promise((r) => setTimeout(r, 400));
+    }
+  }
+  async screenshot(file) {
+    const png = Buffer.from(await this.driver.screenshot(), "base64");
+    if (file) {
+      fs4.mkdirSync(path4.dirname(file), { recursive: true });
+      fs4.writeFileSync(file, png);
+    }
+    return png;
+  }
+  /** Android: the activity on screen. iOS has none worth reading. */
+  async currentScreenName() {
+    if (this.platform !== "android") return "";
+    return this.driver.raw("GET", "/appium/device/current_activity").catch(() => "");
+  }
+  // ── Touching ───────────────────────────────────────────────────────────
+  async tapAt(x, y, holdMs = 60) {
+    this.changed();
+    await this.driver.touch([
+      { type: "pointerMove", x, y, duration: 0 },
+      { type: "pointerDown" },
+      { type: "pause", duration: holdMs },
+      { type: "pointerUp" }
+    ]);
+  }
+  async tap(node) {
+    await this.clearKeyboardFrom(node);
+    const { x, y } = centre(node.bounds);
+    await this.tapAt(x, y);
+  }
+  async longPress(node, ms = 1e3) {
+    await this.clearKeyboardFrom(node);
+    const { x, y } = centre(node.bounds);
+    await this.tapAt(x, y, Math.max(500, Math.min(ms, 1e4)));
+  }
+  /** A finger drawn across `area` (the screen when absent). "up" moves the
+   *  content up — what a person does to see what is further down. */
+  async swipe(direction, area, fraction = 0.6) {
+    const screen = await this.screen();
+    const box = area ?? { x: 0, y: 0, width: screen.size.width, height: screen.size.height };
+    const c = centre(box);
+    const dx = Math.round(box.width * fraction / 2);
+    const dy = Math.round(box.height * fraction / 2);
+    const [from, to] = direction === "up" ? [{ x: c.x, y: c.y + dy }, { x: c.x, y: c.y - dy }] : direction === "down" ? [{ x: c.x, y: c.y - dy }, { x: c.x, y: c.y + dy }] : direction === "left" ? [{ x: c.x + dx, y: c.y }, { x: c.x - dx, y: c.y }] : [{ x: c.x - dx, y: c.y }, { x: c.x + dx, y: c.y }];
+    this.changed();
+    await this.driver.touch([
+      { type: "pointerMove", ...from, duration: 0 },
+      { type: "pointerDown" },
+      { type: "pause", duration: 80 },
+      { type: "pointerMove", ...to, duration: 450 },
+      { type: "pause", duration: 120 },
+      { type: "pointerUp" }
+    ]);
+    await new Promise((r) => setTimeout(r, 350));
+  }
+  /** The element's WebDriver id, for the few commands that need one. */
+  async element(node) {
+    const found = await this.driver.find("xpath", node.xpath);
+    if (!found[0]) throw new Error("The element moved before it could be used.");
+    return found[0];
+  }
+  /** Replace what a field holds with `text`. */
+  async type(node, text) {
+    this.changed();
+    const element = await this.element(node).catch(() => null);
+    if (element) {
+      await this.driver.click(element).catch(() => {
+      });
+      await this.driver.clear(element).catch(() => {
+      });
+      await this.driver.type(element, text);
+      return;
+    }
+    await this.tap(node);
+    await this.driver.keys(text);
+  }
+  async back() {
+    this.changed();
+    await this.driver.back();
+  }
+  async pressKey(key) {
+    this.changed();
+    if (this.platform === "android") {
+      const code = ANDROID_KEYS[key.toLowerCase()];
+      if (code === void 0) throw new Error(`"${key}" is not a key a phone has \u2014 use Enter, Back, Tab, Delete, Search or Home.`);
+      await this.driver.execute("mobile: pressKey", { keycode: code });
+      return;
+    }
+    const ch = { enter: "\n", return: "\n", tab: "	", delete: "\b", backspace: "\b" }[key.toLowerCase()];
+    if (!ch) throw new Error(`"${key}" is not a key an iPhone keyboard has \u2014 use Enter, Tab or Delete.`);
+    await this.driver.keys(ch);
+  }
+  async keyboardShown() {
+    return this.driver.raw("GET", "/appium/device/is_keyboard_shown").catch(() => false);
+  }
+  async hideKeyboard() {
+    if (!await this.keyboardShown()) return;
+    this.changed();
+    if (this.platform === "android") await this.driver.raw("POST", "/appium/device/hide_keyboard", {}).catch(() => this.driver.back());
+    else await this.driver.execute("mobile: hideKeyboard", { keys: ["done", "Done", "return", "Return"] }).catch(() => {
+    });
+  }
+  /** Something not found while the keyboard is up may be under it — Android
+   *  leaves covered text out of the screen entirely. Closes the keyboard once
+   *  per screen; answers whether it did. */
+  async uncover() {
+    if (!await this.keyboardShown()) return false;
+    await this.hideKeyboard();
+    await new Promise((r) => setTimeout(r, 300));
+    this.changed();
+    return true;
+  }
+  /** The keyboard covers the lower part of the screen; tapping something
+   *  under it would type a letter instead. */
+  async clearKeyboardFrom(node) {
+    if (node.role === "textbox") return;
+    const screen = await this.screen();
+    if (centre(node.bounds).y < screen.size.height * 0.55) return;
+    if (await this.keyboardShown()) {
+      await this.hideKeyboard();
+      await new Promise((r) => setTimeout(r, 300));
+    }
+  }
+  // ── The app ────────────────────────────────────────────────────────────
+  appArg() {
+    return this.platform === "android" ? { appId: this.appId } : { bundleId: this.appId };
+  }
+  async launchApp() {
+    this.changed();
+    await this.driver.execute("mobile: activateApp", this.appArg());
+    await this.settle(2e4);
+  }
+  async terminateApp() {
+    this.changed();
+    await this.driver.execute("mobile: terminateApp", this.appArg());
+  }
+  async resetApp() {
+    await this.terminateApp().catch(() => {
+    });
+    await this.driver.execute("mobile: clearApp", this.appArg()).catch((e) => {
+      throw new Error(`This device cannot clear the app's data (${e.message}). Reinstall it, or choose "Start clean" in Settings \u2192 Mobile.`);
+    });
+    await this.launchApp();
+  }
+  async background(seconds) {
+    this.changed();
+    await this.driver.execute("mobile: backgroundApp", { seconds });
+  }
+  async rotate(to) {
+    this.changed();
+    await this.driver.setOrientation(to === "landscape" ? "LANDSCAPE" : "PORTRAIT");
+  }
+  async openLink(url) {
+    this.changed();
+    await this.driver.execute("mobile: deepLink", this.platform === "android" ? { url, package: this.appId } : { url, bundleId: this.appId });
+  }
+  /** Answer the system's permission prompt on screen. */
+  async permission(answer) {
+    this.changed();
+    if (this.platform === "ios") {
+      const buttons = await this.driver.execute("mobile: alert", { action: "getButtons" }).catch(() => []);
+      if (!buttons.length) throw new Error("No permission prompt is showing.");
+      const wanted = answer === "allow" ? buttons.find((b) => /allow while using|^allow$|^ok$|allow full access|allow once/i.test(b)) ?? buttons[buttons.length - 1] : buttons.find((b) => /don.t allow|^deny$|not now|cancel/i.test(b)) ?? buttons[0];
+      await this.driver.execute("mobile: alert", { action: "accept", buttonLabel: wanted });
+      return wanted;
+    }
+    const screen = await this.screen();
+    const button = screen.nodes.filter((n) => n.clickable && n.role === "button").find((n) => answer === "allow" ? /permission_allow_(foreground_only_)?button|permission_allow_one_time_button/.test(n.id) || /^(while using the app|allow|only this time)$/i.test(n.name) : /permission_deny(_and_dont_ask_again)?_button/.test(n.id) || /^(don.t allow|deny)$/i.test(n.name));
+    if (!button) throw new Error("No permission prompt is showing.");
+    await this.tap(button);
+    return button.name;
+  }
+  // ── Video ──────────────────────────────────────────────────────────────
+  recording = false;
+  /** Start filming the screen. Android's own recorder stops at three minutes
+   *  unless Appium can join pieces with ffmpeg; iOS needs ffmpeg at all. A
+   *  phone in a cloud farm is filmed by the farm. Answers whether it started. */
+  async startVideo() {
+    if (this.cloud) return false;
+    const ffmpeg = Boolean(onPath("ffmpeg"));
+    if (this.platform === "ios" && !ffmpeg) return false;
+    const options = this.platform === "android" ? { timeLimit: ffmpeg ? "1800" : "180", bitRate: "3000000", forceRestart: true } : { timeLimit: "1800", videoType: "libx264", videoFps: 10, videoQuality: "medium", forceRestart: true };
+    try {
+      await this.driver.raw("POST", "/appium/start_recording_screen", { options });
+      this.recording = true;
+    } catch {
+      this.recording = false;
+    }
+    return this.recording;
+  }
+  /** Stop filming; keep the film at `file`, or throw it away. */
+  async stopVideo(file) {
+    if (!this.recording) return null;
+    this.recording = false;
+    const b64 = await this.driver.raw("POST", "/appium/stop_recording_screen", { options: {} }, 12e4).catch(() => "");
+    if (!file || !b64) return null;
+    const bytes = Buffer.from(b64, "base64");
+    fs4.mkdirSync(path4.dirname(file), { recursive: true });
+    fs4.writeFileSync(file, bytes);
+    return { relPath: path4.basename(file), bytes: bytes.length };
+  }
+  async close() {
+    if (this.recording) await this.stopVideo(null);
+    await this.driver.close();
+  }
+};
+var ANDROID_KEYS = {
+  enter: 66,
+  return: 66,
+  back: 4,
+  tab: 61,
+  delete: 67,
+  backspace: 67,
+  search: 84,
+  home: 3,
+  escape: 111,
+  space: 62,
+  arrowup: 19,
+  arrowdown: 20,
+  arrowleft: 21,
+  arrowright: 22,
+  menu: 82
+};
+function explainStartFailure(message, platform) {
+  if (/Could not find a driver for automationName/i.test(message)) {
+    return `Appium's ${platform === "android" ? "Android (uiautomator2)" : "iOS (xcuitest)"} driver is not installed \u2014 run \`flowriki-agent mobile setup\`.`;
+  }
+  if (/is not installed|does not exist or is not accessible|Activity name .* cannot be found|App with bundle identifier .* unknown/i.test(message)) {
+    return "The app is not installed on that device. Install it, or add its build (.apk / .ipa / .app) in Settings \u2192 Mobile.";
+  }
+  if (/JAVA_HOME/i.test(message)) return "Java is needed for Android tests \u2014 install a JDK (Android Studio includes one).";
+  if (/ANDROID_HOME|ANDROID_SDK_ROOT/i.test(message)) return "The Android SDK was not found \u2014 install Android Studio.";
+  if (/xcodebuild|WebDriverAgent/i.test(message)) return `Appium could not start its helper on the iPhone: ${message}. For a real iPhone, set your Apple team id in Settings \u2192 Mobile.`;
+  return `The app could not be opened: ${message}`;
+}
+var MOBILE_TIMEOUTS = { step: 15e3, assertion: 5e3 };
+var firstLine = (e) => String(e instanceof Error ? e.message : e).split("\n")[0].trim();
+function expand(text, values) {
+  return text.replace(/\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g, (_, name) => {
+    if (values.has(name)) return values.get(name);
+    if (name === "unique") {
+      const v = `${Date.now().toString(36)}${Math.random().toString(16).slice(2, 8)}`;
+      values.set(name, v);
+      return v;
+    }
+    throw new Error(`Runtime value "${name}" has not been captured yet`);
+  });
+}
+function typedValue(step, opts) {
+  if (step.secretRef || step.secret) {
+    const ref = step.secretRef || step.value;
+    const value = opts.resolveSecret?.(ref);
+    if (value === void 0) throw new Error(`the secret "${ref}" is not available on this computer`);
+    return value;
+  }
+  return expand(step.value, opts.values);
+}
+var failureKind = (e) => e instanceof LocateError ? e.kind : e instanceof CheckError ? e.kind === "assertion" ? "assertion" : e.kind === "unknown" ? "unknown" : e.kind : /timed? ?out/i.test(String(e)) ? "timeout" : "unknown";
+var DIRECTIONS = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+async function performMobileStep(session, step, opts, onFound) {
+  const refused = stepRefusedOn(step.type, session.platform);
+  if (refused) throw new Error(refused);
+  const timeout = step.timeoutMs ?? MOBILE_TIMEOUTS.step;
+  const find = async () => {
+    const found = await locate(session, step, timeout);
+    if (found.foundBy) onFound?.(found.foundBy);
+    return found.node;
+  };
+  switch (step.type) {
+    case "click":
+      return session.tap(await find());
+    case "longPress":
+      return session.longPress(await find(), Number(step.value) || 1e3);
+    case "fill": {
+      const node = await find();
+      await session.type(node, typedValue(step, opts));
+      return;
+    }
+    case "check": {
+      const node = await find();
+      const want = step.value !== "false";
+      if (node.checked === true !== want) await session.tap(node);
+      return;
+    }
+    case "select": {
+      const node = await find();
+      await session.tap(node);
+      const option = expand(step.value, opts.values);
+      const picked = await locate(session, { role: "", name: option, candidates: [{ strategy: "text", value: option }] }, timeout);
+      await session.tap(picked.node);
+      return;
+    }
+    case "press":
+      return session.pressKey(step.value || "Enter");
+    case "back":
+      return session.back();
+    case "navigate":
+      return session.openLink(expand(step.value, opts.values));
+    case "scroll":
+    case "swipe": {
+      const direction = (step.value || "up").toLowerCase();
+      if (!DIRECTIONS.has(direction)) throw new Error(`swipe "${step.value}" \u2014 say up, down, left or right`);
+      if (step.type === "scroll" && step.role) {
+        await find();
+        return;
+      }
+      const area = step.role ? (await find()).bounds : void 0;
+      return session.swipe(direction, area);
+    }
+    case "hideKeyboard":
+      return session.hideKeyboard();
+    case "launchApp":
+      return session.launchApp();
+    case "terminateApp":
+      return session.terminateApp();
+    case "resetApp":
+      return session.resetApp();
+    case "background":
+      return session.background(Math.max(1, Math.min(Number(step.value) || 3, 60)));
+    case "rotate":
+      return session.rotate(step.value === "landscape" ? "landscape" : "portrait");
+    case "permission": {
+      const answered = await session.permission(step.value === "deny" ? "deny" : "allow");
+      return { detail: `answered "${answered}"` };
+    }
+    case "capture": {
+      if (!step.capture) throw new Error("this capture does not say what to keep");
+      if (step.capture.source === "url") throw new Error("a phone app has no address to capture \u2014 capture text from the screen");
+      const node = await find();
+      const value = step.capture.source === "value" ? node.value : textOf(node);
+      opts.values.set(step.capture.name, value);
+      return { value };
+    }
+    case "useHelper": {
+      const helper = step.helper;
+      if (!helper) throw new Error("this step does not say which helper to use");
+      if (!opts.runHelper) throw new Error("this run was started without its helpers \u2014 run it again from Flowriki");
+      const inputs = Object.fromEntries(Object.entries(helper.inputs).map(([k, v]) => [k, expand(v, opts.values)]));
+      const got = await opts.runHelper(helper.helperId, inputs);
+      if (helper.saveAs) opts.values.set(helper.saveAs, got.value);
+      if (helper.then === "open") await session.openLink(got.value);
+      return { value: got.value, detail: got.detail };
+    }
+    case "assert":
+      return;
+    case "useActor":
+    case "resetActor":
+      throw new Error("a flow on a phone has one device \u2014 use a test case to add a second device or a browser");
+    case "unsupported":
+      throw new Error(step.warning || "this step could not be recorded and cannot be replayed");
+    default:
+      throw new Error(`"${step.type}" cannot be done on a phone`);
+  }
+}
+async function performSignIn(session, step, opts) {
+  const auth = step.auth ? opts.resolveAuth?.(step.auth) : void 0;
+  if (!auth) return { ok: false, label: "Sign in", detail: "this run was delivered without the sign-in it needs \u2014 open it again so its procedure and account are resolved" };
+  const out = step.type === "signOut";
+  const label = out ? `Sign out ${auth.accountName}` : `Sign in as ${auth.accountName}`;
+  const procedure = out ? auth.signOut : { steps: auth.steps, success: auth.success };
+  if (!procedure) return { ok: false, label, detail: `"${auth.name}" has no sign-out recorded` };
+  const checks = procedure.success.filter((c) => c.enabled !== false);
+  if (!checks.length) return { ok: false, label, detail: "this sign-in has no check for whether it worked \u2014 add one so a failed login is not reported as a passed step" };
+  if ((opts.authDepth ?? 0) > 0) return { ok: false, label, detail: `"${auth.name}" signs in from inside its own sign-in` };
+  const proven = async (budget) => {
+    for (const c of checks) await checkMobileAssertion(session, c, budget);
+  };
+  if (!out) {
+    try {
+      await proven(2500);
+      return { ok: true, label, detail: "already signed in \u2014 the app kept its session" };
+    } catch {
+    }
+  }
+  const inner = await runMobileSteps(session, procedure.steps, { ...opts, onStepResult: void 0, authDepth: (opts.authDepth ?? 0) + 1 });
+  if (inner.status !== "passed") {
+    const failed = inner.results.find((r) => r.status === "failed");
+    return { ok: false, label, detail: `could not ${label.toLowerCase()}: ${failed ? `"${failed.name}" failed \u2014 ` : ""}${failed?.detail ?? inner.error ?? "no detail"}` };
+  }
+  try {
+    await proven(MOBILE_TIMEOUTS.assertion * 2);
+  } catch (e) {
+    return { ok: false, label, detail: `could not ${label.toLowerCase()}: ${firstLine(e)}` };
+  }
+  return { ok: true, label, detail: "" };
+}
+async function runMobileSteps(session, steps, opts) {
+  const results = [];
+  let status = "passed";
+  let error = null;
+  try {
+    for (const step of steps) {
+      if (opts.signal?.aborted) break;
+      const t0 = Date.now();
+      const secret = Boolean(step.secret || step.secretRef);
+      const result = {
+        stepId: step.id,
+        name: step.name,
+        type: step.type,
+        value: secret ? null : step.value || null,
+        secret,
+        status: "passed",
+        detail: null,
+        failureKind: null,
+        durationMs: 0,
+        checks: []
+      };
+      if (step.disabled) {
+        result.status = "skipped";
+        result.detail = "turned off";
+        results.push(result);
+        opts.onStepResult?.(result);
+        continue;
+      }
+      try {
+        if (step.type === "signIn" || step.type === "signOut") {
+          const signed = await performSignIn(session, step, opts);
+          result.name = signed.label;
+          if (!signed.ok) throw Object.assign(new Error(signed.detail), { kind: "assertion" });
+          if (signed.detail) result.detail = signed.detail;
+        } else {
+          const done = await performMobileStep(session, step, opts, (foundBy) => {
+            result.foundBy = foundBy;
+          });
+          if (done?.value !== void 0 && !secret) result.value = done.value;
+          if (done?.detail) result.detail = done.detail;
+        }
+        let hardKind = null;
+        for (const a of step.proposals ?? []) {
+          if (a.enabled === false) continue;
+          const label = describeAssertion(a, step.name);
+          const soft = a.soft === true;
+          try {
+            const detail = await checkMobileAssertion(session, a, step.assertionTimeoutMs ?? MOBILE_TIMEOUTS.assertion);
+            result.checks.push({ kind: a.kind, expected: label, ok: true, soft, detail });
+          } catch (e) {
+            if (!soft) hardKind = failureKind(e);
+            result.checks.push({ kind: a.kind, expected: label, ok: false, soft, detail: firstLine(e) });
+          }
+        }
+        const hard = result.checks.find((c) => !c.ok && !c.soft);
+        if (hard) {
+          result.status = "failed";
+          result.failureKind = hardKind ?? "assertion";
+          result.detail = hard.detail;
+        }
+      } catch (e) {
+        result.status = "failed";
+        result.failureKind = e.kind ?? failureKind(e);
+        result.detail = firstLine(e);
+      }
+      const shots = opts.screenshots ?? "on-failure";
+      if (opts.evidenceDir && (shots === "always" || shots === "on-failure" && result.status === "failed")) {
+        const file = `step-${String((opts.stepOffset ?? 0) + results.length + 1).padStart(2, "0")}.png`;
+        try {
+          await session.screenshot(path5.join(opts.evidenceDir, file));
+          result.evidence = { screenshot: file, url: await session.currentScreenName(), title: session.deviceName };
+        } catch {
+        }
+      }
+      result.durationMs = Date.now() - t0;
+      results.push(result);
+      opts.onStepResult?.(result);
+      if (result.status === "failed") {
+        status = "failed";
+        error = step.type === "assert" ? `check ${describeAssertion(step.proposals[0] ?? { kind: "visible", value: "" }, step.name)}: ${result.detail}` : `${step.type}${step.name ? ` "${step.name}"` : ""}: ${result.detail}`;
+        break;
+      }
+    }
+  } catch (e) {
+    status = "errored";
+    error = firstLine(e);
+  }
+  return { results, status, error };
+}
+var typesSecrets = (steps) => steps.some((s) => s.secret || Boolean(s.secretRef) || s.type === "signIn");
+var filmsThis = (policy, steps, evidenceDir) => Boolean(evidenceDir) && Boolean(policy) && policy.mode !== "off" && (policy.allowUnmasked === true || !typesSecrets(steps));
+async function finishVideo(session, policy, evidenceDir, passed, name = "phone") {
+  const keep = Boolean(evidenceDir) && (policy?.mode === "always" || policy?.mode === "on-failure" && !passed);
+  const saved = await session.stopVideo(keep ? path6.join(evidenceDir, `video-${name}.mp4`) : null).catch(() => null);
+  return saved ? [{ kind: "video", relPath: saved.relPath, bytes: saved.bytes }] : [];
+}
+async function chooseDevice(platform, mobile, asked) {
+  const chosen = asked ?? mobile.devices[platform];
+  if (chosen) return chosen;
+  const devices = await listDevices();
+  const picked = pickDevice(devices, platform);
+  if (picked) return picked;
+  const farm = mobile.cloud[0];
+  if (farm) throw new Error(`No ${platform === "ios" ? "iPhone or simulator" : "Android phone or emulator"} is connected to this computer. Choose a ${farm.provider} device in Settings \u2192 Mobile, or connect one.`);
+  throw new Error(platform === "ios" ? "No iPhone or simulator is available \u2014 install Xcode for simulators, or plug in an iPhone." : "No Android phone or emulator is available \u2014 start an emulator in Android Studio, or plug in a phone with USB debugging on.");
+}
+async function openMobileSession(opts) {
+  const device = await chooseDevice(opts.platform, opts.mobile, opts.device);
+  return MobileSession.open(
+    { platform: opts.platform, device, mobile: opts.mobile, ...opts.fresh ? { fresh: true } : {} },
+    { ...opts.resolveSecret ? { resolveSecret: opts.resolveSecret } : {}, ...opts.onProgress ? { onProgress: opts.onProgress } : {} }
+  );
+}
+async function replayMobileFlow(opts) {
+  const started = Date.now();
+  let session;
+  try {
+    session = await openMobileSession(opts);
+  } catch (e) {
+    return {
+      status: "errored",
+      error: e.message,
+      durationMs: Date.now() - started,
+      stepsRun: 0,
+      stepsTotal: opts.steps.length,
+      steps: [],
+      device: describeDevice(opts.device ?? null)
+    };
+  }
+  const filming = filmsThis(opts.video, opts.steps, opts.evidenceDir) && await session.startVideo();
+  let outcome = null;
+  try {
+    if (opts.startPath && /^[a-z][\w+.-]*:\/\//i.test(opts.startPath)) await session.openLink(opts.startPath);
+    outcome = await runMobileSteps(session, opts.steps, {
+      values: /* @__PURE__ */ new Map(),
+      ...opts.resolveSecret ? { resolveSecret: opts.resolveSecret } : {},
+      ...opts.resolveAuth ? { resolveAuth: opts.resolveAuth } : {},
+      ...opts.runHelper ? { runHelper: opts.runHelper } : {},
+      ...opts.onStepResult ? { onStepResult: opts.onStepResult } : {},
+      ...opts.evidenceDir ? { evidenceDir: opts.evidenceDir } : {},
+      ...opts.screenshots ? { screenshots: opts.screenshots } : {},
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    const { results, status, error } = outcome;
+    const artifacts = filming ? await finishVideo(session, opts.video, opts.evidenceDir, status === "passed") : [];
+    return {
+      status,
+      error,
+      durationMs: Date.now() - started,
+      stepsRun: results.filter((r) => r.status !== "skipped").length,
+      stepsTotal: opts.steps.length,
+      steps: results,
+      device: session.deviceName,
+      ...artifacts.length ? { artifacts } : {}
+    };
+  } finally {
+    await session.close();
+  }
+}
+async function installedDrivers() {
+  const appium = appiumPath();
+  if (!appium) return {};
+  const out = await run(appium.bin, ["driver", "list", "--installed", "--json"], 6e4, await toolEnv()).catch(() => "{}");
+  try {
+    const parsed = JSON.parse(out.slice(out.indexOf("{")));
+    return Object.fromEntries(Object.entries(parsed).filter(([, v]) => v.installed !== false).map(([k, v]) => [k, v.version ?? "?"]));
+  } catch {
+    return {};
+  }
+}
+async function mobileDoctor() {
+  const appium = appiumPath();
+  const drivers = await installedDrivers();
+  const appiumVersion = appium ? (await run(appium.bin, ["--version"], 3e4, await toolEnv()).catch(() => "")).trim().split("\n").pop() ?? "" : "";
+  const appiumLines = [
+    appium ? { item: "Appium", ok: true, detail: `${appiumVersion || "installed"} (${appium.bin.startsWith(APPIUM_DIR) ? "installed by Flowriki" : appium.bin})` } : { item: "Appium", ok: false, detail: "not installed", fix: "flowriki-agent mobile setup" },
+    onPath("ffmpeg") ? { item: "ffmpeg", ok: true, detail: "phone runs can be filmed", optional: true } : {
+      item: "ffmpeg",
+      ok: false,
+      optional: true,
+      detail: "not installed \u2014 Android videos stop at 3 minutes, iOS runs cannot be filmed",
+      fix: process.platform === "darwin" ? "brew install ffmpeg" : process.platform === "win32" ? "winget install ffmpeg" : "install ffmpeg with your package manager"
+    }
+  ];
+  const sdk = androidHome();
+  const adb = adbPath();
+  const java = await javaHome();
+  const devices = await listDevices().catch(() => []);
+  const android = [
+    sdk ? { item: "Android SDK", ok: true, detail: sdk } : { item: "Android SDK", ok: false, detail: "not found", fix: "Install Android Studio (it installs the SDK), or set ANDROID_HOME" },
+    adb ? { item: "adb", ok: true, detail: adb } : { item: "adb", ok: false, detail: "not found", fix: "Android Studio \u2192 SDK Manager \u2192 SDK Platform-Tools" },
+    java && javaMajor(java) >= 11 ? { item: "Java", ok: true, detail: java } : java ? { item: "Java", ok: false, detail: `${java} is too old`, fix: "Install a JDK 17 (Android Studio includes one), or point JAVA_HOME at one" } : { item: "Java", ok: false, detail: "not found", fix: "Install a JDK 17 (Android Studio includes one), or set JAVA_HOME" },
+    drivers["uiautomator2"] ? { item: "Android driver", ok: true, detail: `uiautomator2 ${drivers["uiautomator2"]}` } : { item: "Android driver", ok: false, detail: "not installed", fix: "flowriki-agent mobile setup" }
+  ];
+  const androids = devices.filter((d) => d.platform === "android");
+  android.push(androids.length ? { item: "Devices", ok: true, detail: androids.map((d) => `${d.name} (${d.kind}${d.state === "ready" ? "" : `, ${d.state}`})`).join(", ") } : { item: "Devices", ok: false, detail: "none", fix: "Create an emulator in Android Studio \u2192 Device Manager, or plug in a phone with USB debugging on" });
+  const ios = [];
+  if (process.platform !== "darwin") {
+    ios.push({ item: "Xcode", ok: false, detail: "iOS testing needs a Mac", fix: "Run the agent on a Mac, or use a cloud device farm" });
+  } else {
+    const xcode = (await run("xcodebuild", ["-version"], 2e4).catch(() => "")).split("\n")[0]?.trim();
+    ios.push(xcode ? { item: "Xcode", ok: true, detail: xcode } : { item: "Xcode", ok: false, detail: "not installed", fix: "Install Xcode from the App Store, then run: sudo xcode-select -s /Applications/Xcode.app" });
+    ios.push(drivers["xcuitest"] ? { item: "iOS driver", ok: true, detail: `xcuitest ${drivers["xcuitest"]}` } : { item: "iOS driver", ok: false, detail: "not installed", fix: "flowriki-agent mobile setup" });
+    const iphones = devices.filter((d) => d.platform === "ios");
+    ios.push(iphones.length ? { item: "Devices", ok: true, detail: `${iphones.filter((d) => d.kind === "simulator").length} simulators${iphones.some((d) => d.kind === "device") ? `, ${iphones.filter((d) => d.kind === "device").map((d) => d.name).join(", ")}` : ""}` } : { item: "Devices", ok: false, detail: "none", fix: "Xcode \u2192 Settings \u2192 Platforms \u2192 add an iOS simulator" });
+  }
+  const okAll = (lines) => lines.every((l) => l.ok || l.optional);
+  return { appium: appiumLines, android, ios, androidReady: okAll(appiumLines) && okAll(android), iosReady: okAll(appiumLines) && okAll(ios) };
+}
+function stream(file, args, env, cwd, say) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(file, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+    const each = (b) => String(b).split("\n").map((l) => l.trim()).filter(Boolean).forEach(say);
+    child.stdout.on("data", each);
+    child.stderr.on("data", each);
+    child.on("error", reject);
+    child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${path7.basename(file)} ${args.join(" ")} failed (${code})`)));
+  });
+}
+async function mobileSetup(say = console.log) {
+  const npm = onPath("npm");
+  if (!npm) throw new Error("npm was not found \u2014 install Node.js 20 or newer.");
+  fs5.mkdirSync(path7.join(APPIUM_DIR, "home"), { recursive: true });
+  if (!fs5.existsSync(path7.join(APPIUM_DIR, "package.json"))) {
+    fs5.writeFileSync(path7.join(APPIUM_DIR, "package.json"), JSON.stringify({ name: "flowriki-appium", private: true }, null, 2));
+  }
+  const env = { ...await toolEnv(), APPIUM_HOME: path7.join(APPIUM_DIR, "home") };
+  say("Installing Appium\u2026");
+  await stream(npm, ["install", "--no-audit", "--no-fund", "appium@2"], env, APPIUM_DIR, say);
+  const bin = path7.join(APPIUM_DIR, "node_modules", ".bin", process.platform === "win32" ? "appium.cmd" : "appium");
+  const have = await installedDrivers();
+  const wanted = ["uiautomator2", ...process.platform === "darwin" ? ["xcuitest"] : []];
+  for (const driver of wanted) {
+    if (have[driver]) {
+      say(`${driver} is already installed.`);
+      continue;
+    }
+    say(`Installing the ${driver === "xcuitest" ? "iOS" : "Android"} driver (${driver})\u2026`);
+    await stream(bin, ["driver", "install", driver], env, APPIUM_DIR, say).catch((e) => say(`Could not install ${driver}: ${e.message}`));
+  }
+  return mobileDoctor();
+}
+var MobileLane = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.values = opts.values ?? /* @__PURE__ */ new Map();
+  }
+  opts;
+  sessions = /* @__PURE__ */ new Map();
+  filming = /* @__PURE__ */ new Set();
+  failed = false;
+  values;
+  /** Run one phone row. `deviceKey` is the row's device — its actor id. */
+  async run(occurrence, ctx) {
+    const platform = occurrence.platform;
+    if (!isMobile(platform)) return { status: "errored", error: `"${occurrence.name}" is not a phone flow`, steps: [] };
+    let session = this.sessions.get(ctx.deviceKey);
+    const start = ctx.first || !session ? "fresh" : startOf(occurrence) === "fresh" ? "fresh" : navigatesFirst(occurrence) ? "navigate" : "continue";
+    try {
+      if (session && session.platform !== platform) {
+        return { status: "errored", error: `"${occurrence.name}" runs on ${platform}, but its device is ${session.platform === "ios" ? "an iPhone" : "an Android phone"} \u2014 give it a device of its own`, steps: [] };
+      }
+      if (!session) {
+        session = await openMobileSession({
+          platform,
+          mobile: this.opts.mobile,
+          ...this.opts.devices?.[platform] ? { device: this.opts.devices[platform] } : {},
+          ...this.opts.resolveSecret ? { resolveSecret: this.opts.resolveSecret } : {}
+        });
+        this.sessions.set(ctx.deviceKey, session);
+        if (filmsThis(this.opts.video, this.opts.allSteps ?? occurrence.steps, this.opts.evidenceDir) && await session.startVideo()) this.filming.add(ctx.deviceKey);
+      } else if (start === "fresh" || start === "navigate") {
+        await session.terminateApp().catch(() => void 0);
+        await session.launchApp();
+        await session.settle();
+      }
+      if (start !== "continue" && occurrence.startPath && /^[a-z][\w+.-]*:\/\//i.test(occurrence.startPath)) {
+        await session.openLink(occurrence.startPath);
+      }
+    } catch (e) {
+      return { status: "errored", error: e.message, steps: [] };
+    }
+    const done = await runMobileSteps(session, occurrence.steps, {
+      values: this.values,
+      stepOffset: ctx.stepOffset,
+      ...this.opts.resolveSecret ? { resolveSecret: this.opts.resolveSecret } : {},
+      ...this.opts.resolveAuth ? { resolveAuth: this.opts.resolveAuth } : {},
+      ...this.opts.runHelper ? { runHelper: this.opts.runHelper } : {},
+      ...ctx.onStepResult ? { onStepResult: ctx.onStepResult } : {},
+      ...this.opts.evidenceDir ? { evidenceDir: this.opts.evidenceDir } : {},
+      ...this.opts.screenshots ? { screenshots: this.opts.screenshots } : {},
+      ...this.opts.signal ? { signal: this.opts.signal } : {}
+    });
+    if (done.status !== "passed") this.failed = true;
+    return { status: done.status, error: done.error, steps: done.results };
+  }
+  /** Close every phone; answers the films kept. `passed` is the whole
+   *  case's result — a film is about the case, not one row. */
+  async close(passed = !this.failed) {
+    const all = [...this.sessions.entries()];
+    this.sessions.clear();
+    const films = [];
+    let n = 0;
+    for (const [key, session] of all) {
+      n++;
+      if (this.filming.has(key)) films.push(...await finishVideo(session, this.opts.video, this.opts.evidenceDir, passed, `phone-${n}`));
+      await session.close().catch(() => void 0);
+    }
+    this.filming.clear();
+    return films;
+  }
+};
+async function replayMobileCase(opts) {
+  const started = Date.now();
+  const lane = new MobileLane(opts);
+  const outcomes = [];
+  const opened = /* @__PURE__ */ new Set();
+  let status = "passed";
+  let error = null;
+  let artifacts = [];
+  try {
+    for (const occurrence of opts.occurrences) {
+      if (status !== "passed" || opts.signal?.aborted) {
+        if (status === "passed") {
+          status = "errored";
+          error = "the run was cancelled";
+        }
+        const skipped = { occurrenceId: occurrence.occurrenceId, name: occurrence.name, status: "skipped", error: null, steps: [], stepsRun: 0, stepsTotal: occurrence.steps.length, durationMs: 0, continued: false };
+        outcomes.push(skipped);
+        opts.onOccurrenceResult?.(skipped);
+        continue;
+      }
+      const key = occurrence.actorId ?? opts.defaultActorId ?? "default";
+      const at = Date.now();
+      const ran = await lane.run(occurrence, {
+        deviceKey: key,
+        first: !opened.has(key),
+        stepOffset: outcomes.reduce((n, o) => n + o.stepsTotal, 0),
+        ...opts.onStepResult ? { onStepResult: (r) => opts.onStepResult(r, occurrence.occurrenceId) } : {}
+      });
+      opened.add(key);
+      const outcome = {
+        occurrenceId: occurrence.occurrenceId,
+        name: occurrence.name,
+        status: ran.status,
+        error: ran.error,
+        steps: ran.steps,
+        stepsRun: ran.steps.filter((r) => r.status !== "skipped").length,
+        stepsTotal: occurrence.steps.length,
+        durationMs: Date.now() - at,
+        continued: outcomes.length > 0 && startOf(occurrence) === "continue"
+      };
+      outcomes.push(outcome);
+      opts.onOccurrenceResult?.(outcome);
+      if (ran.status !== "passed") {
+        status = ran.status;
+        error = `${occurrence.name}: ${ran.error ?? "failed"}`;
+      }
+    }
+  } finally {
+    artifacts = await lane.close(status === "passed");
+  }
+  const steps = outcomes.flatMap((o) => o.steps);
+  return {
+    status,
+    error,
+    artifacts,
+    durationMs: Date.now() - started,
+    occurrences: outcomes,
+    steps,
+    stepsRun: steps.filter((r) => r.status !== "skipped").length,
+    stepsTotal: opts.occurrences.reduce((n, o) => n + o.steps.length, 0),
+    warnings: []
+  };
+}
+
+export {
+  isMobile,
+  stepRefusedOn,
+  platformsOf,
+  CLOUD_PROVIDERS,
+  CLOUD_PROVIDER_NAME,
+  DeviceChoiceSchema,
+  mobileOf,
+  ArtifactPolicySchema,
+  ExecutionEnvironmentSchema,
+  RecordedAssertionSchema,
+  FeatureSchema,
+  isSecretRefName,
+  RecordedStepSchema,
+  DraftStepSchema,
+  slugify,
+  CURRENT_SCHEMA_VERSION,
+  FlowDocumentSchema,
+  parseFlowDocument,
+  mirrorCheckTargets,
+  CapabilitySchema,
+  parseGherkin,
+  TestCaseSchema,
+  startOf,
+  navigatesFirst,
+  sessionLanes,
+  caseDebugPlan,
+  restoreDebugCase,
+  AuthReferenceSchema,
+  DeliveredAuthSchema,
+  actorPreparations,
+  validateActors,
+  actorIdsUsed,
+  sameIdentity,
+  PrerequisiteProblem,
+  expandForRun,
+  DeliveredHelperSchema,
+  proposeAssertions,
+  hasObservableChange,
+  normalizeStartUrl,
+  resolveStartUrl,
+  locatorPlans,
+  locatorPlan,
+  describeLocators,
+  adjacentLabelPattern,
+  frameSelector,
+  inputSelector,
+  SCOPE_ROLES,
+  CHECKS,
+  describeAssertion,
+  identifiedByOwnWords,
+  textIndependent,
+  STEP_PRESENTATION,
+  WebDriverError,
+  WebDriverSession,
+  AGENT_HOME,
+  APPIUM_DIR,
+  androidHome,
+  adbPath,
+  appiumPath,
+  javaHome,
+  toolEnv,
+  run,
+  AppiumMissing,
+  appiumServer,
+  stopAppium,
+  listDevices,
+  bootDevice,
+  CLOUD_HUBS,
+  appOf,
+  cloudDevices,
+  readScreen,
+  screenLines,
+  nodeAt,
+  centre,
+  LocateError,
+  resolveOn,
+  describeTarget,
+  locate,
+  targetFor,
+  CheckError,
+  textOf,
+  checkMobileAssertion,
+  MobileSession,
+  MOBILE_TIMEOUTS,
+  performMobileStep,
+  runMobileSteps,
+  typesSecrets,
+  filmsThis,
+  finishVideo,
+  chooseDevice,
+  openMobileSession,
+  replayMobileFlow,
+  mobileDoctor,
+  mobileSetup,
+  MobileLane,
+  replayMobileCase
+};