@unotest/mobile 0.8.3 → 0.9.1

package/dist/mcp/server.js

@@ -163,16 +163,24 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/config/env.ts
-import { config as loadDotenv } from "dotenv";
+import { applyEnvLayers as applyCoreEnvLayers } from "@unotest/core";
 import { z } from "zod";
-var ENV_FILE_PATH = "unotest/.env";
+
+// src/runner/scenarios-dir.ts
+import { runsDirFor, testDirFor, UNOTEST_DIR } from "@unotest/protocol";
+var MOBILE_SUFFIX = "-mobile";
+var MOBILE_TEST_DIR = testDirFor(MOBILE_SUFFIX);
+var MOBILE_SCENARIOS_DIR = `${UNOTEST_DIR}/${MOBILE_TEST_DIR}`;
+var MOBILE_RUNS_DIR = `${UNOTEST_DIR}/${runsDirFor(MOBILE_SUFFIX)}`;
+
+// src/config/env.ts
 var loaded = false;
-function ensureLoaded() {
+function applyEnvLayers() {
   if (loaded) return;
-  loadDotenv({ path: ENV_FILE_PATH });
+  applyCoreEnvLayers(process.cwd(), MOBILE_SUFFIX);
   loaded = true;
 }
-__name(ensureLoaded, "ensureLoaded");
+__name(applyEnvLayers, "applyEnvLayers");
 var EnvSchema = z.object({
   // APP_BUNDLE_ID — required at appLaunch / install time. We let the schema
   // accept it as optional so commands that don't touch the app (`doctor`,
@@ -219,7 +227,10 @@ var EnvSchema = z.object({
   // `exp+<APP_URL_SCHEME>://expo-development-client/?url=<METRO_URL>` after
   // `app_launch clean: true` to bypass the launcher. (Flow not yet wired.)
   EXPO_DEV_CLIENT: z.string().optional().transform((v) => v === "true" || v === "1"),
-  SESSION_LOG_PATH: z.string().default("unotest/sessions/current.jsonl"),
+  // Dot-prefixed + target-suffixed per the M-10 artifact convention
+  // (`.sessions-mobile`, like `.runs-mobile`): one `.gitignore` wildcard
+  // covers all runtime debris, and web/mobile artifacts never mix.
+  SESSION_LOG_PATH: z.string().default("unotest/.sessions-mobile/current.jsonl"),
   // Explicit kill-switch for session recording. When "1"/"true", or when
   // SESSION_LOG_PATH is empty, buildApp wires a NoopSessionRecorder. Used
   // by evals harness and any consumer that wants the MCP server to make
@@ -228,10 +239,10 @@ var EnvSchema = z.object({
   // When true, recorder writes the FULL tool result alongside the
   // truncated preview. Off by default — snapshots can be megabytes.
   SESSION_LOG_FULL: z.string().optional().transform((v) => v === "1" || v === "true"),
-  ARTIFACTS_DIR: z.string().default("unotest/artifacts"),
+  ARTIFACTS_DIR: z.string().default("unotest/.artifacts-mobile"),
   // Where ExplorationService persists per-session JSONL recording logs.
   // Default: <ARTIFACTS_DIR>/explorations. Folded into the gitignored
-  // `unotest/artifacts/` tree by the init template.
+  // `unotest/.artifacts-mobile/` tree by the init template.
   EXPLORATIONS_DIR: z.string().optional(),
   // WDA per-slot port mapping (D-13 parallel multi-device). Stored as a
   // comma-separated `slot=port` list, e.g. "A=8100,B=8101". Each slot present
@@ -255,7 +266,7 @@ var EnvSchema = z.object({
 var cached = null;
 function loadEnv() {
   if (cached) return cached;
-  ensureLoaded();
+  applyEnvLayers();
   const parsed = EnvSchema.safeParse(process.env);
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
@@ -2164,1963 +2175,301 @@ var TreeInspector = class {
   }
 };
 
-// vendor/dsl/parser/lib/array-value.ts
-var ArrayValue = class _ArrayValue {
-  static {
-    __name(this, "ArrayValue");
-  }
-  elements;
-  constructor(sizeOrElements) {
-    if (typeof sizeOrElements === "number") {
-      this.elements = new Array(sizeOrElements).fill(void 0);
-    } else if (Array.isArray(sizeOrElements)) {
-      this.elements = [...sizeOrElements];
-    } else {
-      this.elements = [...sizeOrElements.elements];
-    }
-  }
-  get(index) {
-    return this.elements[index];
-  }
-  set(index, value) {
-    this.elements[index] = value;
-  }
-  asNumber() {
-    throw new Error("Cannot cast array to number");
-  }
-  clone() {
-    return new _ArrayValue(this.elements.map((e) => e.clone()));
-  }
-  asString() {
-    return `[${this.elements.map((e) => e.asString()).join(", ")}]`;
-  }
-  toString() {
-    return this.asString();
-  }
-};
-
-// vendor/dsl/parser/lib/number-value.ts
-var NumberValue = class _NumberValue {
+// src/dsl/ast-executor.ts
+import {
+  ExecutionWalker
+} from "@unotest/dsl/executor";
+import { UnsupportedAstNodeError } from "@unotest/dsl/executor";
+var AstExecutor = class {
   static {
-    __name(this, "NumberValue");
-  }
-  static ZERO = new _NumberValue(0);
-  value;
-  constructor(value) {
-    if (typeof value === "boolean") {
-      this.value = value ? 1 : 0;
-    } else {
-      this.value = value;
-    }
-  }
-  clone() {
-    return new _NumberValue(this.value);
-  }
-  asNumber() {
-    return this.value;
+    __name(this, "AstExecutor");
   }
-  asString() {
-    return this.value.toString();
+  walker;
+  constructor(registry) {
+    this.walker = new ExecutionWalker(
+      registry
+    );
   }
-  toString() {
-    return this.asString();
+  run(program, testName, runtime, opts, helpers) {
+    return this.walker.run(
+      program,
+      testName,
+      runtime,
+      { resumeRetriesFailedStep: true, ...opts },
+      helpers
+    );
   }
 };
 
-// vendor/dsl/parser/lib/functions.ts
-var Functions = class {
-  static {
-    __name(this, "Functions");
-  }
-  static functions = /* @__PURE__ */ new Map([
-    // prettier-ignore
-    ["cos", { execute(...args) {
-      if (args.length !== 1) {
-        throw new Error("One argument expected");
-      }
-      return new NumberValue(Math.cos(args[0].asNumber()));
-    } }],
-    // prettier-ignore
-    ["echo", { execute(...args) {
-      for (const arg of args) {
-        console.log(arg.asString());
-      }
-      return NumberValue.ZERO;
-    } }],
-    // prettier-ignore
-    ["highlightBlock", { execute(...args) {
-      return NumberValue.ZERO;
-    } }],
-    // prettier-ignore
-    ["setPage", { execute(...args) {
-      return NumberValue.ZERO;
-    } }],
-    // prettier-ignore
-    ["afterBlock", { execute(...args) {
-      return NumberValue.ZERO;
-    } }],
-    // prettier-ignore
-    ["open", { execute(...args) {
-      return NumberValue.ZERO;
-    } }],
-    // prettier-ignore
-    ["String", { execute(...args) {
-      return NumberValue.ZERO;
-    } }]
-  ]);
-  static isExists(key) {
-    return this.functions.has(key);
-  }
-  static get(key) {
-    const f = this.functions.get(key);
-    if (!f) {
-      throw new TypeError(`Unknown function: ${key}`);
-    }
-    return f;
-  }
-  static set(name, value) {
-    this.functions.set(name, value);
-  }
-};
+// src/dsl/linter.ts
+import {
+  AssignmentStatement,
+  ArrayAccessExpression,
+  ArrayAssignmentStatement,
+  ArrayExpression,
+  BinaryExpression,
+  BlockStatement,
+  BreakStatement,
+  ConditionalExpression,
+  ContinueStatement,
+  DoWhileStatement,
+  ForStatement,
+  FunctionDefineStatement,
+  FunctionStatement,
+  FunctionalExpression,
+  IfStatement,
+  IncrementExpression,
+  IncrementStatement,
+  MemberCallExpression,
+  MetaBlockStatement,
+  ObjectExpression,
+  PropertyAccessExpression,
+  PrintStatement,
+  ReturnStatement,
+  StepStatement,
+  UnaryExpression,
+  ValueExpression,
+  VarStatement,
+  VariableExpression,
+  WhileStatement
+} from "@unotest/dsl";
+import { validateDsl } from "@unotest/dsl/validator";
 
-// vendor/dsl/parser/lib/object-value.ts
-var ObjectValue = class _ObjectValue {
-  static {
-    __name(this, "ObjectValue");
-  }
-  properties;
-  constructor(properties = /* @__PURE__ */ new Map()) {
-    this.properties = properties;
-  }
-  get(key) {
-    return this.properties.get(key);
-  }
-  set(key, value) {
-    this.properties.set(key, value);
-  }
-  asNumber() {
-    return this.properties.size;
-  }
-  asString() {
-    const entries = Array.from(this.properties.entries()).map(([key, value]) => `${key}: ${value.asString()}`).join(", ");
-    return `{${entries}}`;
-  }
-  clone() {
-    const clonedProperties = /* @__PURE__ */ new Map();
-    this.properties.forEach((value, key) => {
-      clonedProperties.set(key, value.clone());
-    });
-    return new _ObjectValue(clonedProperties);
-  }
-  getProperties() {
-    return this.properties;
-  }
+// src/dsl/mobile-dsl-registry.ts
+var ARG_KIND = {
+  // Mobile's loose types map onto the engine's lenient predicates —
+  // variables / helper-call results of unknown kind always pass, like the
+  // old E6 "only flag the unambiguous" policy. `selector` maps to the
+  // STRICT locator kind: mobile selectors only come from selector
+  // functions (getByTestId/getByText/…), never bare strings.
+  string: "stringLike",
+  number: "number",
+  boolean: "boolLike",
+  selector: "strictLocatorLike",
+  any: "any"
 };
-
-// vendor/dsl/parser/lib/string-value.ts
-var StringValue = class _StringValue {
-  static {
-    __name(this, "StringValue");
-  }
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-  clone() {
-    return new _StringValue(this.value);
-  }
-  asNumber() {
-    try {
-      return parseFloat(this.value);
-    } catch (error) {
-      return 0;
-    }
-  }
-  asString() {
-    return this.value;
-  }
-  toString() {
-    return this.asString();
-  }
+var ARG_KIND_OVERRIDES = {
+  // apiCall(method, path, jsonBody?, jsonHeaders?) — body/headers must be
+  // JSON strings; replaces the old local E4 check.
+  apiCall: { 2: "jsonObjectString", 3: "jsonObjectString" }
 };
-
-// vendor/dsl/parser/lib/user-define-function.ts
-var UserDefineFunction = class {
-  static {
-    __name(this, "UserDefineFunction");
-  }
-  argNames;
-  body;
-  constructor(argNames, body) {
-    this.argNames = argNames;
-    this.body = body;
-  }
-  getArgsCount() {
-    return this.argNames.length;
-  }
-  getArgsName(index) {
-    if (index < 0 || index >= this.argNames.length) {
-      return "";
-    }
-    return this.argNames[index];
-  }
-  execute(...args) {
-    try {
-      this.body.execute();
-      return NumberValue.ZERO;
-    } catch (e) {
-      if (e instanceof ReturnStatement) {
-        return e.getResult();
-      }
-      throw e;
-    }
-  }
+var RETURN_KIND = {
+  void: "void",
+  string: "string",
+  number: "number",
+  boolean: "bool",
+  selector: "locator",
+  any: "unknown"
 };
-
-// vendor/dsl/parser/lib/variables.ts
-var Variables = class {
+function contractFor(fn) {
+  const required = fn.minArgs ?? fn.argTypes.length;
+  const overrides = ARG_KIND_OVERRIDES[fn.name] ?? {};
+  return {
+    name: fn.name,
+    signature: {
+      args: fn.argTypes.map((t, i) => ({
+        label: `arg${i + 1}`,
+        kind: overrides[i] ?? ARG_KIND[t],
+        required: i < required
+      })),
+      ...fn.variadic ? { variadic: true } : {}
+    },
+    support: "visual",
+    returns: { mode: "fixed", kind: RETURN_KIND[fn.returnType] },
+    // Mobile's frozen subset (D-4) forbids method chains entirely — the
+    // slim linter rejects MemberCallExpression before the engine ever
+    // sees a chain, so no contract is chainable.
+    locatorCapability: fn.returnType === "selector" ? "locator" : "none"
+  };
+}
+__name(contractFor, "contractFor");
+function helperContract(name) {
+  return {
+    name,
+    signature: { args: [], variadic: true },
+    support: "visual",
+    returns: { mode: "fixed", kind: "unknown" },
+    locatorCapability: "none",
+    trusted: true
+  };
+}
+__name(helperContract, "helperContract");
+var MobileDslRegistry = class {
   static {
-    __name(this, "Variables");
-  }
-  static stack = [];
-  static variables = /* @__PURE__ */ new Map([
-    ["PI", new NumberValue(Math.PI)],
-    ["E", new NumberValue(Math.E)]
-  ]);
-  static push() {
-    const clone = /* @__PURE__ */ new Map([]);
-    for (const [key, value] of this.variables.entries()) {
-      clone.set(key, value);
-    }
-    this.stack.push(clone);
+    __name(this, "MobileDslRegistry");
   }
-  static pop() {
-    const v = this.stack.pop();
-    if (!v) {
-      throw new Error("Variables stack undefined");
+  byName = /* @__PURE__ */ new Map();
+  constructor(functions, userFunctionNames = []) {
+    for (const fn of functions) this.byName.set(fn.name, contractFor(fn));
+    for (const name of userFunctionNames) {
+      if (!this.byName.has(name)) this.byName.set(name, helperContract(name));
     }
-    this.variables = v;
   }
-  static isExists(key) {
-    return this.variables.has(key);
+  resolve(name) {
+    return this.byName.get(name) ?? null;
   }
-  static get(key) {
-    return this.variables.get(key) || NumberValue.ZERO;
+  resolveContract(name) {
+    return this.resolve(name);
   }
-  static set(name, value) {
-    this.variables.set(name, value);
+  inferReturnKind(expression, _session) {
+    const contract = this.resolveContract(expression.name);
+    if (!contract || contract.returns.mode !== "fixed") return "unknown";
+    if (contract.returns.kind === "void") return "unknown";
+    return contract.returns.kind;
   }
 };
+var MOBILE_DISABLED_ENGINE_RULES = [
+  "unsupported-statement",
+  "unsupported-expression",
+  "for-shape",
+  "var-shape",
+  "if-shape",
+  "string-concat",
+  "semantic-loss",
+  "list-arg",
+  "wrapped-format"
+];
 
-// vendor/dsl/parser/ast/array-access-expression.ts
-var ArrayAccessExpression = class {
+// src/dsl/function-registry.ts
+var FunctionRegistry = class {
   static {
-    __name(this, "ArrayAccessExpression");
-  }
-  variable;
-  indexes;
-  token;
-  constructor(variable, indexes, token) {
-    this.variable = variable;
-    this.indexes = indexes;
-    this.token = token;
-  }
-  eval() {
-    const i = this.lastIndex();
-    const arr = this.getArray();
-    return arr.get(i);
-  }
-  lastIndex() {
-    return this.index(this.indexes.length - 1);
-  }
-  index(index) {
-    return this.indexes[index].eval().asNumber();
-  }
-  getArray() {
-    let arr = this.consumeArray(Variables.get(this.variable));
-    const last = this.indexes.length - 1;
-    for (let i = 0; i < last; i++) {
-      arr = this.consumeArray(arr.get(this.index(i)));
-    }
-    return arr;
+    __name(this, "FunctionRegistry");
   }
-  consumeArray(value) {
-    if (value instanceof ArrayValue) {
-      return value;
+  map = /* @__PURE__ */ new Map();
+  register(fn) {
+    if (this.map.has(fn.name)) {
+      throw new Error(`Duplicate DSL function: ${fn.name}`);
     }
-    throw new Error("Array expected");
-  }
-  toString() {
-    return `${this.variable + this.indexes}`;
-  }
-};
-
-// vendor/dsl/parser/ast/array-assignment-statement.ts
-var ArrayAssignmentStatement = class {
-  static {
-    __name(this, "ArrayAssignmentStatement");
+    this.map.set(fn.name, fn);
   }
-  array;
-  expression;
-  token;
-  constructor(array, expression, token) {
-    this.array = array;
-    this.expression = expression;
-    this.token = token;
+  has(name) {
+    return this.map.has(name);
   }
-  execute() {
-    this.array.getArray().set(this.array.lastIndex(), this.expression.eval());
+  get(name) {
+    return this.map.get(name);
   }
-  toString() {
-    return `${this.array} = ${this.expression}`;
+  names() {
+    return [...this.map.keys()].sort();
   }
 };
 
-// vendor/dsl/parser/ast/array-expression.ts
-var ArrayExpression = class {
-  static {
-    __name(this, "ArrayExpression");
-  }
-  elements;
-  token;
-  constructor(argument, token) {
-    this.elements = argument;
-    this.token = token;
-  }
-  eval() {
-    const values = this.elements.map((el) => el.eval());
-    return new ArrayValue(values);
-  }
-  toString() {
-    return `${this.elements.toString()}`;
-  }
+// src/dsl/functions/alerts.ts
+function asString(x, fn, idx) {
+  if (typeof x !== "string") throw new Error(`${fn}(): arg ${idx} must be a string. Got ${typeof x}.`);
+  return x;
+}
+__name(asString, "asString");
+var acceptAlert = {
+  name: "acceptAlert",
+  argTypes: ["string"],
+  returnType: "void",
+  minArgs: 0,
+  invoke: /* @__PURE__ */ __name(async (runtime, buttonArg) => {
+    const button = buttonArg !== void 0 ? asString(buttonArg, "acceptAlert", 0) : void 0;
+    await runtime.driver.acceptAlert(runtime.currentDeviceSlot, button);
+  }, "invoke")
 };
-
-// vendor/dsl/parser/ast/assignment-statement.ts
-var AssignmentStatement = class {
-  static {
-    __name(this, "AssignmentStatement");
-  }
-  variable;
-  expression;
-  token;
-  constructor(variable, expression, token) {
-    this.variable = variable;
-    this.expression = expression;
-    this.token = token;
-  }
-  execute() {
-    const result = this.expression.eval();
-    Variables.set(this.variable, result);
-  }
-  toString() {
-    return `${this.variable} = ${this.expression}`;
-  }
+var dismissAlert = {
+  name: "dismissAlert",
+  argTypes: [],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime) => {
+    await runtime.driver.dismissAlert(runtime.currentDeviceSlot);
+  }, "invoke")
 };
-
-// vendor/dsl/parser/ast/binary-expression.ts
-var BinaryExpression = class {
-  static {
-    __name(this, "BinaryExpression");
-  }
-  expr1;
-  expr2;
-  operation;
-  token;
-  constructor(operator, expr1, expr2, token) {
-    this.expr1 = expr1;
-    this.expr2 = expr2;
-    this.operation = operator;
-    this.token = token;
-  }
-  eval() {
-    const value1 = this.expr1.eval();
-    if (value1 instanceof StringValue || value1 instanceof ArrayValue) {
-      const string1 = value1.asString();
-      const string2 = this.expr2.eval().asString();
-      switch (this.operation) {
-        case "+":
-          return new StringValue(string1 + string2);
-        default:
-          throw new Error("Unrecognized operator for string value");
-      }
-    }
-    const number1 = this.expr1.eval().asNumber();
-    const number2 = this.expr2.eval().asNumber();
-    switch (this.operation) {
-      case "-":
-        return new NumberValue(number1 - number2);
-      case "+":
-        return new NumberValue(number1 + number2);
-      case "/":
-        return new NumberValue(number1 / number2);
-      case "*":
-      default:
-        return new NumberValue(number1 * number2);
-    }
-  }
-  toString() {
-    return `${this.expr1} ${this.operation} ${this.expr2}`;
-  }
+var readAlert = {
+  name: "readAlert",
+  argTypes: [],
+  returnType: "string",
+  invoke: /* @__PURE__ */ __name(async (runtime) => {
+    const { text } = await runtime.driver.readAlert(runtime.currentDeviceSlot);
+    return text;
+  }, "invoke")
 };
+var ALERT_FUNCTIONS = [acceptAlert, dismissAlert, readAlert];
 
-// vendor/dsl/parser/ast/block-statement.ts
-var BlockStatement = class {
-  static {
-    __name(this, "BlockStatement");
-  }
-  statements = [];
-  token;
-  constructor(token) {
-    this.token = token;
-  }
-  add(statement) {
-    this.statements.push(statement);
+// src/dsl/functions/asserts.ts
+function asSelector(x, fn, idx) {
+  if (typeof x !== "object" || x === null) {
+    throw new Error(`${fn}(): arg ${idx} must be a Selector. Got ${typeof x}.`);
   }
-  execute() {
-    for (const statement of this.statements) {
-      statement.execute();
+  return x;
+}
+__name(asSelector, "asSelector");
+function asNumber(x, fn, idx) {
+  if (typeof x !== "number") throw new Error(`${fn}(): arg ${idx} must be a number. Got ${typeof x}.`);
+  return x;
+}
+__name(asNumber, "asNumber");
+var assertEqual = {
+  name: "assertEqual",
+  argTypes: ["any", "any"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name((_runtime, actual, expected) => {
+    if (actual !== expected) {
+      throw new Error(
+        `assertEqual failed: actual ${JSON.stringify(actual)} !== expected ${JSON.stringify(expected)}`
+      );
     }
-  }
-  toString() {
-    return `${this.statements.join("\n")}`;
-  }
+  }, "invoke")
 };
-
-// vendor/dsl/parser/ast/break-statement.ts
-var BreakStatement = class extends Error {
-  static {
-    __name(this, "BreakStatement");
-  }
-  token;
-  constructor(token) {
-    super("BreakStatement");
-    this.token = token;
-  }
-  execute() {
-    throw this;
-  }
-  toString() {
-    return `break`;
-  }
+var assertVisible = {
+  name: "assertVisible",
+  argTypes: ["selector"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg) => {
+    const selector = asSelector(selectorArg, "assertVisible", 0);
+    const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
+    const r = runtime.selectorResolver.resolve(tree, selector);
+    if (!r.ok) {
+      throw new Error(
+        `assertVisible failed: ${r.reason}
+  selector: ${JSON.stringify(selector)}
+  candidates: ${JSON.stringify(r.candidates).slice(0, 600)}`
+      );
+    }
+  }, "invoke")
 };
-
-// vendor/dsl/parser/ast/conditional-expression.ts
-var ConditionalExpression = class {
-  static {
-    __name(this, "ConditionalExpression");
-  }
-  expr1;
-  expr2;
-  operation;
-  token;
-  constructor(operator, expr1, expr2, token) {
-    this.expr1 = expr1;
-    this.expr2 = expr2;
-    this.operation = operator;
-    this.token = token;
-  }
-  eval() {
-    const value1 = this.expr1.eval();
-    const value2 = this.expr2.eval();
-    let number1;
-    let number2;
-    if (value1 instanceof StringValue) {
-      number1 = number1 = value1.asString().localeCompare(value2.asString());
-      number2 = 0;
-    } else {
-      number1 = this.expr1.eval().asNumber();
-      number2 = this.expr2.eval().asNumber();
+var assertCount = {
+  name: "assertCount",
+  argTypes: ["selector", "number"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg, expectedArg) => {
+    const selector = asSelector(selectorArg, "assertCount", 0);
+    const expected = asNumber(expectedArg, "assertCount", 1);
+    const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
+    let count = 0;
+    while (true) {
+      const probe = { ...selector, ordinal: count };
+      const r = runtime.selectorResolver.resolve(tree, probe);
+      if (!r.ok) break;
+      count++;
+      if (count > 1e3) {
+        throw new Error(`assertCount: aborting after 1000 \u2014 selector too broad`);
+      }
     }
-    let result;
-    switch (this.operation) {
-      case "<" /* LT */:
-        result = number1 < number2;
-        break;
-      case "<=" /* LTE */:
-        result = number1 <= number2;
-        break;
-      case ">" /* GT */:
-        result = number1 > number2;
-        break;
-      case ">=" /* GTE */:
-        result = number1 >= number2;
-        break;
-      case "!=" /* NEQ */:
-        result = number1 != number2;
-        break;
-      case "&&" /* AND */:
-        result = number1 != 0 && number2 != 0;
-        break;
-      case "||" /* OR */:
-        result = number1 != 0 || number2 != 0;
-        break;
-      case "==" /* EQ */:
-      default:
-        result = number1 === number2;
+    if (count !== expected) {
+      throw new Error(
+        `assertCount failed: ${JSON.stringify(selector)} matched ${count} time(s), expected ${expected}`
+      );
     }
-    return new NumberValue(result);
-  }
-  toString() {
-    return `${this.expr1} ${this.operation} ${this.expr2}`;
-  }
+  }, "invoke")
 };
-
-// vendor/dsl/parser/ast/continue-statement.ts
-var ContinueStatement = class extends Error {
-  static {
-    __name(this, "ContinueStatement");
-  }
-  token;
-  constructor(token) {
-    super("ContinueStatement");
-    this.token = token;
+async function assertEnabledState(runtime, selectorArg, expected, fnName) {
+  const selector = asSelector(selectorArg, fnName, 0);
+  const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
+  const r = runtime.selectorResolver.resolve(tree, selector);
+  if (!r.ok) {
+    throw new Error(
+      `${fnName} failed: selector did not match. ${r.reason}
+  selector: ${JSON.stringify(selector)}`
+    );
   }
-  execute() {
-    throw this;
-  }
-  toString() {
-    return `continue`;
-  }
-};
-
-// vendor/dsl/parser/ast/do-while-statement.ts
-var DoWhileStatement = class {
-  static {
-    __name(this, "DoWhileStatement");
-  }
-  condition;
-  statement;
-  token;
-  constructor(expression, statement, token) {
-    this.condition = expression;
-    this.statement = statement;
-    this.token = token;
-  }
-  execute() {
-    do {
-      try {
-        this.statement.execute();
-      } catch (e) {
-        if (e instanceof BreakStatement) {
-          break;
-        } else if (e instanceof ContinueStatement) {
-        } else {
-          throw e;
-        }
-      }
-    } while (this.condition.eval().asNumber() != 0);
-  }
-  toString() {
-    return `do {
-${this.statement}
-}
-while (${this.condition})
-`;
-  }
-};
-
-// vendor/dsl/parser/ast/for-statement.ts
-var ForStatement = class {
-  static {
-    __name(this, "ForStatement");
-  }
-  initialization;
-  termination;
-  increment;
-  block;
-  token;
-  constructor(initialization, termination, increment, block, token) {
-    this.initialization = initialization;
-    this.termination = termination;
-    this.increment = increment;
-    this.block = block;
-    this.token = token;
-  }
-  execute() {
-    for (this.initialization.execute(); this.termination.eval().asNumber() != 0; this.increment.execute()) {
-      try {
-        this.block.execute();
-      } catch (e) {
-        if (e instanceof BreakStatement) {
-          break;
-        } else if (e instanceof ContinueStatement) {
-        } else {
-          throw e;
-        }
-      }
-    }
-  }
-  toString() {
-    return `for (${this.initialization}; ${this.termination}; ${this.increment})
-{
-${this.block}
-}`;
-  }
-};
-
-// vendor/dsl/parser/ast/function-define-statement.ts
-var FunctionDefineStatement = class {
-  static {
-    __name(this, "FunctionDefineStatement");
-  }
-  name;
-  argNames;
-  body;
-  token;
-  constructor(name, argNames, body, token) {
-    this.name = name;
-    this.argNames = argNames;
-    this.body = body;
-    this.token = token;
-  }
-  execute() {
-    Functions.set(this.name, new UserDefineFunction(this.argNames, this.body));
-  }
-  toString() {
-    const argsString = this.argNames.map((arg) => arg.toString()).join(", ");
-    return `function ${this.name}(${argsString})`;
-  }
-};
-
-// vendor/dsl/parser/ast/function-statement.ts
-var FunctionStatement = class {
-  static {
-    __name(this, "FunctionStatement");
-  }
-  functionalExpression;
-  token;
-  constructor(func, token) {
-    this.functionalExpression = func;
-    this.token = token;
-  }
-  execute() {
-    this.functionalExpression.eval();
-  }
-  toString() {
-    return `${this.functionalExpression.toString()}`;
-  }
-};
-
-// vendor/dsl/parser/ast/functional-expression.ts
-var FunctionalExpression = class {
-  static {
-    __name(this, "FunctionalExpression");
-  }
-  name;
-  arguments;
-  token;
-  constructor(name, argument, token) {
-    this.name = name;
-    this.arguments = argument;
-    this.token = token;
-  }
-  addArgument(argument) {
-    return this.arguments.push(argument);
-  }
-  eval() {
-    const values = this.arguments.map((v) => v.eval());
-    const size = values.length;
-    const func = Functions.get(this.name);
-    if (func instanceof UserDefineFunction) {
-      const userFunction = func;
-      if (values.length !== userFunction.getArgsCount()) {
-        throw new Error(`Invalid argument count for function ${this.name}: expected ${size}`);
-      }
-      Variables.push();
-      for (let i = 0; i < size; i++) {
-        Variables.set(userFunction.getArgsName(i), values[i]);
-      }
-      const result = userFunction.execute(...values);
-      Variables.pop();
-      return result;
-    }
-    return func.execute(...values);
-  }
-  toString() {
-    const argsString = this.arguments.map((arg) => arg.toString()).join(", ");
-    return `${this.name}(${argsString})`;
-  }
-};
-
-// vendor/dsl/parser/ast/if-statement.ts
-var IfStatement = class {
-  static {
-    __name(this, "IfStatement");
-  }
-  expression;
-  ifStatement;
-  elseStatement;
-  token;
-  constructor(expression, ifStatement, elseStatement, token) {
-    this.expression = expression;
-    this.ifStatement = ifStatement;
-    this.elseStatement = elseStatement;
-    this.token = token;
-  }
-  execute() {
-    const result = this.expression.eval().asNumber();
-    if (result != 0) {
-      this.ifStatement.execute();
-    } else if (this.elseStatement != null) {
-      this.elseStatement.execute();
-    }
-  }
-  toString() {
-    let result = `if ${this.expression} ${this.ifStatement}`;
-    if (this.elseStatement != null) {
-      result += ` else ${this.elseStatement}`;
-    }
-    return result.toString();
-  }
-};
-
-// vendor/dsl/parser/ast/increment-expression.ts
-var IncrementExpression = class {
-  static {
-    __name(this, "IncrementExpression");
-  }
-  variable;
-  type;
-  token;
-  constructor(variable, type, token) {
-    this.variable = variable;
-    this.type = type;
-    this.token = token;
-  }
-  eval() {
-    const varName = this.variable.getName();
-    const currentValue = Variables.get(varName);
-    if (!(currentValue instanceof NumberValue)) {
-      throw new Error(`Cannot increment/decrement non-numeric value`);
-    }
-    const currentNumber = currentValue.asNumber();
-    let newNumber;
-    switch (this.type) {
-      case 0 /* PREFIX_INCREMENT */:
-        newNumber = currentNumber + 1;
-        Variables.set(varName, new NumberValue(newNumber));
-        return new NumberValue(newNumber);
-      case 1 /* PREFIX_DECREMENT */:
-        newNumber = currentNumber - 1;
-        Variables.set(varName, new NumberValue(newNumber));
-        return new NumberValue(newNumber);
-      case 2 /* POSTFIX_INCREMENT */:
-        Variables.set(varName, new NumberValue(currentNumber + 1));
-        return new NumberValue(currentNumber);
-      case 3 /* POSTFIX_DECREMENT */:
-        Variables.set(varName, new NumberValue(currentNumber - 1));
-        return new NumberValue(currentNumber);
-    }
-  }
-};
-
-// vendor/dsl/parser/ast/increment-statement.ts
-var IncrementStatement = class {
-  static {
-    __name(this, "IncrementStatement");
-  }
-  expression;
-  token;
-  constructor(expression, token) {
-    this.expression = expression;
-    this.token = token;
-  }
-  execute() {
-    this.expression.eval();
-  }
-};
-
-// vendor/dsl/parser/ast/meta-block-statement.ts
-var MetaBlockStatement = class {
-  static {
-    __name(this, "MetaBlockStatement");
-  }
-  name;
-  argNames;
-  body;
-  token;
-  constructor(name, argNames, body, token) {
-    this.name = name;
-    this.argNames = argNames;
-    this.body = body;
-    this.token = token;
-  }
-  execute() {
-  }
-  toString() {
-    const argsString = this.argNames.map((arg) => arg.toString()).join(", ");
-    return `//@${this.name}(${argsString})
-${this.body}
-//@end-${this.name}`;
-  }
-};
-
-// vendor/dsl/parser/ast/object-expression.ts
-var ObjectExpression = class {
-  static {
-    __name(this, "ObjectExpression");
-  }
-  properties;
-  token;
-  constructor(properties = /* @__PURE__ */ new Map(), token) {
-    this.properties = properties;
-    this.token = token;
-  }
-  eval() {
-    const evaluatedProperties = /* @__PURE__ */ new Map();
-    this.properties.forEach((expression, key) => {
-      evaluatedProperties.set(key, expression.eval());
-    });
-    return new ObjectValue(evaluatedProperties);
-  }
-  toString() {
-    const entries = Array.from(this.properties.entries()).map(([key, value]) => `${key}: ${value.toString()}`).join(", ");
-    return `{${entries}}`;
-  }
-};
-
-// vendor/dsl/parser/ast/print-statement.ts
-var PrintStatement = class {
-  static {
-    __name(this, "PrintStatement");
-  }
-  expression;
-  token;
-  constructor(expression, token) {
-    this.expression = expression;
-    this.token = token;
-  }
-  execute() {
-    const result = this.expression.eval().asString();
-    console.log(`${result}`);
-  }
-  toString() {
-    return `print ${this.expression}`;
-  }
-};
-
-// vendor/dsl/parser/ast/return-statement.ts
-var ReturnStatement = class extends Error {
-  static {
-    __name(this, "ReturnStatement");
-  }
-  expression;
-  result;
-  token;
-  constructor(expression, token) {
-    super("ContinueStatement");
-    this.expression = expression;
-    this.token = token;
-  }
-  getResult() {
-    if (!this.result) {
-      throw new Error("Not execute ReturnStatement");
-    }
-    return this.result;
-  }
-  execute() {
-    this.result = this.expression.eval();
-    throw this;
-  }
-  toString() {
-    return `return`;
-  }
-};
-
-// vendor/dsl/parser/ast/unary-expression.ts
-var UnaryExpression = class {
-  static {
-    __name(this, "UnaryExpression");
-  }
-  expr1;
-  operation;
-  token;
-  constructor(operator, expr1, token) {
-    this.operation = operator;
-    this.expr1 = expr1;
-    this.token = token;
-  }
-  eval() {
-    switch (this.operation) {
-      case "-":
-        return new NumberValue(-this.expr1.eval().asNumber());
-      case "+":
-      default:
-        return new NumberValue(this.expr1.eval().asNumber());
-    }
-  }
-  toString() {
-    return `${this.operation}${this.expr1}`;
-  }
-};
-
-// vendor/dsl/parser/token-type.ts
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2[TokenType2["NUMBER"] = 0] = "NUMBER";
-  TokenType2[TokenType2["WORD"] = 1] = "WORD";
-  TokenType2[TokenType2["TEXT"] = 2] = "TEXT";
-  TokenType2[TokenType2["VAR"] = 3] = "VAR";
-  TokenType2[TokenType2["PRINT"] = 4] = "PRINT";
-  TokenType2[TokenType2["IF"] = 5] = "IF";
-  TokenType2[TokenType2["ELSE"] = 6] = "ELSE";
-  TokenType2[TokenType2["WHILE"] = 7] = "WHILE";
-  TokenType2[TokenType2["FOR"] = 8] = "FOR";
-  TokenType2[TokenType2["DO"] = 9] = "DO";
-  TokenType2[TokenType2["BREAK"] = 10] = "BREAK";
-  TokenType2[TokenType2["CONTINUE"] = 11] = "CONTINUE";
-  TokenType2[TokenType2["FUNCTION"] = 12] = "FUNCTION";
-  TokenType2[TokenType2["RETURN"] = 13] = "RETURN";
-  TokenType2[TokenType2["PLUS"] = 14] = "PLUS";
-  TokenType2[TokenType2["PLUSPLUS"] = 15] = "PLUSPLUS";
-  TokenType2[TokenType2["MINUS"] = 16] = "MINUS";
-  TokenType2[TokenType2["MINUSMINUS"] = 17] = "MINUSMINUS";
-  TokenType2[TokenType2["STAR"] = 18] = "STAR";
-  TokenType2[TokenType2["SLASH"] = 19] = "SLASH";
-  TokenType2[TokenType2["EQ"] = 20] = "EQ";
-  TokenType2[TokenType2["EQEQ"] = 21] = "EQEQ";
-  TokenType2[TokenType2["EXCL"] = 22] = "EXCL";
-  TokenType2[TokenType2["EXCLEQ"] = 23] = "EXCLEQ";
-  TokenType2[TokenType2["LT"] = 24] = "LT";
-  TokenType2[TokenType2["LTEQ"] = 25] = "LTEQ";
-  TokenType2[TokenType2["GT"] = 26] = "GT";
-  TokenType2[TokenType2["GTEQ"] = 27] = "GTEQ";
-  TokenType2[TokenType2["BAR"] = 28] = "BAR";
-  TokenType2[TokenType2["BARBAR"] = 29] = "BARBAR";
-  TokenType2[TokenType2["AMP"] = 30] = "AMP";
-  TokenType2[TokenType2["AMPAMP"] = 31] = "AMPAMP";
-  TokenType2[TokenType2["LPAREN"] = 32] = "LPAREN";
-  TokenType2[TokenType2["RPAREN"] = 33] = "RPAREN";
-  TokenType2[TokenType2["LBRACE"] = 34] = "LBRACE";
-  TokenType2[TokenType2["RBRACE"] = 35] = "RBRACE";
-  TokenType2[TokenType2["LBRACKET"] = 36] = "LBRACKET";
-  TokenType2[TokenType2["RBRACKET"] = 37] = "RBRACKET";
-  TokenType2[TokenType2["COMMA"] = 38] = "COMMA";
-  TokenType2[TokenType2["COLON"] = 39] = "COLON";
-  TokenType2[TokenType2["SEMICOLON"] = 40] = "SEMICOLON";
-  TokenType2[TokenType2["META_BLOCK"] = 41] = "META_BLOCK";
-  TokenType2[TokenType2["CLOSE_META_BLOCK"] = 42] = "CLOSE_META_BLOCK";
-  TokenType2[TokenType2["EOF"] = 43] = "EOF";
-  return TokenType2;
-})(TokenType || {});
-
-// vendor/dsl/parser/ast/value-expression.ts
-var ValueExpression = class {
-  static {
-    __name(this, "ValueExpression");
-  }
-  value;
-  token;
-  constructor(value, token) {
-    this.token = token;
-    if (token.getType() === 0 /* NUMBER */) {
-      this.value = new NumberValue(parseFloat(value));
-      return;
-    }
-    if (token.getType() === 2 /* TEXT */) {
-      this.value = new StringValue(value);
-      return;
-    }
-    throw new Error(`Unrecognized value. ${token}`);
-  }
-  eval() {
-    return this.value;
-  }
-  toString() {
-    return `${this.value.asString()}`;
-  }
-};
-
-// vendor/dsl/parser/lib/undefined-value.ts
-var UndefinedValue = class _UndefinedValue {
-  static {
-    __name(this, "UndefinedValue");
-  }
-  static UNDEFINED = new _UndefinedValue();
-  clone() {
-    return _UndefinedValue.UNDEFINED;
-  }
-  asNumber() {
-    return NaN;
-  }
-  asString() {
-    return "undefined";
-  }
-  toString() {
-    return this.asString();
-  }
-};
-
-// vendor/dsl/parser/ast/var-statement.ts
-var VarStatement = class {
-  static {
-    __name(this, "VarStatement");
-  }
-  declarators;
-  token;
-  constructor(declarators, token) {
-    this.declarators = declarators;
-    this.token = token;
-  }
-  execute() {
-    for (const declarator of this.declarators) {
-      if (declarator.init) {
-        const value = declarator.init.eval();
-        Variables.set(declarator.name, value);
-      } else {
-        Variables.set(declarator.name, UndefinedValue.UNDEFINED);
-      }
-    }
-  }
-  toString() {
-    const decls = this.declarators.map((d) => d.init ? `${d.name} = ${d.init}` : d.name).join(", ");
-    return `var ${decls}`;
-  }
-};
-
-// vendor/dsl/parser/ast/variable-expression.ts
-var VariableExpression = class {
-  static {
-    __name(this, "VariableExpression");
-  }
-  name;
-  token;
-  constructor(name, token) {
-    this.name = name;
-    this.token = token;
-  }
-  eval() {
-    if (!Variables.isExists(this.name)) {
-      throw new Error(`Constant ${this.name} does not exist!`);
-    }
-    return Variables.get(this.name);
-  }
-  getName() {
-    return this.name;
-  }
-  toString() {
-    return `${this.name}`;
-  }
-};
-
-// vendor/dsl/parser/ast/while-statement.ts
-var WhileStatement = class {
-  static {
-    __name(this, "WhileStatement");
-  }
-  condition;
-  statement;
-  token;
-  constructor(expression, statement, token) {
-    this.condition = expression;
-    this.statement = statement;
-    this.token = token;
-  }
-  execute() {
-    while (this.condition.eval().asNumber() != 0) {
-      try {
-        this.statement.execute();
-      } catch (e) {
-        if (e instanceof BreakStatement) {
-          break;
-        } else if (e instanceof ContinueStatement) {
-        } else {
-          throw e;
-        }
-      }
-    }
-  }
-  toString() {
-    return `while (${this.condition})
-{
-${this.statement}
-}`;
-  }
-};
-
-// src/dsl/return-signal.ts
-var ReturnSignal = class extends Error {
-  constructor(value) {
-    super("ReturnSignal");
-    this.value = value;
-    this.name = "ReturnSignal";
-  }
-  value;
-  static {
-    __name(this, "ReturnSignal");
-  }
-};
-
-// src/dsl/user-function-resolver.ts
-var UserFunctionResolver = class {
-  static {
-    __name(this, "UserFunctionResolver");
-  }
-  fns = /* @__PURE__ */ new Map();
-  register(fnDef, source) {
-    if (this.fns.has(fnDef.name)) {
-      const existing = this.fns.get(fnDef.name);
-      const existingTok = existing.token?.getLine?.();
-      throw new Error(
-        `Duplicate user function "${fnDef.name}"` + (existingTok ? ` (already defined at line ${existingTok}${source ? ` in ${source}` : ""})` : "")
-      );
-    }
-    this.fns.set(fnDef.name, fnDef);
-  }
-  get(name) {
-    return this.fns.get(name);
-  }
-  has(name) {
-    return this.fns.has(name);
-  }
-  names() {
-    return [...this.fns.keys()].sort();
-  }
-};
-
-// src/dsl/ast-executor.ts
-var UnsupportedAstNodeError = class extends Error {
-  static {
-    __name(this, "UnsupportedAstNodeError");
-  }
-  constructor(nodeType, line, col) {
-    super(`Unsupported AST node "${nodeType}" at ${line}:${col} \u2014 not allowed by MVP DSL subset (D-4)`);
-    this.name = "UnsupportedAstNodeError";
-  }
-};
-var DEFAULT_MAX_CALL_DEPTH = 32;
-function isBlockMappable(name) {
-  return name.startsWith("test_") || name.startsWith("flow_");
-}
-__name(isBlockMappable, "isBlockMappable");
-var AstExecutor = class {
-  constructor(registry) {
-    this.registry = registry;
-  }
-  registry;
-  static {
-    __name(this, "AstExecutor");
-  }
-  /**
-   * Run the test function `testName` from the parsed AST `program`.
-   *
-   * @param program  entry scenario AST
-   * @param testName name of the entry test_/flow_ function
-   * @param runtime  per-run state container
-   * @param opts     execution options (budgets, mode)
-   * @param helpers  optional helper-file ASTs (Stage 2); their top-level
-   *                 FunctionDefineStatements are registered alongside
-   *                 the entry's helpers in the user-function resolver
-   */
-  async *run(program, testName, runtime, opts, helpers) {
-    const start = Date.now();
-    let stepsExecuted = 0;
-    const userFns = new UserFunctionResolver();
-    const programs = [program, ...helpers ?? []];
-    for (const p of programs) {
-      for (const stmt of p.statements) {
-        if (stmt instanceof FunctionDefineStatement) {
-          userFns.register(stmt);
-        }
-      }
-    }
-    const entry = userFns.get(testName);
-    if (!entry) {
-      const error = {
-        message: `Test function "${testName}" not found in scenario AST`
-      };
-      return { outcome: "failed", stepsExecuted, durationMs: Date.now() - start, error };
-    }
-    if (!(entry.body instanceof BlockStatement)) {
-      const error = {
-        message: `Test "${testName}" body is not a BlockStatement (got ${entry.body.constructor.name})`
-      };
-      return { outcome: "failed", stepsExecuted, durationMs: Date.now() - start, error };
-    }
-    if (!isBlockMappable(testName)) {
-      const error = {
-        message: `Entry function "${testName}" must start with test_ or flow_`
-      };
-      return { outcome: "failed", stepsExecuted, durationMs: Date.now() - start, error };
-    }
-    const getSteps = /* @__PURE__ */ __name(() => stepsExecuted, "getSteps");
-    const setSteps = /* @__PURE__ */ __name((n) => {
-      stepsExecuted = n;
-    }, "setSteps");
-    const callStack = [];
-    try {
-      yield* this.runBlock(entry.body, runtime, opts, getSteps, setSteps, start, userFns, callStack);
-      return { outcome: "completed", stepsExecuted, durationMs: Date.now() - start };
-    } catch (e) {
-      const error = toExecutionError(e);
-      return { outcome: "failed", stepsExecuted, durationMs: Date.now() - start, error };
-    }
-  }
-  // ---- internals ---------------------------------------------------------
-  async *runBlock(block, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack) {
-    for (const stmt of block.statements) {
-      yield* this.runStatement(stmt, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-    }
-  }
-  async *runStatement(stmt, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack) {
-    const { line, col } = locationOf(stmt);
-    const stackSnap = callStack.length === 0 ? void 0 : [...callStack];
-    yield { kind: "step-start", node: stmt, line, col, callStack: stackSnap };
-    let attempted = false;
-    while (true) {
-      this.checkBudgets(opts, getSteps(), runStartMs);
-      try {
-        yield* this.execStatement(stmt, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-        setSteps(getSteps() + 1);
-        yield { kind: "step-end", node: stmt, line, col, ok: true, callStack: stackSnap };
-        if (opts.mode === "step") yield { kind: "paused", reason: "step", line, col };
-        return;
-      } catch (e) {
-        if (e instanceof ReturnSignal) throw e;
-        const error = toExecutionError(e);
-        yield { kind: "step-end", node: stmt, line, col, ok: false, error, callStack: stackSnap };
-        if (!opts.pauseOnFailure) throw e;
-        yield { kind: "paused", reason: "failure", line, col };
-        attempted = true;
-        if (attempted) continue;
-        return;
-      }
-    }
-  }
-  async *execStatement(stmt, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack) {
-    if (stmt instanceof BlockStatement) {
-      yield* this.runBlock(stmt, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      return;
-    }
-    if (stmt instanceof AssignmentStatement) {
-      const value = yield* this.evalExpression(stmt.expression, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      runtime.setVar(stmt.variable, value);
-      return;
-    }
-    if (stmt instanceof FunctionStatement) {
-      yield* this.evalExpression(
-        stmt.functionalExpression,
-        runtime,
-        opts,
-        getSteps,
-        setSteps,
-        runStartMs,
-        userFns,
-        callStack
-      );
-      return;
-    }
-    if (stmt instanceof IfStatement) {
-      const cond = yield* this.evalExpression(stmt.expression, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      if (isTruthy(cond)) {
-        yield* this.execStatement(stmt.ifStatement, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      } else if (stmt.elseStatement) {
-        yield* this.execStatement(stmt.elseStatement, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      }
-      return;
-    }
-    if (stmt instanceof MetaBlockStatement) {
-      yield* this.execStatement(stmt.body, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      return;
-    }
-    if (stmt instanceof ReturnStatement) {
-      const expr = stmt.expression;
-      const value = yield* this.evalExpression(expr, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      throw new ReturnSignal(value);
-    }
-    if (stmt instanceof FunctionDefineStatement) {
-      const { line: line2, col: col2 } = locationOf(stmt);
-      throw new UnsupportedAstNodeError("nested FunctionDefineStatement", line2, col2);
-    }
-    if (stmt instanceof VarStatement) {
-      const { line: line2, col: col2 } = locationOf(stmt);
-      throw new UnsupportedAstNodeError("VarStatement (use bare assignment instead)", line2, col2);
-    }
-    if (stmt instanceof ForStatement || stmt instanceof WhileStatement) {
-      const { line: line2, col: col2 } = locationOf(stmt);
-      throw new UnsupportedAstNodeError(
-        stmt instanceof ForStatement ? "ForStatement" : "WhileStatement",
-        line2,
-        col2
-      );
-    }
-    const { line, col } = locationOf(stmt);
-    throw new UnsupportedAstNodeError(stmt.constructor.name, line, col);
-  }
-  async *evalExpression(expr, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack) {
-    if (expr instanceof ValueExpression) {
-      const v = expr.value;
-      if (v instanceof StringValue) return v.asString();
-      if (v instanceof NumberValue) return v.asNumber();
-      const { line: line2, col: col2 } = locationOf(expr);
-      throw new UnsupportedAstNodeError(
-        `ValueExpression payload ${v.constructor.name}`,
-        line2,
-        col2
-      );
-    }
-    if (expr instanceof VariableExpression) {
-      if (expr.name === "true") return true;
-      if (expr.name === "false") return false;
-      if (expr.name === "null") return null;
-      return runtime.getVar(expr.name);
-    }
-    if (expr instanceof FunctionalExpression) {
-      const args = [];
-      for (const a of expr.arguments) {
-        const v = yield* this.evalExpression(a, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-        args.push(v);
-      }
-      const userFn = userFns.get(expr.name);
-      if (userFn) {
-        return yield* this.callUserFunction(
-          userFn,
-          args,
-          runtime,
-          opts,
-          getSteps,
-          setSteps,
-          runStartMs,
-          userFns,
-          callStack
-        );
-      }
-      const fn = this.registry.get(expr.name);
-      if (!fn) {
-        const { line: line2, col: col2 } = locationOf(expr);
-        throw new Error(`Unknown DSL function "${expr.name}" at ${line2}:${col2}`);
-      }
-      return await fn.invoke(runtime, ...args);
-    }
-    if (expr instanceof BinaryExpression) {
-      const l = yield* this.evalExpression(expr.expr1, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      const r = yield* this.evalExpression(expr.expr2, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-      return applyBinaryOp(expr.operation, l, r);
-    }
-    if (expr instanceof ArrayExpression) {
-      const out = [];
-      for (const e of expr.elements) {
-        const v = yield* this.evalExpression(e, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-        out.push(v);
-      }
-      return out;
-    }
-    const { line, col } = locationOf(expr);
-    throw new UnsupportedAstNodeError(`expression ${expr.constructor.name}`, line, col);
-  }
-  /**
-   * Invoke a user-defined function. enterCall (maxCallDepth budget), pushScope,
-   * bind args, runBlock body, catch ReturnSignal → return value, popScope,
-   * exitCall. NOTE: does NOT increment stepsExecuted on the call itself —
-   * `stepsExecuted == count of emitted step-events`, invariant preserved.
-   */
-  async *callUserFunction(fnDef, args, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack) {
-    runtime.enterCall(opts.maxCallDepth ?? DEFAULT_MAX_CALL_DEPTH);
-    callStack.push(fnDef.name);
-    try {
-      runtime.pushScope();
-      try {
-        for (let i = 0; i < fnDef.argNames.length; i++) {
-          runtime.setVar(fnDef.argNames[i], args[i] ?? null);
-        }
-        if (!(fnDef.body instanceof BlockStatement)) {
-          throw new Error(`User function "${fnDef.name}" body is not a BlockStatement`);
-        }
-        try {
-          yield* this.runBlock(fnDef.body, runtime, opts, getSteps, setSteps, runStartMs, userFns, callStack);
-          return null;
-        } catch (e) {
-          if (e instanceof ReturnSignal) return e.value ?? null;
-          throw e;
-        }
-      } finally {
-        runtime.popScope();
-      }
-    } finally {
-      callStack.pop();
-      runtime.exitCall();
-    }
-  }
-  checkBudgets(opts, steps, runStartMs) {
-    if (opts.maxSteps !== void 0 && steps >= opts.maxSteps) {
-      throw new Error(`maxSteps budget (${opts.maxSteps}) exhausted`);
-    }
-    if (opts.maxDurationMs !== void 0 && Date.now() - runStartMs >= opts.maxDurationMs) {
-      throw new Error(`maxDurationMs budget (${opts.maxDurationMs}ms) exhausted`);
-    }
-  }
-};
-function locationOf(node) {
-  const tok = node.token;
-  if (!tok) return { line: 0, col: 0 };
-  return {
-    line: tok.getLine ? tok.getLine() : 0,
-    col: tok.getColumn ? tok.getColumn() : 0
-  };
-}
-__name(locationOf, "locationOf");
-function isTruthy(v) {
-  if (typeof v === "number") return v !== 0;
-  if (typeof v === "boolean") return v;
-  if (typeof v === "string") return v.length > 0;
-  return v != null;
-}
-__name(isTruthy, "isTruthy");
-function applyBinaryOp(op, l, r) {
-  const ln = typeof l === "number" ? l : Number(l);
-  const rn = typeof r === "number" ? r : Number(r);
-  switch (op) {
-    case "+":
-      if (typeof l === "string" || typeof r === "string") return String(l) + String(r);
-      return ln + rn;
-    case "-":
-      return ln - rn;
-    case "*":
-      return ln * rn;
-    case "/":
-      return ln / rn;
-    case "==":
-      return l === r || Number.isFinite(ln) && Number.isFinite(rn) && ln === rn;
-    case "!=":
-      return !(l === r || Number.isFinite(ln) && Number.isFinite(rn) && ln === rn);
-    case "<":
-      return ln < rn;
-    case "<=":
-      return ln <= rn;
-    case ">":
-      return ln > rn;
-    case ">=":
-      return ln >= rn;
-    case "&&":
-      return Boolean(l) && Boolean(r);
-    case "||":
-      return Boolean(l) || Boolean(r);
-    default:
-      throw new Error(`Unsupported binary operator "${op}"`);
-  }
-}
-__name(applyBinaryOp, "applyBinaryOp");
-function toExecutionError(e) {
-  if (e instanceof Error) {
-    return { message: e.message, stack: e.stack ?? "" };
-  }
-  return { message: String(e) };
-}
-__name(toExecutionError, "toExecutionError");
-
-// src/dsl/linter.ts
-var ASSERT_PREFIX = "assert";
-var UI_CALL_NAMES = /* @__PURE__ */ new Set(["tap", "type", "swipe", "pressKey", "waitFor", "appLaunch", "openDeeplink"]);
-var DslLinter = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  static {
-    __name(this, "DslLinter");
-  }
-  /**
-   * Lint a parsed scenario AST.
-   *
-   * @param ast      entry-scenario AST
-   * @param source   raw source — when present enables E7 header check
-   * @param options  cross-cutting context (user-function names, etc.)
-   */
-  lint(ast, source, options = {}) {
-    const diags = [];
-    const lines = source !== void 0 ? source.split("\n") : null;
-    const userFns = options.userFunctionNames ?? /* @__PURE__ */ new Set();
-    for (const stmt of ast.statements) {
-      if (stmt instanceof FunctionDefineStatement && isBlockMappable2(stmt.name)) {
-        if (lines !== null) this.checkBlocklyHeader(stmt, lines, diags);
-        this.lintFunctionBody(
-          stmt,
-          diags,
-          userFns,
-          /*allowReturn*/
-          false
-        );
-      } else if (stmt instanceof FunctionDefineStatement) {
-        this.lintFunctionBody(
-          stmt,
-          diags,
-          userFns,
-          /*allowReturn*/
-          true
-        );
-      } else if (stmt instanceof MetaBlockStatement) {
-      } else {
-        diags.push(diag("error", "E2", `Only function definitions allowed at top level (got ${stmt.constructor.name})`, stmt));
-      }
-    }
-    return diags;
-  }
-  /**
-   * Cross-file E8 check — duplicate user-function names + shadowing
-   * built-ins. Run ONCE per scenario load (not per file) using the
-   * full origin list from ScenarioLoader.userFunctionOrigins.
-   *
-   * Each diagnostic is anchored to a specific origin (with path/line/col),
-   * so production callers print "_helpers/seed.js:12:1 [E8] ...".
-   */
-  lintCrossFile(origins) {
-    const diags = [];
-    const byName = /* @__PURE__ */ new Map();
-    for (const o of origins) {
-      const list = byName.get(o.name) ?? [];
-      list.push(o);
-      byName.set(o.name, list);
-    }
-    for (const [name, list] of byName) {
-      if (this.deps.registry.has(name)) {
-        for (const o of list) {
-          diags.push({
-            severity: "error",
-            code: "E8",
-            message: `User function "${name}" shadows a built-in DSL function. Rename it.`,
-            line: o.line,
-            col: o.col,
-            source: o.source
-          });
-        }
-        continue;
-      }
-      if (list.length > 1) {
-        const where = list.map((o) => `${o.source}:${o.line}`).join(", ");
-        for (const o of list) {
-          diags.push({
-            severity: "error",
-            code: "E8",
-            message: `Duplicate user function "${name}". Defined at: ${where}`,
-            line: o.line,
-            col: o.col,
-            source: o.source
-          });
-        }
-      }
-    }
-    return diags;
-  }
-  /**
-   * Lint a helper file. Same rules as scenario, but:
-   *   - No E7 header check (helpers aren't block-mappable)
-   *   - `return` allowed in any function body
-   *   - All diagnostics tagged with helper.path
-   */
-  lintHelper(helper, options = {}) {
-    const diags = [];
-    const userFns = options.userFunctionNames ?? /* @__PURE__ */ new Set();
-    for (const stmt of helper.ast.statements) {
-      if (stmt instanceof FunctionDefineStatement) {
-        if (isBlockMappable2(stmt.name)) {
-          this.lintFunctionBody(
-            stmt,
-            diags,
-            userFns,
-            /*allowReturn*/
-            false
-          );
-        } else {
-          this.lintFunctionBody(
-            stmt,
-            diags,
-            userFns,
-            /*allowReturn*/
-            true
-          );
-        }
-      } else if (stmt instanceof MetaBlockStatement) {
-      } else {
-        diags.push(diag("error", "E2", `Only function definitions allowed at top level (got ${stmt.constructor.name})`, stmt));
-      }
-    }
-    return diags.map((d) => ({ ...d, source: helper.path }));
-  }
-  // ---- internals --------------------------------------------------------
-  checkBlocklyHeader(fn, lines, diags) {
-    const fnLine = fn.token?.getLine?.() ?? 0;
-    if (fnLine <= 3) {
-      diags.push(diag("error", "E7", `${fn.name}: missing 3-comment Blockly header (// id-<slug>, // <name>, // #<color>) immediately above the function definition`, fn));
-      return;
-    }
-    const idLine = lines[fnLine - 4];
-    const nameLine = lines[fnLine - 3];
-    const colorLine = lines[fnLine - 2];
-    const allComments = [idLine, nameLine, colorLine].every(
-      (l) => typeof l === "string" && l.trimStart().startsWith("//")
-    );
-    if (!allComments) {
-      diags.push(diag("error", "E7", `${fn.name}: 3 comment lines must immediately precede the function (// id-<slug>, // <name>, // #<color>) \u2014 no blank line in between`, fn));
-    }
-  }
-  lintFunctionBody(fn, diags, userFns, allowReturn) {
-    if (!(fn.body instanceof BlockStatement)) {
-      diags.push(diag("error", "E2", `Function "${fn.name}" body must be a block`, fn));
-      return;
-    }
-    let firstUiSeen = false;
-    let firstAssertSeen = false;
-    const recordCall = /* @__PURE__ */ __name((name) => {
-      if (UI_CALL_NAMES.has(name)) firstUiSeen = true;
-      if (name.startsWith(ASSERT_PREFIX)) firstAssertSeen = true;
-    }, "recordCall");
-    for (const stmt of fn.body.statements) {
-      this.checkStatement(stmt, diags, recordCall, () => firstUiSeen, userFns, allowReturn);
-    }
-    void firstAssertSeen;
-  }
-  checkStatement(stmt, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
-    if (stmt instanceof ReturnStatement) {
-      if (!allowReturn) {
-        diags.push(diag("error", "E2", `'return' is not allowed inside test_*/flow_* function bodies (only in helpers)`, stmt));
-        return;
-      }
-      const expr = stmt.expression;
-      if (expr) this.checkExpression(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (this.isForbiddenStatement(stmt)) {
-      diags.push(diag("error", "E2", `Forbidden statement type "${stmt.constructor.name}" (D-4 subset)`, stmt));
-      return;
-    }
-    if (stmt instanceof AssignmentStatement) {
-      this.checkExpression(stmt.expression, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (stmt instanceof FunctionStatement) {
-      this.checkCall(stmt.functionalExpression, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (stmt instanceof IfStatement) {
-      this.checkExpression(stmt.expression, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      this.checkStatement(stmt.ifStatement, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      if (stmt.elseStatement) this.checkStatement(stmt.elseStatement, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (stmt instanceof BlockStatement) {
-      for (const s of stmt.statements) this.checkStatement(s, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (stmt instanceof FunctionDefineStatement) {
-      diags.push(diag("error", "E2", "Nested function definitions are not allowed", stmt));
-      return;
-    }
-    if (stmt instanceof MetaBlockStatement) return;
-    diags.push(diag("error", "E2", `Unsupported statement "${stmt.constructor.name}"`, stmt));
-  }
-  checkExpression(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
-    if (expr instanceof FunctionalExpression) {
-      this.checkCall(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (expr instanceof BinaryExpression) {
-      this.checkExpression(expr.expr1, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      this.checkExpression(expr.expr2, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (expr instanceof ArrayExpression) {
-      for (const e of expr.elements) this.checkExpression(e, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-      return;
-    }
-    if (expr instanceof ValueExpression || expr instanceof VariableExpression) return;
-    if (this.isForbiddenExpression(expr)) {
-      diags.push(diag("error", "E2", `Forbidden expression "${expr.constructor.name}" (D-4 subset)`, expr));
-      return;
-    }
-    diags.push(diag("error", "E2", `Unsupported expression "${expr.constructor.name}"`, expr));
-  }
-  checkCall(call, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
-    const name = call.name;
-    if (!this.deps.registry.has(name) && !userFns.has(name)) {
-      diags.push(diag("error", "E1", `Unknown DSL function "${name}"`, call));
-    }
-    const fn = this.deps.registry.get(name);
-    if (fn) {
-      this.checkArity(call, fn, diags);
-      this.checkArgTypes(call, fn, diags);
-    }
-    if (name === "setDevice" && call.arguments.length > 0) {
-      const arg0 = call.arguments[0];
-      if (arg0 instanceof ValueExpression) {
-        const val = arg0.value.asString?.call(arg0.value);
-        if (typeof val === "string" && !this.deps.knownSlots.includes(val)) {
-          diags.push(
-            diag("error", "E3", `setDevice("${val}"): unknown slot. Known: ${this.deps.knownSlots.join(", ") || "(none)"}`, call)
-          );
-        }
-      }
-    }
-    if (name === "apiCall" && call.arguments.length > 0) {
-      const jsonArgIdx = 2;
-      const jsonArg = call.arguments[jsonArgIdx];
-      if (jsonArg instanceof ValueExpression) {
-        const val = jsonArg.value.asString?.call(jsonArg.value);
-        if (typeof val === "string") {
-          try {
-            JSON.parse(val);
-          } catch (e) {
-            diags.push(
-              diag("error", "E4", `${name}: arg ${jsonArgIdx} is not valid JSON \u2014 ${e.message}`, call)
-            );
-          }
-        }
-      }
-    }
-    if (name.startsWith(ASSERT_PREFIX) && !isFirstUiSeen()) {
-      diags.push(diag("warning", "W5", `${name}() called before any UI action \u2014 typo or wrong order?`, call));
-    }
-    recordCall(name);
-    for (const arg of call.arguments) {
-      this.checkExpression(arg, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
-    }
-  }
-  checkArity(call, fn, diags) {
-    const max = fn.argTypes.length;
-    const min = fn.minArgs ?? max;
-    const got = call.arguments.length;
-    if (got < min) {
-      diags.push(
-        diag(
-          "error",
-          "E5",
-          `${fn.name}(): expected ${min === max ? `${min}` : `at least ${min}`} arg${min === 1 ? "" : "s"}, got ${got}`,
-          call
-        )
-      );
-      return;
-    }
-    if (!fn.variadic && got > max) {
-      diags.push(
-        diag(
-          "error",
-          "E5",
-          `${fn.name}(): expected at most ${max} arg${max === 1 ? "" : "s"}, got ${got}`,
-          call
-        )
-      );
-    }
-  }
-  /**
-   * For each provided arg up to argTypes.length, infer its static type and
-   * compare to the declared signature. Only emits E6 when the inferred type
-   * is UNAMBIGUOUS — we never flag "any" sources (variables, helper-call
-   * results, BinaryExpression, ArrayExpression).
-   */
-  checkArgTypes(call, fn, diags) {
-    const limit = Math.min(call.arguments.length, fn.argTypes.length);
-    for (let i = 0; i < limit; i++) {
-      const expected = fn.argTypes[i];
-      if (expected === "any") continue;
-      const inferred = this.inferExprType(call.arguments[i]);
-      if (inferred === "any") continue;
-      if (inferred === expected) continue;
-      if (expected === "boolean" && inferred === "number" || expected === "number" && inferred === "boolean") {
-        continue;
-      }
-      diags.push(
-        diag(
-          "error",
-          "E6",
-          `${fn.name}(): arg ${i} expected ${expected}, got ${describeInferred(call.arguments[i], inferred)}`,
-          call
-        )
-      );
-    }
-  }
-  /** Best-effort static type for an expression node. "any" = unknown. */
-  inferExprType(expr) {
-    if (expr instanceof ValueExpression) {
-      const v = expr.value;
-      if (v instanceof StringValue) return "string";
-      if (v instanceof NumberValue) return "number";
-      return "any";
-    }
-    if (expr instanceof VariableExpression) {
-      if (expr.name === "true" || expr.name === "false") return "boolean";
-      return "any";
-    }
-    if (expr instanceof FunctionalExpression) {
-      const callee = this.deps.registry.get(expr.name);
-      return callee ? callee.returnType : "any";
-    }
-    return "any";
-  }
-  isForbiddenStatement(stmt) {
-    return stmt instanceof ForStatement || stmt instanceof WhileStatement || stmt instanceof DoWhileStatement || stmt instanceof VarStatement || stmt instanceof PrintStatement || stmt instanceof BreakStatement || stmt instanceof ContinueStatement || stmt instanceof IncrementStatement || stmt instanceof ArrayAssignmentStatement;
-  }
-  isForbiddenExpression(expr) {
-    return expr instanceof IncrementExpression || expr instanceof UnaryExpression || expr instanceof ConditionalExpression || expr instanceof ObjectExpression || expr instanceof ArrayAccessExpression;
-  }
-};
-function isBlockMappable2(name) {
-  return name.startsWith("test_") || name.startsWith("flow_");
-}
-__name(isBlockMappable2, "isBlockMappable");
-function describeInferred(expr, inferred) {
-  if (expr instanceof FunctionalExpression) {
-    return `${inferred} (${expr.name}() returns ${inferred})`;
-  }
-  if (expr instanceof ValueExpression) {
-    return `${inferred} literal`;
-  }
-  if (expr instanceof VariableExpression && (expr.name === "true" || expr.name === "false")) {
-    return `boolean literal \`${expr.name}\``;
-  }
-  return inferred;
-}
-__name(describeInferred, "describeInferred");
-function diag(severity, code, message, node) {
-  const tok = node.token;
-  return {
-    severity,
-    code,
-    message,
-    line: tok?.getLine ? tok.getLine() : 0,
-    col: tok?.getColumn ? tok.getColumn() : 0
-  };
-}
-__name(diag, "diag");
-
-// src/dsl/function-registry.ts
-var FunctionRegistry = class {
-  static {
-    __name(this, "FunctionRegistry");
-  }
-  map = /* @__PURE__ */ new Map();
-  register(fn) {
-    if (this.map.has(fn.name)) {
-      throw new Error(`Duplicate DSL function: ${fn.name}`);
-    }
-    this.map.set(fn.name, fn);
-  }
-  has(name) {
-    return this.map.has(name);
-  }
-  get(name) {
-    return this.map.get(name);
-  }
-  names() {
-    return [...this.map.keys()].sort();
-  }
-};
-
-// src/dsl/functions/alerts.ts
-function asString(x, fn, idx) {
-  if (typeof x !== "string") throw new Error(`${fn}(): arg ${idx} must be a string. Got ${typeof x}.`);
-  return x;
-}
-__name(asString, "asString");
-var acceptAlert = {
-  name: "acceptAlert",
-  argTypes: ["string"],
-  returnType: "void",
-  minArgs: 0,
-  invoke: /* @__PURE__ */ __name(async (runtime, buttonArg) => {
-    const button = buttonArg !== void 0 ? asString(buttonArg, "acceptAlert", 0) : void 0;
-    await runtime.driver.acceptAlert(runtime.currentDeviceSlot, button);
-  }, "invoke")
-};
-var dismissAlert = {
-  name: "dismissAlert",
-  argTypes: [],
-  returnType: "void",
-  invoke: /* @__PURE__ */ __name(async (runtime) => {
-    await runtime.driver.dismissAlert(runtime.currentDeviceSlot);
-  }, "invoke")
-};
-var readAlert = {
-  name: "readAlert",
-  argTypes: [],
-  returnType: "string",
-  invoke: /* @__PURE__ */ __name(async (runtime) => {
-    const { text } = await runtime.driver.readAlert(runtime.currentDeviceSlot);
-    return text;
-  }, "invoke")
-};
-var ALERT_FUNCTIONS = [acceptAlert, dismissAlert, readAlert];
-
-// src/dsl/functions/asserts.ts
-function asSelector(x, fn, idx) {
-  if (typeof x !== "object" || x === null) {
-    throw new Error(`${fn}(): arg ${idx} must be a Selector. Got ${typeof x}.`);
-  }
-  return x;
-}
-__name(asSelector, "asSelector");
-function asNumber(x, fn, idx) {
-  if (typeof x !== "number") throw new Error(`${fn}(): arg ${idx} must be a number. Got ${typeof x}.`);
-  return x;
-}
-__name(asNumber, "asNumber");
-var assertEqual = {
-  name: "assertEqual",
-  argTypes: ["any", "any"],
-  returnType: "void",
-  invoke: /* @__PURE__ */ __name((_runtime, actual, expected) => {
-    if (actual !== expected) {
-      throw new Error(
-        `assertEqual failed: actual ${JSON.stringify(actual)} !== expected ${JSON.stringify(expected)}`
-      );
-    }
-  }, "invoke")
-};
-var assertVisible = {
-  name: "assertVisible",
-  argTypes: ["selector"],
-  returnType: "void",
-  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg) => {
-    const selector = asSelector(selectorArg, "assertVisible", 0);
-    const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
-    const r = runtime.selectorResolver.resolve(tree, selector);
-    if (!r.ok) {
-      throw new Error(
-        `assertVisible failed: ${r.reason}
-  selector: ${JSON.stringify(selector)}
-  candidates: ${JSON.stringify(r.candidates).slice(0, 600)}`
-      );
-    }
-  }, "invoke")
-};
-var assertCount = {
-  name: "assertCount",
-  argTypes: ["selector", "number"],
-  returnType: "void",
-  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg, expectedArg) => {
-    const selector = asSelector(selectorArg, "assertCount", 0);
-    const expected = asNumber(expectedArg, "assertCount", 1);
-    const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
-    let count = 0;
-    while (true) {
-      const probe = { ...selector, ordinal: count };
-      const r = runtime.selectorResolver.resolve(tree, probe);
-      if (!r.ok) break;
-      count++;
-      if (count > 1e3) {
-        throw new Error(`assertCount: aborting after 1000 \u2014 selector too broad`);
-      }
-    }
-    if (count !== expected) {
-      throw new Error(
-        `assertCount failed: ${JSON.stringify(selector)} matched ${count} time(s), expected ${expected}`
-      );
-    }
-  }, "invoke")
-};
-async function assertEnabledState(runtime, selectorArg, expected, fnName) {
-  const selector = asSelector(selectorArg, fnName, 0);
-  const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
-  const r = runtime.selectorResolver.resolve(tree, selector);
-  if (!r.ok) {
-    throw new Error(
-      `${fnName} failed: selector did not match. ${r.reason}
-  selector: ${JSON.stringify(selector)}`
-    );
-  }
-  const node = r.node;
-  if (node.enabled === void 0) {
-    throw new Error(
-      `${fnName} failed: matched node does not report 'enabled' (likely a non-interactive widget or RN-side accessibility gap). Selector: ${JSON.stringify(selector)}`
-    );
+  const node = r.node;
+  if (node.enabled === void 0) {
+    throw new Error(
+      `${fnName} failed: matched node does not report 'enabled' (likely a non-interactive widget or RN-side accessibility gap). Selector: ${JSON.stringify(selector)}`
+    );
   }
   if (node.enabled !== expected) {
     throw new Error(
@@ -4494,47 +2843,319 @@ var pressKey = {
     if (key !== "back" && key !== "home" && key !== "enter" && key !== "escape") {
       throw new Error(`pressKey(): key must be 'back'|'home'|'enter'|'escape'. Got "${key}".`);
     }
-    await runtime.driver.pressKey(runtime.currentDeviceSlot, key);
-  }, "invoke")
-};
-var waitFor = {
-  name: "waitFor",
-  argTypes: ["selector", "number"],
-  returnType: "void",
-  minArgs: 1,
-  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg, timeoutMsArg) => {
-    const selector = asSelector2(selectorArg, "waitFor", 0);
-    const timeoutMs = timeoutMsArg === void 0 ? runtime.envConfig.defaultWaitForTimeoutMs : asNumber2(timeoutMsArg, "waitFor", 1);
-    await pollUntilFound(runtime, selector, timeoutMs);
-  }, "invoke")
-};
-var pause = {
-  name: "pause",
-  argTypes: ["number"],
-  returnType: "void",
-  invoke: /* @__PURE__ */ __name(async (_runtime, msArg) => {
-    const ms = asNumber2(msArg, "pause", 0);
-    await wait(ms);
-  }, "invoke")
+    await runtime.driver.pressKey(runtime.currentDeviceSlot, key);
+  }, "invoke")
+};
+var waitFor = {
+  name: "waitFor",
+  argTypes: ["selector", "number"],
+  returnType: "void",
+  minArgs: 1,
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg, timeoutMsArg) => {
+    const selector = asSelector2(selectorArg, "waitFor", 0);
+    const timeoutMs = timeoutMsArg === void 0 ? runtime.envConfig.defaultWaitForTimeoutMs : asNumber2(timeoutMsArg, "waitFor", 1);
+    await pollUntilFound(runtime, selector, timeoutMs);
+  }, "invoke")
+};
+var pause = {
+  name: "pause",
+  argTypes: ["number"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (_runtime, msArg) => {
+    const ms = asNumber2(msArg, "pause", 0);
+    await wait(ms);
+  }, "invoke")
+};
+var UI_FUNCTIONS = [tap, type_, swipe, pressKey, waitFor, pause];
+
+// src/dsl/functions/index.ts
+var ALL_DSL_FUNCTIONS = [
+  ...DEVICE_FUNCTIONS,
+  ...UI_FUNCTIONS,
+  ...SELECTOR_FUNCTIONS,
+  ...ALERT_FUNCTIONS,
+  ...DATA_FUNCTIONS,
+  ...ASSERT_FUNCTIONS,
+  ...TIME_FUNCTIONS
+];
+function buildDefaultRegistry() {
+  const reg = new FunctionRegistry();
+  for (const fn of ALL_DSL_FUNCTIONS) reg.register(fn);
+  return reg;
+}
+__name(buildDefaultRegistry, "buildDefaultRegistry");
+
+// src/dsl/linter.ts
+var ASSERT_PREFIX = "assert";
+var UI_CALL_NAMES = /* @__PURE__ */ new Set(["tap", "type", "swipe", "pressKey", "waitFor", "appLaunch", "openDeeplink"]);
+var DslLinter = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  static {
+    __name(this, "DslLinter");
+  }
+  /**
+   * Lint a parsed scenario AST: mobile-specific pass + the shared
+   * validator engine over the same tree.
+   *
+   * @param ast      entry-scenario AST
+   * @param source   raw source — the engine's validation session reads it
+   * @param options  cross-cutting context (user-function names, etc.)
+   */
+  lint(ast, source, options = {}) {
+    const diags = [];
+    const userFns = options.userFunctionNames ?? /* @__PURE__ */ new Set();
+    for (const stmt of ast.statements) {
+      if (stmt instanceof FunctionDefineStatement && isBlockMappable(stmt.name)) {
+        this.lintFunctionBody(
+          stmt,
+          diags,
+          userFns,
+          /*allowReturn*/
+          false
+        );
+      } else if (stmt instanceof FunctionDefineStatement) {
+        this.lintFunctionBody(
+          stmt,
+          diags,
+          userFns,
+          /*allowReturn*/
+          true
+        );
+      } else if (stmt instanceof MetaBlockStatement) {
+      } else {
+        diags.push(diag("error", "E2", `Only function definitions allowed at top level (got ${stmt.constructor.name})`, stmt));
+      }
+    }
+    diags.push(...this.runEngine(ast, source ?? "", userFns));
+    return diags;
+  }
+  /**
+   * Cross-file E8 check — duplicate user-function names + shadowing
+   * built-ins. Run ONCE per scenario load (not per file) using the
+   * full origin list from ScenarioLoader.userFunctionOrigins.
+   *
+   * Each diagnostic is anchored to a specific origin (with path/line/col),
+   * so production callers print "_helpers/seed.js:12:1 [E8] ...".
+   */
+  lintCrossFile(origins) {
+    const diags = [];
+    const byName = /* @__PURE__ */ new Map();
+    for (const o of origins) {
+      const list = byName.get(o.name) ?? [];
+      list.push(o);
+      byName.set(o.name, list);
+    }
+    for (const [name, list] of byName) {
+      if (this.deps.registry.has(name)) {
+        for (const o of list) {
+          diags.push({
+            severity: "error",
+            code: "E8",
+            message: `User function "${name}" shadows a built-in DSL function. Rename it.`,
+            line: o.line,
+            col: o.col,
+            source: o.source
+          });
+        }
+        continue;
+      }
+      if (list.length > 1) {
+        const where = list.map((o) => `${o.source}:${o.line}`).join(", ");
+        for (const o of list) {
+          diags.push({
+            severity: "error",
+            code: "E8",
+            message: `Duplicate user function "${name}". Defined at: ${where}`,
+            line: o.line,
+            col: o.col,
+            source: o.source
+          });
+        }
+      }
+    }
+    return diags;
+  }
+  /**
+   * Lint a helper file. Same two layers as a scenario, but `return` is
+   * allowed in any non-entry function body and all diagnostics are
+   * tagged with helper.path.
+   */
+  lintHelper(helper, options = {}) {
+    const diags = [];
+    const userFns = options.userFunctionNames ?? /* @__PURE__ */ new Set();
+    for (const stmt of helper.ast.statements) {
+      if (stmt instanceof FunctionDefineStatement) {
+        if (isBlockMappable(stmt.name)) {
+          this.lintFunctionBody(
+            stmt,
+            diags,
+            userFns,
+            /*allowReturn*/
+            false
+          );
+        } else {
+          this.lintFunctionBody(
+            stmt,
+            diags,
+            userFns,
+            /*allowReturn*/
+            true
+          );
+        }
+      } else if (stmt instanceof MetaBlockStatement) {
+      } else {
+        diags.push(diag("error", "E2", `Only function definitions allowed at top level (got ${stmt.constructor.name})`, stmt));
+      }
+    }
+    diags.push(...this.runEngine(helper.ast, helper.source ?? "", userFns));
+    return diags.map((d) => ({ ...d, source: helper.path }));
+  }
+  // ---- shared engine ------------------------------------------------------
+  /** Run the `@unotest/dsl/validator` engine with the mobile contracts.
+   *  Engine diagnostics map 1:1 into mobile `Diagnostic` rows with
+   *  `validator:<rule>` codes. */
+  runEngine(ast, source, userFns) {
+    const registry = new MobileDslRegistry(ALL_DSL_FUNCTIONS, userFns);
+    return validateDsl(ast, source, false, registry, {
+      disabledRules: MOBILE_DISABLED_ENGINE_RULES
+    }).map((d) => ({
+      severity: d.severity,
+      code: `validator:${d.rule}`,
+      message: d.message,
+      line: d.line ?? 0,
+      col: d.column ?? 0
+    }));
+  }
+  // ---- mobile-specific pass ----------------------------------------------
+  lintFunctionBody(fn, diags, userFns, allowReturn) {
+    if (!(fn.body instanceof BlockStatement)) {
+      diags.push(diag("error", "E2", `Function "${fn.name}" body must be a block`, fn));
+      return;
+    }
+    let firstUiSeen = false;
+    const recordCall = /* @__PURE__ */ __name((name) => {
+      if (UI_CALL_NAMES.has(name)) firstUiSeen = true;
+    }, "recordCall");
+    for (const stmt of fn.body.statements) {
+      this.checkStatement(stmt, diags, recordCall, () => firstUiSeen, userFns, allowReturn);
+    }
+  }
+  checkStatement(stmt, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
+    if (stmt instanceof ReturnStatement) {
+      if (!allowReturn) {
+        diags.push(diag("error", "E2", `'return' is not allowed inside test_*/flow_* function bodies (only in helpers)`, stmt));
+        return;
+      }
+      const expr = stmt.expression;
+      if (expr) this.checkExpression(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (this.isForbiddenStatement(stmt)) {
+      diags.push(diag("error", "E2", `Forbidden statement type "${stmt.constructor.name}" (D-4 subset)`, stmt));
+      return;
+    }
+    if (stmt instanceof AssignmentStatement) {
+      this.checkExpression(stmt.expression, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (stmt instanceof FunctionStatement) {
+      const call = stmt.functionalExpression;
+      if (!(call instanceof FunctionalExpression)) {
+        diags.push(diag("error", "E2", `Method chains are not allowed (D-4 subset)`, stmt));
+        return;
+      }
+      this.checkCall(call, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (stmt instanceof StepStatement) {
+      this.checkStatement(stmt.body, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (stmt instanceof IfStatement) {
+      this.checkExpression(stmt.expression, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      this.checkStatement(stmt.ifStatement, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      if (stmt.elseStatement) this.checkStatement(stmt.elseStatement, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (stmt instanceof BlockStatement) {
+      for (const s of stmt.statements) this.checkStatement(s, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (stmt instanceof FunctionDefineStatement) {
+      diags.push(diag("error", "E2", "Nested function definitions are not allowed", stmt));
+      return;
+    }
+    if (stmt instanceof MetaBlockStatement) return;
+    diags.push(diag("error", "E2", `Unsupported statement "${stmt.constructor.name}"`, stmt));
+  }
+  checkExpression(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
+    if (expr instanceof FunctionalExpression) {
+      this.checkCall(expr, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (expr instanceof BinaryExpression) {
+      this.checkExpression(expr.expr1, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      this.checkExpression(expr.expr2, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (expr instanceof ArrayExpression) {
+      for (const e of expr.elements) this.checkExpression(e, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+      return;
+    }
+    if (expr instanceof ValueExpression || expr instanceof VariableExpression) return;
+    if (this.isForbiddenExpression(expr)) {
+      diags.push(diag("error", "E2", `Forbidden expression "${expr.constructor.name}" (D-4 subset)`, expr));
+      return;
+    }
+    diags.push(diag("error", "E2", `Unsupported expression "${expr.constructor.name}"`, expr));
+  }
+  checkCall(call, diags, recordCall, isFirstUiSeen, userFns, allowReturn) {
+    const name = call.name;
+    if (name === "setDevice" && call.arguments.length > 0) {
+      const arg0 = call.arguments[0];
+      if (arg0 instanceof ValueExpression) {
+        const val = arg0.value.asString?.call(arg0.value);
+        if (typeof val === "string" && !this.deps.knownSlots.includes(val)) {
+          diags.push(
+            diag("error", "E3", `setDevice("${val}"): unknown slot. Known: ${this.deps.knownSlots.join(", ") || "(none)"}`, call)
+          );
+        }
+      }
+    }
+    if (name.startsWith(ASSERT_PREFIX) && !isFirstUiSeen()) {
+      diags.push(diag("warning", "W5", `${name}() called before any UI action \u2014 typo or wrong order?`, call));
+    }
+    recordCall(name);
+    for (const arg of call.arguments) {
+      this.checkExpression(arg, diags, recordCall, isFirstUiSeen, userFns, allowReturn);
+    }
+  }
+  isForbiddenStatement(stmt) {
+    return stmt instanceof ForStatement || stmt instanceof WhileStatement || stmt instanceof DoWhileStatement || stmt instanceof VarStatement || stmt instanceof PrintStatement || stmt instanceof BreakStatement || stmt instanceof ContinueStatement || stmt instanceof IncrementStatement || stmt instanceof ArrayAssignmentStatement;
+  }
+  isForbiddenExpression(expr) {
+    return expr instanceof IncrementExpression || expr instanceof UnaryExpression || expr instanceof ConditionalExpression || expr instanceof ObjectExpression || expr instanceof ArrayAccessExpression || // Post-vendor @unotest/dsl extensions the mobile frozen subset rejects.
+    expr instanceof MemberCallExpression || expr instanceof PropertyAccessExpression;
+  }
 };
-var UI_FUNCTIONS = [tap, type_, swipe, pressKey, waitFor, pause];
-
-// src/dsl/functions/index.ts
-var ALL_DSL_FUNCTIONS = [
-  ...DEVICE_FUNCTIONS,
-  ...UI_FUNCTIONS,
-  ...SELECTOR_FUNCTIONS,
-  ...ALERT_FUNCTIONS,
-  ...DATA_FUNCTIONS,
-  ...ASSERT_FUNCTIONS,
-  ...TIME_FUNCTIONS
-];
-function buildDefaultRegistry() {
-  const reg = new FunctionRegistry();
-  for (const fn of ALL_DSL_FUNCTIONS) reg.register(fn);
-  return reg;
+function isBlockMappable(name) {
+  return name.startsWith("test_") || name.startsWith("flow_");
 }
-__name(buildDefaultRegistry, "buildDefaultRegistry");
+__name(isBlockMappable, "isBlockMappable");
+function diag(severity, code, message, node) {
+  const tok = node.token;
+  return {
+    severity,
+    code,
+    message,
+    line: tok?.getLine ? tok.getLine() : 0,
+    col: tok?.getColumn ? tok.getColumn() : 0
+  };
+}
+__name(diag, "diag");
 
 // src/dsl/test-runtime-manager.ts
 var TestRuntimeManager = class {
@@ -4695,849 +3316,77 @@ var TestRuntimeManager = class {
     if (!active.ttlTimer) return;
     const clear = this.deps.clearTimeoutFn ?? clearTimeout;
     clear(active.ttlTimer);
-    active.ttlTimer = null;
-  }
-  requireActive(id) {
-    const a = this.runtimes.get(id);
-    if (!a) throw new Error(`Runtime "${id}" not found (already aborted or never started)`);
-    return a;
-  }
-};
-
-// src/runner/fs-scenario-repository.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { readdir } from "fs/promises";
-import { dirname as dirname2, resolve, join as join2, sep } from "path";
-var FileSystemScenarioRepository = class {
-  static {
-    __name(this, "FileSystemScenarioRepository");
-  }
-  scenariosDir;
-  constructor(deps) {
-    this.scenariosDir = resolve(deps.scenariosDir);
-  }
-  async list() {
-    const out = [];
-    await this.walk(this.scenariosDir, "", out);
-    return out.sort();
-  }
-  async walk(dir, relPrefix, out) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
-      const abs = join2(dir, entry.name);
-      const rel = relPrefix === "" ? entry.name : `${relPrefix}/${entry.name}`;
-      if (entry.isDirectory()) {
-        await this.walk(abs, rel, out);
-      } else if (entry.isFile() && entry.name.endsWith(".js")) {
-        out.push(rel.slice(0, -".js".length));
-      }
-    }
-  }
-  async load(name) {
-    const path = this.pathFor(name);
-    const source = readFileSync2(path, "utf8");
-    return { name, source };
-  }
-  async has(name) {
-    return existsSync2(this.pathFor(name));
-  }
-  async save(name, source, opts) {
-    const path = this.pathFor(name);
-    if (existsSync2(path) && !opts?.overwrite) {
-      throw new Error(`scenario "${name}" already exists at ${path}`);
-    }
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync(path, source);
-    return path;
-  }
-  pathFor(name) {
-    if (name.includes("..") || name.startsWith("/") || name.includes("\\")) {
-      throw new Error(`Invalid scenario name "${name}"`);
-    }
-    const relPath = name.split("/").join(sep) + ".js";
-    return join2(this.scenariosDir, relPath);
-  }
-};
-
-// vendor/dsl/parser/token.ts
-var Token = class {
-  static {
-    __name(this, "Token");
-  }
-  text;
-  type;
-  column;
-  line;
-  constructor(tokenType, text, column, line) {
-    this.type = tokenType;
-    this.text = text;
-    this.column = column;
-    this.line = line;
-  }
-  getText() {
-    return this.text;
-  }
-  getType() {
-    return this.type;
-  }
-  getLine() {
-    return this.line;
-  }
-  getColumn() {
-    return this.column;
-  }
-  // Переопределение метода toString
-  toString() {
-    return `Token(type: ${TokenType[this.type]}, text: "${this.text}", line: ${this.line}, column: ${this.column})`;
-  }
-};
-
-// vendor/dsl/parser/tools.ts
-function isNumber(char) {
-  const num = Number(char);
-  return !isNaN(num) && char.trim() === num.toString();
-}
-__name(isNumber, "isNumber");
-function isLetter(char) {
-  return /^[a-zA-Zа-яА-ЯёЁ]$/.test(char);
-}
-__name(isLetter, "isLetter");
-function isLetterInWord(char) {
-  return /^[a-zA-Zа-яА-ЯёЁ0-9_$]$/.test(char);
-}
-__name(isLetterInWord, "isLetterInWord");
-
-// vendor/dsl/parser/lexer.ts
-var Lexer = class {
-  static {
-    __name(this, "Lexer");
-  }
-  OPERATOR_CHARS = "+-*/(){}[]=<>!&|,:;";
-  OPERATORS = /* @__PURE__ */ new Map([
-    ["+", 14 /* PLUS */],
-    ["++", 15 /* PLUSPLUS */],
-    ["-", 16 /* MINUS */],
-    ["--", 17 /* MINUSMINUS */],
-    ["*", 18 /* STAR */],
-    ["/", 19 /* SLASH */],
-    ["(", 32 /* LPAREN */],
-    [")", 33 /* RPAREN */],
-    ["{", 34 /* LBRACE */],
-    ["}", 35 /* RBRACE */],
-    ["[", 36 /* LBRACKET */],
-    ["]", 37 /* RBRACKET */],
-    ["=", 20 /* EQ */],
-    ["<", 24 /* LT */],
-    [">", 26 /* GT */],
-    [",", 38 /* COMMA */],
-    [":", 39 /* COLON */],
-    [";", 40 /* SEMICOLON */],
-    ["!", 22 /* EXCL */],
-    ["&", 30 /* AMP */],
-    ["|", 28 /* BAR */],
-    ["==", 21 /* EQEQ */],
-    ["!=", 23 /* EXCLEQ */],
-    ["<=", 25 /* LTEQ */],
-    [">=", 27 /* GTEQ */],
-    ["&&", 31 /* AMPAMP */],
-    ["||", 29 /* BARBAR */]
-  ]);
-  input;
-  length;
-  tokens = [];
-  pos = 0;
-  column = 1;
-  line = 1;
-  constructor(input) {
-    this.input = input;
-    this.length = input.length;
-  }
-  tokenize() {
-    while (this.pos < this.length) {
-      const current = this.peek(0);
-      if (isNumber(current)) {
-        this.tokenizeNumber();
-      } else if (isLetter(current)) {
-        this.tokenizeWord();
-      } else if (current === '"' || current === "'") {
-        this.tokenizeText(current);
-      } else if (this.peekGroup(3) === "//@") {
-        this.tokenizeMetaWord();
-      } else if (this.OPERATOR_CHARS.indexOf(current) !== -1) {
-        this.tokenizeOperator();
-      } else {
-        this.next();
-      }
-    }
-    return this.tokens;
-  }
-  next() {
-    const currentChar = this.input.charAt(this.pos);
-    this.pos++;
-    if (currentChar == "\n") {
-      this.line++;
-      this.column = 1;
-    } else {
-      this.column++;
-    }
-    return this.peek(0);
-  }
-  peek(relativePosition) {
-    const position = this.pos + relativePosition;
-    if (position >= this.length) {
-      return "\0";
-    }
-    return this.input.charAt(position);
-  }
-  peekGroup(count) {
-    const buffer = [];
-    for (let i = 0; i < count; i++) {
-      buffer.push(this.peek(i));
-    }
-    return buffer.join("");
-  }
-  addToken(type, text, column, line) {
-    this.tokens.push(new Token(type, text, column - 1, line));
-  }
-  tokenizeNumber() {
-    const column = this.column;
-    const line = this.line;
-    const buffer = [];
-    let current = this.peek(0);
-    while (current !== "\0") {
-      if (current == ".") {
-        if (buffer.indexOf(".") !== -1) {
-          throw new Error("Invalid float number");
-        }
-      } else if (!isNumber(current)) {
-        break;
-      }
-      buffer.push(current);
-      current = this.next();
-    }
-    this.addToken(0 /* NUMBER */, buffer.join(""), column, line);
-  }
-  consumeWord() {
-    const buffer = [];
-    let current = this.peek(0);
-    while (current !== "\0") {
-      if (!isLetterInWord(current)) {
-        break;
-      }
-      buffer.push(current);
-      current = this.next();
-    }
-    return buffer.join("");
-  }
-  tokenizeMetaWord() {
-    const column = this.column;
-    const line = this.line;
-    this.next();
-    this.next();
-    this.next();
-    const word = this.consumeWord();
-    if (word.startsWith("end")) {
-      this.addToken(42 /* CLOSE_META_BLOCK */, word, column, line);
-    } else {
-      this.addToken(41 /* META_BLOCK */, word, column, line);
-    }
-  }
-  tokenizeWord() {
-    const column = this.column;
-    const line = this.line;
-    const word = this.consumeWord();
-    switch (word) {
-      case "var":
-        this.addToken(3 /* VAR */, "", column, line);
-        break;
-      case "print":
-        this.addToken(4 /* PRINT */, "", column, line);
-        break;
-      case "if":
-        this.addToken(5 /* IF */, "", column, line);
-        break;
-      case "else":
-        this.addToken(6 /* ELSE */, "", column, line);
-        break;
-      case "for":
-        this.addToken(8 /* FOR */, "", column, line);
-        break;
-      case "while":
-        this.addToken(7 /* WHILE */, "", column, line);
-        break;
-      case "do":
-        this.addToken(9 /* DO */, "", column, line);
-        break;
-      case "break":
-        this.addToken(10 /* BREAK */, "", column, line);
-        break;
-      case "continue":
-        this.addToken(11 /* CONTINUE */, "", column, line);
-        break;
-      case "function":
-        this.addToken(12 /* FUNCTION */, "", column, line);
-        break;
-      case "return":
-        this.addToken(13 /* RETURN */, "", column, line);
-        break;
-      default:
-        this.addToken(1 /* WORD */, word, column, line);
-    }
-  }
-  tokenizeText(char) {
-    this.next();
-    const column = this.column;
-    const line = this.line;
-    const buffer = [];
-    let current = this.peek(0);
-    while (current !== "\0") {
-      if (current == "\\") {
-        current = this.next();
-        switch (current) {
-          case char:
-            current = this.next();
-            buffer.push(char);
-            continue;
-          case "n":
-            current = this.next();
-            buffer.push("\n");
-            continue;
-          case "t":
-            current = this.next();
-            buffer.push("	");
-            continue;
-        }
-        buffer.push("\\");
-        continue;
-      }
-      if (current == char) {
-        break;
-      }
-      buffer.push(current);
-      current = this.next();
-    }
-    if (current === "\0") {
-      throw new Error("Missing close quote in string literal");
-    }
-    this.next();
-    const text = buffer.join("");
-    this.addToken(2 /* TEXT */, text, column, line);
-  }
-  tokenizeComment() {
-    let current = this.peek(0);
-    while ("\r\n\0".indexOf(current) == -1) {
-      current = this.next();
-    }
-  }
-  tokenizeMultilineComment() {
-    let current = this.peek(0);
-    while (current != "\0") {
-      if (current == "*" && this.peek(1) == "/") break;
-      current = this.next();
-    }
-    if (current == "\0") throw new Error("Missing close tag in comment");
-    this.next();
-    this.next();
-  }
-  tokenizeOperator() {
-    let current = this.peek(0);
-    if (current == "/") {
-      if (this.peek(1) == "/") {
-        this.next();
-        this.next();
-        this.tokenizeComment();
-        return;
-      } else if (this.peek(1) == "*") {
-        this.next();
-        this.next();
-        this.tokenizeMultilineComment();
-        return;
-      }
-    }
-    const buffer = [];
-    while (current !== "\0") {
-      const text2 = buffer.join("");
-      const column = this.column;
-      const line = this.line;
-      if (!this.OPERATORS.has(text2 + current) && text2 != "") {
-        const type = this.OPERATORS.get(text2);
-        if (!type) {
-          throw new Error(`Invalid tokenizeOperator ${text2}`);
-        }
-        this.addToken(type, "", column, line);
-        return;
-      }
-      buffer.push(current);
-      current = this.next();
-    }
-    const text = buffer.join("");
-    if (text !== "") {
-      const type = this.OPERATORS.get(text);
-      if (type) {
-        this.addToken(type, "", this.column, this.line);
-        return;
-      }
-    }
-    throw new Error("Invalid tokenizeOperator: unexpected end of input");
-  }
-};
-
-// vendor/dsl/parser/parser.ts
-var Parser = class _Parser {
-  static {
-    __name(this, "Parser");
-  }
-  EOF = new Token(43 /* EOF */, "", -1, -1);
-  tokens = [];
-  pos = 0;
-  size;
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.size = tokens.length;
-  }
-  parse() {
-    const current = this.get(0);
-    const result = new BlockStatement(current);
-    while (!this.match(43 /* EOF */)) {
-      result.add(this.statement());
-      this.match(40 /* SEMICOLON */);
-    }
-    return result;
-  }
-  statementOrBlock() {
-    if (this.get(0).getType() === 34 /* LBRACE */) {
-      return this.block();
-    }
-    return this.statement();
-  }
-  blockMetaBlock(name) {
-    const current = this.get(0);
-    const block = new BlockStatement(current);
-    while (!this.match(42 /* CLOSE_META_BLOCK */)) {
-      block.add(this.statement());
-      this.match(40 /* SEMICOLON */);
-    }
-    return block;
-  }
-  metaBlock() {
-    const current = this.get(0);
-    const name = this.consume(41 /* META_BLOCK */).getText();
-    this.consume(32 /* LPAREN */);
-    const argNames = [];
-    while (!this.match(33 /* RPAREN */)) {
-      argNames.push(this.consume(2 /* TEXT */).getText());
-      this.match(38 /* COMMA */);
-    }
-    const body = this.blockMetaBlock(name);
-    return new MetaBlockStatement(name, argNames, body, current);
-  }
-  block() {
-    const current = this.get(0);
-    const block = new BlockStatement(current);
-    this.consume(34 /* LBRACE */);
-    while (!this.match(35 /* RBRACE */)) {
-      block.add(this.statement());
-      this.match(40 /* SEMICOLON */);
-    }
-    return block;
-  }
-  statement() {
-    const current = this.get(0);
-    if (this.match(3 /* VAR */)) {
-      return this.varStatement(current);
-    }
-    if (this.match(4 /* PRINT */)) {
-      return new PrintStatement(this.expression(), current);
-    }
-    if (this.match(5 /* IF */)) {
-      return this.ifElse(current);
-    }
-    if (this.match(7 /* WHILE */)) {
-      return this.whileStatement(current);
-    }
-    if (this.match(9 /* DO */)) {
-      return this.doWhileStatement(current);
-    }
-    if (this.match(10 /* BREAK */)) {
-      return new BreakStatement(current);
-    }
-    if (this.match(11 /* CONTINUE */)) {
-      return new ContinueStatement(current);
-    }
-    if (this.match(13 /* RETURN */)) {
-      return new ReturnStatement(this.expression(), current);
-    }
-    if (this.match(8 /* FOR */)) {
-      return this.forStatement(current);
-    }
-    if (this.match(12 /* FUNCTION */)) {
-      return this.functionDefine(current);
-    }
-    if (this.lookMatch(0, 41 /* META_BLOCK */)) {
-      return this.metaBlock();
-    }
-    if (this.lookMatch(0, 1 /* WORD */) && this.lookMatch(1, 32 /* LPAREN */)) {
-      return new FunctionStatement(this.functionExpression(current), current);
-    }
-    if (this.match(15 /* PLUSPLUS */)) {
-      const variable = new VariableExpression(this.consume(1 /* WORD */).getText(), current);
-      return new IncrementStatement(
-        new IncrementExpression(variable, 0 /* PREFIX_INCREMENT */, current),
-        current
-      );
-    }
-    if (this.match(17 /* MINUSMINUS */)) {
-      const variable = new VariableExpression(this.consume(1 /* WORD */).getText(), current);
-      return new IncrementStatement(
-        new IncrementExpression(variable, 1 /* PREFIX_DECREMENT */, current),
-        current
-      );
-    }
-    if (this.lookMatch(0, 1 /* WORD */) && (this.lookMatch(1, 15 /* PLUSPLUS */) || this.lookMatch(1, 17 /* MINUSMINUS */))) {
-      const varToken = this.consume(1 /* WORD */);
-      const varName = varToken.getText();
-      if (this.match(15 /* PLUSPLUS */)) {
-        throw new Error(
-          `Postfix increment '${varName}++' is not supported. Use '${varName} = ${varName} + 1' instead. ${varToken.toString()}`
-        );
-      } else if (this.match(17 /* MINUSMINUS */)) {
-        throw new Error(
-          `Postfix decrement '${varName}--' is not supported. Use '${varName} = ${varName} - 1' instead. ${varToken.toString()}`
-        );
-      }
-    }
-    return this.assignmentStatement();
-  }
-  static RESERVED_WORDS = /* @__PURE__ */ new Set([
-    "true",
-    "false",
-    "null",
-    "undefined",
-    "let",
-    "const",
-    "class",
-    "new",
-    "delete",
-    "typeof",
-    "instanceof",
-    "in",
-    "of",
-    "import",
-    "export",
-    "default",
-    "extends",
-    "super",
-    "this",
-    "void",
-    "throw",
-    "try",
-    "catch",
-    "finally",
-    "switch",
-    "case",
-    "with",
-    "debugger",
-    "yield",
-    "await"
-  ]);
-  varStatement(token) {
-    const declarators = [];
-    do {
-      const nameToken = this.consume(1 /* WORD */);
-      const name = nameToken.getText();
-      if (_Parser.RESERVED_WORDS.has(name)) {
-        throw new Error(
-          `Variable name '${name}' is a reserved JavaScript keyword. Use a different name. ${nameToken.toString()}`
-        );
-      }
-      let init = null;
-      if (this.match(20 /* EQ */)) {
-        init = this.expression();
-      }
-      declarators.push({ name, init });
-    } while (this.match(38 /* COMMA */));
-    return new VarStatement(declarators, token);
-  }
-  assignmentStatement() {
-    const current = this.get(0);
-    if (this.lookMatch(0, 1 /* WORD */) && this.lookMatch(1, 20 /* EQ */)) {
-      const variable = this.consume(1 /* WORD */).getText();
-      this.consume(20 /* EQ */);
-      return new AssignmentStatement(variable, this.expression(), current);
-    }
-    if (this.lookMatch(0, 1 /* WORD */) && this.lookMatch(1, 36 /* LBRACKET */)) {
-      const array = this.elementExpression(current);
-      this.consume(20 /* EQ */);
-      return new ArrayAssignmentStatement(array, this.expression(), current);
-    }
-    throw new Error(`Unknown statement ${this.get(0)}`);
-  }
-  ifElse(token) {
-    const condition = this.expression();
-    const ifStatement = this.statementOrBlock();
-    let elseStatement;
-    if (this.match(6 /* ELSE */)) {
-      elseStatement = this.statementOrBlock();
-    } else {
-      elseStatement = null;
-    }
-    return new IfStatement(condition, ifStatement, elseStatement, token);
-  }
-  doWhileStatement(token) {
-    const statement = this.statementOrBlock();
-    this.consume(7 /* WHILE */);
-    const condition = this.expression();
-    return new DoWhileStatement(condition, statement, token);
-  }
-  whileStatement(token) {
-    const condition = this.expression();
-    const statement = this.statementOrBlock();
-    return new WhileStatement(condition, statement, token);
-  }
-  forStatement(token) {
-    this.consume(32 /* LPAREN */);
-    let initialization;
-    if (this.match(3 /* VAR */)) {
-      throw new Error(
-        `'var' in for-loop initialization is not supported by the Blockly converter. Use plain assignment: 'for (k = 1; k <= N; k = k + 1)'. ${this.get(-1).toString()}`
-      );
-    } else {
-      initialization = this.assignmentStatement();
-    }
-    this.consume(40 /* SEMICOLON */);
-    const termination = this.expression();
-    this.consume(40 /* SEMICOLON */);
-    const increment = this.statement();
-    this.consume(33 /* RPAREN */);
-    const block = this.statementOrBlock();
-    return new ForStatement(initialization, termination, increment, block, token);
-  }
-  functionDefine(token) {
-    const name = this.consume(1 /* WORD */).getText();
-    this.consume(32 /* LPAREN */);
-    const argNames = [];
-    while (!this.match(33 /* RPAREN */)) {
-      argNames.push(this.consume(1 /* WORD */).getText());
-      this.match(38 /* COMMA */);
-    }
-    const body = this.statementOrBlock();
-    return new FunctionDefineStatement(name, argNames, body, token);
-  }
-  functionExpression(token) {
-    const name = this.consume(1 /* WORD */).getText();
-    this.consume(32 /* LPAREN */);
-    const func = new FunctionalExpression(name, [], token);
-    while (!this.match(33 /* RPAREN */)) {
-      func.addArgument(this.expression());
-      this.match(38 /* COMMA */);
-    }
-    return func;
-  }
-  elementExpression(token) {
-    const variable = this.consume(1 /* WORD */).getText();
-    const indexes = [];
-    do {
-      this.consume(36 /* LBRACKET */);
-      indexes.push(this.expression());
-      this.consume(37 /* RBRACKET */);
-    } while (this.lookMatch(0, 36 /* LBRACKET */));
-    return new ArrayAccessExpression(variable, indexes, token);
-  }
-  arrayExpression(token) {
-    this.consume(36 /* LBRACKET */);
-    const elements = [];
-    while (!this.match(37 /* RBRACKET */)) {
-      elements.push(this.expression());
-      this.match(38 /* COMMA */);
-    }
-    return new ArrayExpression(elements, token);
-  }
-  objectExpression(token) {
-    this.consume(34 /* LBRACE */);
-    const properties = /* @__PURE__ */ new Map();
-    while (!this.match(35 /* RBRACE */)) {
-      let key;
-      if (this.lookMatch(0, 1 /* WORD */)) {
-        key = this.consume(1 /* WORD */).getText();
-      } else if (this.lookMatch(0, 2 /* TEXT */)) {
-        key = this.consume(2 /* TEXT */).getText();
-      } else {
-        throw new Error("Expected property key (word or string)");
-      }
-      this.consume(39 /* COLON */);
-      const value = this.expression();
-      properties.set(key, value);
-      this.match(38 /* COMMA */);
-    }
-    return new ObjectExpression(properties, token);
-  }
-  expression() {
-    return this.logicalOr();
+    active.ttlTimer = null;
   }
-  logicalOr() {
-    let result = this.logicalAnd();
-    while (this.match(29 /* BARBAR */)) {
-      const current = this.get(0);
-      result = new ConditionalExpression("||" /* OR */, result, this.logicalAnd(), current);
-    }
-    return result;
+  requireActive(id) {
+    const a = this.runtimes.get(id);
+    if (!a) throw new Error(`Runtime "${id}" not found (already aborted or never started)`);
+    return a;
   }
-  logicalAnd() {
-    let result = this.equality();
-    while (this.match(31 /* AMPAMP */)) {
-      const current = this.get(0);
-      result = new ConditionalExpression("&&" /* AND */, result, this.equality(), current);
-    }
-    return result;
+};
+
+// src/runner/fs-scenario-repository.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { readdir } from "fs/promises";
+import { dirname as dirname2, resolve, join as join2, sep } from "path";
+var FileSystemScenarioRepository = class {
+  static {
+    __name(this, "FileSystemScenarioRepository");
   }
-  equality() {
-    const current = this.get(0);
-    const result = this.conditional();
-    if (this.match(21 /* EQEQ */)) {
-      return new ConditionalExpression("==" /* EQ */, result, this.conditional(), current);
-    }
-    if (this.match(23 /* EXCLEQ */)) {
-      return new ConditionalExpression("!=" /* NEQ */, result, this.conditional(), current);
-    }
-    return result;
+  scenariosDir;
+  constructor(deps) {
+    this.scenariosDir = resolve(deps.scenariosDir);
   }
-  conditional() {
-    let result = this.additive();
-    while (this.lookMatch(0, 24 /* LT */) || this.lookMatch(0, 25 /* LTEQ */) || this.lookMatch(0, 26 /* GT */) || this.lookMatch(0, 27 /* GTEQ */)) {
-      const current = this.get(0);
-      if (this.match(24 /* LT */)) {
-        result = new ConditionalExpression("<" /* LT */, result, this.additive(), current);
-        continue;
-      }
-      if (this.match(25 /* LTEQ */)) {
-        result = new ConditionalExpression("<=" /* LTE */, result, this.additive(), current);
-        continue;
-      }
-      if (this.match(26 /* GT */)) {
-        result = new ConditionalExpression(">" /* GT */, result, this.additive(), current);
-        continue;
-      }
-      if (this.match(27 /* GTEQ */)) {
-        result = new ConditionalExpression(">=" /* GTE */, result, this.additive(), current);
-        continue;
-      }
-    }
-    return result;
+  async list() {
+    const out = [];
+    await this.walk(this.scenariosDir, "", out);
+    return out.sort();
   }
-  additive() {
-    let result = this.multiplicate();
-    while (this.lookMatch(0, 14 /* PLUS */) || this.lookMatch(0, 16 /* MINUS */)) {
-      if (this.match(14 /* PLUS */)) {
-        const opToken2 = this.get(-1);
-        result = new BinaryExpression("+", result, this.multiplicate(), opToken2);
-        continue;
-      }
-      this.consume(16 /* MINUS */);
-      const opToken = this.get(-1);
-      result = new BinaryExpression("-", result, this.multiplicate(), opToken);
-    }
-    return result;
-  }
-  multiplicate() {
-    let result = this.unary();
-    while (this.lookMatch(0, 18 /* STAR */) || this.lookMatch(0, 19 /* SLASH */)) {
-      if (this.match(18 /* STAR */)) {
-        const opToken2 = this.get(-1);
-        result = new BinaryExpression("*", result, this.unary(), opToken2);
-        continue;
+  async walk(dir, relPrefix, out) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+      const abs = join2(dir, entry.name);
+      const rel = relPrefix === "" ? entry.name : `${relPrefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        await this.walk(abs, rel, out);
+      } else if (entry.isFile() && entry.name.endsWith(".js")) {
+        out.push(rel.slice(0, -".js".length));
       }
-      this.consume(19 /* SLASH */);
-      const opToken = this.get(-1);
-      result = new BinaryExpression("/", result, this.unary(), opToken);
-    }
-    return result;
-  }
-  unary() {
-    const current = this.get(0);
-    if (this.match(16 /* MINUS */)) {
-      return new UnaryExpression("-", this.primary(), current);
-    }
-    if (this.match(15 /* PLUSPLUS */)) {
-      const variable = new VariableExpression(this.consume(1 /* WORD */).getText(), current);
-      return new IncrementExpression(variable, 0 /* PREFIX_INCREMENT */, current);
     }
-    if (this.match(17 /* MINUSMINUS */)) {
-      const variable = new VariableExpression(this.consume(1 /* WORD */).getText(), current);
-      return new IncrementExpression(variable, 1 /* PREFIX_DECREMENT */, current);
-    }
-    return this.primary();
   }
-  primary() {
-    const current = this.get(0);
-    if (this.match(0 /* NUMBER */)) {
-      return new ValueExpression(current.getText(), current);
-    }
-    if (this.lookMatch(0, 1 /* WORD */) && this.lookMatch(1, 32 /* LPAREN */)) {
-      return this.functionExpression(current);
-    }
-    if (this.lookMatch(0, 1 /* WORD */) && this.lookMatch(1, 36 /* LBRACKET */)) {
-      return this.elementExpression(current);
-    }
-    if (this.lookMatch(0, 36 /* LBRACKET */)) {
-      return this.arrayExpression(current);
-    }
-    if (this.lookMatch(0, 34 /* LBRACE */)) {
-      return this.objectExpression(current);
-    }
-    if (this.match(1 /* WORD */)) {
-      const variable = new VariableExpression(current.getText(), current);
-      if (this.match(15 /* PLUSPLUS */)) {
-        throw new Error(
-          `Postfix increment '${current.getText()}++' is not supported. Use '${current.getText()} = ${current.getText()} + 1' instead. ${current.toString()}`
-        );
-      }
-      if (this.match(17 /* MINUSMINUS */)) {
-        throw new Error(
-          `Postfix decrement '${current.getText()}--' is not supported. Use '${current.getText()} = ${current.getText()} - 1' instead. ${current.toString()}`
-        );
-      }
-      return variable;
-    }
-    if (this.match(2 /* TEXT */)) {
-      return new ValueExpression(current.getText(), current);
-    }
-    if (this.match(32 /* LPAREN */)) {
-      const result = this.expression();
-      this.match(33 /* RPAREN */);
-      return result;
-    }
-    throw new Error(`Invalid token ${current}`);
+  async load(name) {
+    const path = this.pathFor(name);
+    const source = readFileSync2(path, "utf8");
+    return { name, source };
   }
-  consume(type) {
-    const current = this.get(0);
-    if (type != current.getType()) {
-      throw new Error(`Token ${current} doesn't match token type ${TokenType[type]}`);
-    }
-    this.pos++;
-    return current;
+  async has(name) {
+    return existsSync2(this.pathFor(name));
   }
-  match(type) {
-    const current = this.get(0);
-    if (type != current.getType()) {
-      return false;
+  async save(name, source, opts) {
+    const path = this.pathFor(name);
+    if (existsSync2(path) && !opts?.overwrite) {
+      throw new Error(`scenario "${name}" already exists at ${path}`);
     }
-    this.pos++;
-    return true;
-  }
-  lookMatch(pos, type) {
-    return this.get(pos).getType() == type;
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync(path, source);
+    return path;
   }
-  get(relativePosition) {
-    const position = this.pos + relativePosition;
-    if (position >= this.size) {
-      return this.EOF;
+  pathFor(name) {
+    if (name.includes("..") || name.startsWith("/") || name.includes("\\")) {
+      throw new Error(`Invalid scenario name "${name}"`);
     }
-    return this.tokens[position];
+    const relPath = name.split("/").join(sep) + ".js";
+    return join2(this.scenariosDir, relPath);
   }
 };
 
 // src/runner/scenario-loader.ts
+import { Lexer } from "@unotest/dsl";
+import { Parser } from "@unotest/dsl";
+import {
+  FunctionDefineStatement as FunctionDefineStatement2
+} from "@unotest/dsl";
 var ScenarioLoader = class {
   constructor(repo, helpers) {
     this.repo = repo;
@@ -5570,7 +3419,7 @@ function resolveEntryFunctionName(scenarioName, prefix = "test") {
 __name(resolveEntryFunctionName, "resolveEntryFunctionName");
 function collectOrigins(program, sourcePath, out) {
   for (const stmt of program.statements) {
-    if (stmt instanceof FunctionDefineStatement) {
+    if (stmt instanceof FunctionDefineStatement2) {
       const tok = stmt.token;
       out.push({
         name: stmt.name,
@@ -5587,6 +3436,8 @@ __name(collectOrigins, "collectOrigins");
 import { readdir as readdir2, readFile } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { join as join3, relative } from "path";
+import { Lexer as Lexer2 } from "@unotest/dsl";
+import { Parser as Parser2 } from "@unotest/dsl";
 var FileSystemHelperRepository = class {
   static {
     __name(this, "FileSystemHelperRepository");
@@ -5603,8 +3454,8 @@ var FileSystemHelperRepository = class {
     const out = [];
     for (const absolutePath of files) {
       const source = await readFile(absolutePath, "utf8");
-      const tokens = new Lexer(source).tokenize();
-      const ast = new Parser(tokens).parse();
+      const tokens = new Lexer2(source).tokenize();
+      const ast = new Parser2(tokens).parse();
       out.push({
         path: relative(this.scenariosDir, absolutePath),
         absolutePath,
@@ -5893,14 +3744,15 @@ var DslViewService = class {
   generate(session, log) {
     const warnings = [];
     const lines = [];
-    lines.push(renderHeader(session));
+    lines.push(`// ${session.title ?? session.scenarioName}`);
     lines.push(`function test_${session.scenarioName.replace(/[^a-zA-Z0-9_]/g, "_")}() {`);
-    lines.push(`  setDevice(${JSON.stringify(session.device)});`);
-    let openSection = null;
+    lines.push(`  step("setup", () => {`);
+    lines.push(`    setDevice(${JSON.stringify(session.device)});`);
+    let openSection = "setup";
     for (const entry of log.entries) {
       if (entry.section !== openSection) {
-        if (openSection !== null) lines.push("  //@endcollapse");
-        lines.push(`  //@collapse(${JSON.stringify(entry.section)})`);
+        lines.push("  });");
+        lines.push(`  step(${JSON.stringify(entry.section)}, () => {`);
         openSection = entry.section;
       }
       const result = renderEntry(entry);
@@ -5910,7 +3762,7 @@ var DslViewService = class {
           type: "NO_DSL_PRIMITIVE",
           message: result.reason
         });
-        lines.push(`  // SKIPPED (${result.reason}) \u2014 replace with getByTestId/getByText/getByLabel`);
+        lines.push(`    // SKIPPED (${result.reason}) \u2014 replace with getByTestId/getByText/getByLabel`);
         continue;
       }
       if (entry.stability === "fragile") {
@@ -5923,22 +3775,13 @@ var DslViewService = class {
       for (const w of result.warnings ?? []) {
         warnings.push({ ...w, entryId: entry.entryId });
       }
-      lines.push("  " + result.stmt);
+      lines.push("    " + result.stmt);
     }
-    if (openSection !== null) lines.push("  //@endcollapse");
+    lines.push("  });");
     lines.push("}");
     return { draftDsl: lines.join("\n") + "\n", warnings };
   }
 };
-function renderHeader(session) {
-  const title = session.title ?? session.scenarioName;
-  return [
-    `// id-${session.scenarioName}`,
-    `// ${title}`,
-    `// #4287f5`
-  ].join("\n");
-}
-__name(renderHeader, "renderHeader");
 function renderEntry(entry) {
   const sel = /* @__PURE__ */ __name((s) => {
     const out = formatSelector(s);
@@ -6199,7 +4042,7 @@ async function buildApp(opts = {}) {
       await Promise.allSettled(slots.map((slot) => active.testRuntime.driver.shutdown(slot)));
     }, "onAbort")
   });
-  const scenariosDirAbs = resolve3(opts.scenariosDir ?? "unotest/e2e");
+  const scenariosDirAbs = resolve3(opts.scenariosDir ?? MOBILE_SCENARIOS_DIR);
   const scenarioRepository = opts.scenarioRepository ?? new FileSystemScenarioRepository({ scenariosDir: scenariosDirAbs });
   const helperRepository = opts.helperRepository ?? new FileSystemHelperRepository({ scenariosDir: scenariosDirAbs });
   const scenarioLoader = new ScenarioLoader(scenarioRepository, helperRepository);
@@ -7030,37 +4873,7 @@ var AppInstallTool = class extends BaseTool {
 import { z as z5 } from "zod";
 
 // src/dsl/variable-scope.ts
-var VariableScope = class {
-  static {
-    __name(this, "VariableScope");
-  }
-  stack = [];
-  current = /* @__PURE__ */ new Map();
-  push() {
-    this.stack.push(new Map(this.current));
-  }
-  pop() {
-    const popped = this.stack.pop();
-    if (popped === void 0) throw new Error("VariableScope.pop(): underflow (more pops than pushes)");
-    this.current = popped;
-  }
-  get(name) {
-    return this.current.get(name);
-  }
-  has(name) {
-    return this.current.has(name);
-  }
-  set(name, value) {
-    this.current.set(name, value);
-  }
-  toObject() {
-    return Object.fromEntries(this.current.entries());
-  }
-  /** Depth of the push-stack. 0 at construction; +1 per push, -1 per pop. */
-  depth() {
-    return this.stack.length;
-  }
-};
+import { VariableScope } from "@unotest/dsl/executor";
 
 // src/dsl/runtime.ts
 var TestRuntime = class {
@@ -7180,7 +4993,7 @@ var RunTestTool = class extends BaseTool {
       "run_test",
       {
         title: "Run a DSL scenario (with optional step/pause modes)",
-        description: "Loads unotest/e2e/<name>.js, parses + lints, then runs the function 'test_<name>' through AstExecutor. mode='auto' runs to completion or failure; mode='step' pauses after every statement. pauseOnFailure (default true) keeps simulators and WDA sessions alive on error so they can be inspected.",
+        description: "Loads unotest/e2e-mobile/<name>.js, parses + lints, then runs the function 'test_<name>' through AstExecutor. mode='auto' runs to completion or failure; mode='step' pauses after every statement. pauseOnFailure (default true) keeps simulators and WDA sessions alive on error so they can be inspected.",
         inputSchema: {
           name: z5.string(),
           mode: z5.enum(["auto", "step"]).optional(),
@@ -7208,7 +5021,7 @@ var RunTestTool = class extends BaseTool {
         if (!loaded2.userFunctionNames.has(testFn)) {
           return this.failJson({
             status: "entry_not_found",
-            message: `Entry function "${testFn}" not found in ${name}.js. Convention: unotest/e2e/${name}.js \u2192 function ${testFn}().`
+            message: `Entry function "${testFn}" not found in ${name}.js. Convention: unotest/e2e-mobile/${name}.js \u2192 function ${testFn}().`
           });
         }
         const runId = `e2e-${randomUUID2().slice(0, 8)}`;
@@ -7347,19 +5160,404 @@ var ListRuntimesTool = class extends BaseTool {
   }
 };
 
-// src/mcp/tools/explore.tool.ts
+// src/mcp/tools/attach.tool.ts
+import { z as z6 } from "zod";
+
+// src/mcp/attach-runtime.ts
+import {
+  COMMANDS_FILE,
+  HEARTBEAT_FILE,
+  RUNTIME_FILE
+} from "@unotest/protocol";
+import { appendFile, mkdir, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+var HEARTBEAT_STALE_MS = 3e4;
+function runDir(projectRoot, runId) {
+  return join6(projectRoot, MOBILE_RUNS_DIR, runId);
+}
+__name(runDir, "runDir");
+async function readMobileRuntimeFile(projectRoot, runId) {
+  try {
+    return JSON.parse(
+      await readFile2(join6(runDir(projectRoot, runId), RUNTIME_FILE), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+__name(readMobileRuntimeFile, "readMobileRuntimeFile");
+async function findShareableMobileRun(projectRoot, nowFn = Date.now) {
+  const root = join6(projectRoot, MOBILE_RUNS_DIR);
+  if (!existsSync6(root)) return null;
+  const now = nowFn();
+  let best = null;
+  for (const name of readdirSync3(root)) {
+    const hb = join6(root, name, HEARTBEAT_FILE);
+    if (!existsSync6(hb)) continue;
+    let mtimeMs = 0;
+    try {
+      mtimeMs = statSync3(hb).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (now - mtimeMs > HEARTBEAT_STALE_MS) continue;
+    const snap = await readMobileRuntimeFile(projectRoot, name);
+    if (!snap?.deviceSlot) continue;
+    if (snap.state === "completed" || snap.state === "failed" || snap.state === "aborted") {
+      continue;
+    }
+    if (!best || mtimeMs > best.mtimeMs) best = { runtimeId: name, snap, mtimeMs };
+  }
+  return best ? { runtimeId: best.runtimeId, snap: best.snap } : null;
+}
+__name(findShareableMobileRun, "findShareableMobileRun");
+async function appendDbgCommand(projectRoot, runId, cmd) {
+  const path = join6(runDir(projectRoot, runId), COMMANDS_FILE);
+  await mkdir(dirname4(path), { recursive: true });
+  await appendFile(path, JSON.stringify(cmd) + "\n", "utf8");
+}
+__name(appendDbgCommand, "appendDbgCommand");
+function nextCommandId() {
+  return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 8);
+}
+__name(nextCommandId, "nextCommandId");
+var AttachState = class {
+  static {
+    __name(this, "AttachState");
+  }
+  runId = null;
+  slot = null;
+  attach(runId, slot) {
+    this.runId = runId;
+    this.slot = slot;
+  }
+  detach() {
+    this.runId = null;
+    this.slot = null;
+  }
+  attachedRunId() {
+    return this.runId;
+  }
+  attachedSlot() {
+    return this.slot;
+  }
+};
+
+// src/mcp/tools/attach.tool.ts
+var AttachBaseTool = class extends BaseTool {
+  constructor(services, attach, projectRoot) {
+    super(services);
+    this.attach = attach;
+    this.projectRoot = projectRoot;
+  }
+  attach;
+  projectRoot;
+  static {
+    __name(this, "AttachBaseTool");
+  }
+};
+var GetActiveContextTool = class extends AttachBaseTool {
+  static {
+    __name(this, "GetActiveContextTool");
+  }
+  register(server) {
+    server.registerTool(
+      "get_active_context",
+      {
+        title: "Active mobile context",
+        description: "Reports whether you are attached to a live mobile debug session and, if not, whether one is JOINABLE. When a human is debugging a scenario in the viewer (Debug mode), `attachable` names its runtimeId + device slot + state \u2014 call attach_debug_session to co-drive the SAME device, then a11y_tree / screenshot that slot. Returns attachable=null when no live debug session exists (start your own with run_test).",
+        inputSchema: {}
+      },
+      async () => this.tracked("get_active_context", {}, async () => {
+        const attachedRunId = this.attach.attachedRunId();
+        const found = await findShareableMobileRun(this.projectRoot);
+        return this.okJson({
+          attached: attachedRunId ? { runtimeId: attachedRunId, slot: this.attach.attachedSlot() } : null,
+          attachable: found ? {
+            runtimeId: found.runtimeId,
+            slot: found.snap.deviceSlot ?? null,
+            state: found.snap.state,
+            wheel: found.snap.wheel ?? "human"
+          } : null
+        });
+      })
+    );
+  }
+};
+var AttachDebugSessionTool = class extends AttachBaseTool {
+  static {
+    __name(this, "AttachDebugSessionTool");
+  }
+  register(server) {
+    server.registerTool(
+      "attach_debug_session",
+      {
+        title: "Attach to a mobile debug session",
+        description: "Join a human's live mobile debug run so you BOTH drive the SAME device (collaborative debugging). Omit runtimeId to auto-pick the single live debug session. Afterwards a11y_tree / screenshot / find_element on the run's device slot show what the human is debugging; take_wheel before you act. The run must be started in Debug mode (the viewer's Debug button) \u2014 a normal run advertises no device slot. Call detach_debug_session to disengage.",
+        inputSchema: { runtimeId: z6.string().optional() }
+      },
+      async ({ runtimeId }) => this.tracked("attach_debug_session", { runtimeId }, async () => {
+        let id = runtimeId;
+        let snap = id ? await readMobileRuntimeFile(this.projectRoot, id) : null;
+        if (!id) {
+          const found = await findShareableMobileRun(this.projectRoot);
+          if (!found) {
+            return this.okJson({
+              status: "no_session",
+              reason: "no live mobile debug session to attach to \u2014 start one from the viewer's Debug button, or run_test here."
+            });
+          }
+          id = found.runtimeId;
+          snap = found.snap;
+        }
+        if (!snap) {
+          return this.okJson({
+            status: "no_session",
+            reason: `no runtime.json for "${id}" \u2014 the run may have ended.`
+          });
+        }
+        if (!snap.deviceSlot) {
+          return this.okJson({
+            status: "not_attachable",
+            runtimeId: id,
+            reason: "this run advertises no device slot \u2014 only Debug-mode runs are attachable."
+          });
+        }
+        this.attach.attach(id, snap.deviceSlot);
+        return this.okJson({
+          status: "attached",
+          runtimeId: id,
+          slot: snap.deviceSlot,
+          state: snap.state,
+          wheel: snap.wheel ?? "human"
+        });
+      })
+    );
+  }
+};
+var DetachDebugSessionTool = class extends AttachBaseTool {
+  static {
+    __name(this, "DetachDebugSessionTool");
+  }
+  register(server) {
+    server.registerTool(
+      "detach_debug_session",
+      {
+        title: "Detach from the mobile debug session",
+        description: "Disengage from the live debug session you joined with attach_debug_session. Does not stop the human's run \u2014 only clears your attachment so the device tools no longer default to its slot.",
+        inputSchema: {}
+      },
+      async () => this.tracked("detach_debug_session", {}, async () => {
+        const was = this.attach.attachedRunId();
+        this.attach.detach();
+        return this.okJson({ status: "detached", wasAttachedTo: was });
+      })
+    );
+  }
+};
+var WheelTool = class extends AttachBaseTool {
+  constructor(services, attach, projectRoot, owner) {
+    super(services, attach, projectRoot);
+    this.owner = owner;
+  }
+  owner;
+  static {
+    __name(this, "WheelTool");
+  }
+  register(server) {
+    const name = this.owner === "agent" ? "take_wheel" : "release_wheel";
+    server.registerTool(
+      name,
+      {
+        title: name === "take_wheel" ? "Take the wheel" : "Release the wheel",
+        description: this.owner === "agent" ? "Take the collaborative control token so you may act on the human's debug device. The viewer shows an 'Agent driving' badge and the human can take it back any time. Omit runtimeId to use the session you attached to." : "Release the control token back to the human (the host). Omit runtimeId to use the session you attached to.",
+        inputSchema: { runtimeId: z6.string().optional() }
+      },
+      async ({ runtimeId }) => this.tracked(name, { runtimeId }, async () => {
+        const id = runtimeId ?? this.attach.attachedRunId();
+        if (!id) {
+          return this.okJson({
+            status: "no_target",
+            reason: "not attached \u2014 call attach_debug_session first, or pass runtimeId."
+          });
+        }
+        await appendDbgCommand(this.projectRoot, id, {
+          id: nextCommandId(),
+          cmd: "wheel",
+          owner: this.owner
+        });
+        return this.okJson({ status: "ok", runtimeId: id, owner: this.owner });
+      })
+    );
+  }
+};
+
+// src/mcp/tools/failure.tool.ts
 import { z as z7 } from "zod";
 
+// src/mcp/failure-bundle-reader.ts
+import {
+  PICKER_SNAPSHOT_FILE,
+  RUN_MANIFEST_FILE
+} from "@unotest/protocol";
+import { existsSync as existsSync7, readdirSync as readdirSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join7 } from "path";
+var FAILURE_SCREENSHOT_FILE = "screenshot.png";
+function runDir2(projectRoot, runId) {
+  return join7(projectRoot, MOBILE_RUNS_DIR, runId);
+}
+__name(runDir2, "runDir");
+async function readManifest(projectRoot, runId) {
+  try {
+    return JSON.parse(
+      await readFile3(join7(runDir2(projectRoot, runId), RUN_MANIFEST_FILE), "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+__name(readManifest, "readManifest");
+async function listMobileFailures(projectRoot) {
+  const root = join7(projectRoot, MOBILE_RUNS_DIR);
+  if (!existsSync7(root)) return [];
+  const out = [];
+  for (const runId of readdirSync4(root)) {
+    const snap = await readMobileRuntimeFile(projectRoot, runId);
+    if (!snap) continue;
+    const failed = snap.state === "failed" || snap.state === "paused-failure" || snap.lastFailure != null;
+    if (!failed) continue;
+    const manifest = await readManifest(projectRoot, runId);
+    out.push({
+      runId,
+      scenario: manifest?.ref ?? snap.scenario ?? runId,
+      state: snap.state,
+      error: snap.lastFailure?.error ?? null,
+      location: snap.lastFailure ? { line: snap.lastFailure.line, col: snap.lastFailure.col } : null,
+      hasScreenshot: existsSync7(join7(runDir2(projectRoot, runId), FAILURE_SCREENSHOT_FILE)),
+      hasOutline: existsSync7(join7(runDir2(projectRoot, runId), PICKER_SNAPSHOT_FILE))
+    });
+  }
+  return out;
+}
+__name(listMobileFailures, "listMobileFailures");
+async function readFailureScreenshot(projectRoot, runId) {
+  const path = join7(runDir2(projectRoot, runId), FAILURE_SCREENSHOT_FILE);
+  if (!existsSync7(path)) return null;
+  try {
+    return await readFile3(path);
+  } catch {
+    return null;
+  }
+}
+__name(readFailureScreenshot, "readFailureScreenshot");
+async function readFailureOutline(projectRoot, runId) {
+  const path = join7(runDir2(projectRoot, runId), PICKER_SNAPSHOT_FILE);
+  if (!existsSync7(path)) return null;
+  try {
+    return await readFile3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+__name(readFailureOutline, "readFailureOutline");
+
+// src/mcp/tools/failure.tool.ts
+var FailureBaseTool = class extends BaseTool {
+  constructor(services, projectRoot) {
+    super(services);
+    this.projectRoot = projectRoot;
+  }
+  projectRoot;
+  static {
+    __name(this, "FailureBaseTool");
+  }
+};
+var ListFailuresTool = class extends FailureBaseTool {
+  static {
+    __name(this, "ListFailuresTool");
+  }
+  register(server) {
+    server.registerTool(
+      "list_failures",
+      {
+        title: "List failed runs",
+        description: "Lists recent runs that ended in (or are paused at) a failure, with the scenario name, error message, and failing line:col. Each entry says whether a failure screenshot and an a11y outline are available \u2014 fetch them with get_failure_screenshot / get_failure_a11y by runtimeId.",
+        inputSchema: {}
+      },
+      async () => this.tracked("list_failures", {}, async () => {
+        return this.okJson({ failures: await listMobileFailures(this.projectRoot) });
+      })
+    );
+  }
+};
+var GetFailureScreenshotTool = class extends FailureBaseTool {
+  static {
+    __name(this, "GetFailureScreenshotTool");
+  }
+  register(server) {
+    server.registerTool(
+      "get_failure_screenshot",
+      {
+        title: "Failure screenshot",
+        description: "Returns the device screenshot captured at the failure point of a run (as inline MCP image content). Pass the runtimeId from list_failures. Returns a not_found status when the run has no failure screenshot.",
+        inputSchema: { runtimeId: z7.string() }
+      },
+      async ({ runtimeId }) => this.tracked("get_failure_screenshot", { runtimeId }, async () => {
+        const png = await readFailureScreenshot(this.projectRoot, runtimeId);
+        if (!png) {
+          return this.okJson({ status: "not_found", runtimeId });
+        }
+        return {
+          content: [
+            {
+              type: "image",
+              data: png.toString("base64"),
+              mimeType: "image/png"
+            }
+          ]
+        };
+      })
+    );
+  }
+};
+var GetFailureA11yTool = class extends FailureBaseTool {
+  static {
+    __name(this, "GetFailureA11yTool");
+  }
+  register(server) {
+    server.registerTool(
+      "get_failure_a11y",
+      {
+        title: "Failure a11y outline",
+        description: "Returns the accessibility outline of the device at the failure/pause point of a run (the same compact outline as a11y_tree). Pass the runtimeId from list_failures. Returns a not_found status when no outline was captured.",
+        inputSchema: { runtimeId: z7.string() }
+      },
+      async ({ runtimeId }) => this.tracked("get_failure_a11y", { runtimeId }, async () => {
+        const outline = await readFailureOutline(this.projectRoot, runtimeId);
+        if (outline === null) {
+          return this.okJson({ status: "not_found", runtimeId });
+        }
+        return this.ok(outline);
+      })
+    );
+  }
+};
+
+// src/mcp/tools/explore.tool.ts
+import { z as z9 } from "zod";
+
 // src/mcp/tools/selector-param.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var SelectorShape = {
-  testId: z6.string().optional(),
-  text: z6.string().optional(),
-  label: z6.string().optional(),
-  ordinal: z6.number().int().nonnegative().optional(),
-  pointPercent: z6.object({
-    x: z6.number().min(0).max(1),
-    y: z6.number().min(0).max(1)
+  testId: z8.string().optional(),
+  text: z8.string().optional(),
+  label: z8.string().optional(),
+  ordinal: z8.number().int().nonnegative().optional(),
+  pointPercent: z8.object({
+    x: z8.number().min(0).max(1),
+    y: z8.number().min(0).max(1)
   }).optional()
 };
 function coerceJsonObject(v) {
@@ -7371,14 +5569,14 @@ function coerceJsonObject(v) {
   }
 }
 __name(coerceJsonObject, "coerceJsonObject");
-var SelectorParam = z6.preprocess(
+var SelectorParam = z8.preprocess(
   coerceJsonObject,
-  z6.object(SelectorShape).refine(
+  z8.object(SelectorShape).refine(
     (s) => Boolean(s.testId || s.text || s.label || s.pointPercent),
     { message: "selector requires one of testId/text/label/pointPercent" }
   )
 );
-var SelectorParamOptional = z6.preprocess(coerceJsonObject, z6.object(SelectorShape).optional());
+var SelectorParamOptional = z8.preprocess(coerceJsonObject, z8.object(SelectorShape).optional());
 
 // src/mcp/tools/explore.tool.ts
 var ACTION_ENUM = [
@@ -7395,22 +5593,22 @@ var ACTION_ENUM = [
 var KEY_ENUM = ["back", "home", "enter", "escape"];
 var DIRECTION_ENUM = ["up", "down", "left", "right"];
 var stepShape = {
-  explorationId: z7.string().optional(),
-  action: z7.enum(ACTION_ENUM),
-  device: z7.string().optional(),
+  explorationId: z9.string().optional(),
+  action: z9.enum(ACTION_ENUM),
+  device: z9.string().optional(),
   selector: SelectorParamOptional,
-  value: z7.string().optional(),
-  key: z7.enum(KEY_ENUM).optional(),
-  direction: z7.enum(DIRECTION_ENUM).optional(),
+  value: z9.string().optional(),
+  key: z9.enum(KEY_ENUM).optional(),
+  direction: z9.enum(DIRECTION_ENUM).optional(),
   from: SelectorParamOptional,
-  url: z7.string().optional(),
-  bundleId: z7.string().optional(),
-  clean: z7.boolean().optional(),
-  timeoutMs: z7.number().int().positive().optional(),
-  optional: z7.boolean().optional(),
-  button: z7.string().optional(),
-  description: z7.string().optional(),
-  section: z7.string().optional()
+  url: z9.string().optional(),
+  bundleId: z9.string().optional(),
+  clean: z9.boolean().optional(),
+  timeoutMs: z9.number().int().positive().optional(),
+  optional: z9.boolean().optional(),
+  button: z9.string().optional(),
+  description: z9.string().optional(),
+  section: z9.string().optional()
 };
 function validateRecordingArgs(args) {
   if (!args.section) return "section required when recording";
@@ -7497,10 +5695,10 @@ var ExploreStartTool = class extends BaseTool {
         title: "Start a recording session",
         description: "Begins an ExplorationSession. Returns { explorationId }. Subsequent explore_step calls that include this id will be recorded into an ActionLog; calls without it are ad-hoc. Device slot ('A' or 'B') is fixed for the session. No auto-launch: the first explore_step must do the app_launch / open_deeplink so it appears in the generated test.",
         inputSchema: {
-          scenario_name: z7.string().min(1).describe("Logical name; later used by save_exploration_as_test as the test file name."),
-          device: z7.string().min(1).describe("Slot from SIM_POOL, e.g. 'A'."),
-          title: z7.string().optional(),
-          description: z7.string().optional()
+          scenario_name: z9.string().min(1).describe("Logical name; later used by save_exploration_as_test as the test file name."),
+          device: z9.string().min(1).describe("Slot from SIM_POOL, e.g. 'A'."),
+          title: z9.string().optional(),
+          description: z9.string().optional()
         }
       },
       async ({ scenario_name, device, title, description }) => this.tracked(
@@ -7536,7 +5734,7 @@ var ExploreStopTool = class extends BaseTool {
         title: "Stop a recording session",
         description: "Marks the session as stopped. The device stays running (no teardown). After stop, generate_dsl_from_exploration / save_exploration_as_test remain callable; further explore_step calls with this id will fail.",
         inputSchema: {
-          explorationId: z7.string().min(1)
+          explorationId: z9.string().min(1)
         }
       },
       async ({ explorationId }) => this.tracked("explore_stop", { explorationId }, async () => {
@@ -7563,7 +5761,7 @@ var ExploreStateTool = class extends BaseTool {
         title: "Inspect the recording session log",
         description: "Returns the session status and all recorded ActionEntries. Each entry carries its per-entry `stability` annotation (stable | fragile). The full warnings list (FRAGILE_LOCATOR / NO_DSL_PRIMITIVE / BUNDLE_ID_IGNORED) is NOT returned here \u2014 it is derived on demand by generate_dsl_from_exploration.",
         inputSchema: {
-          explorationId: z7.string().min(1)
+          explorationId: z9.string().min(1)
         }
       },
       async ({ explorationId }) => this.tracked("explore_state", { explorationId }, async () => {
@@ -7707,8 +5905,8 @@ var ExploreRemoveStepTool = class extends BaseTool {
         title: "Remove an entry from the recording session log",
         description: "Deletes the entry by entryId. Returns { removed: true } or { removed: false } if not found.",
         inputSchema: {
-          explorationId: z7.string().min(1),
-          entryId: z7.string().min(1)
+          explorationId: z9.string().min(1),
+          entryId: z9.string().min(1)
         }
       },
       async ({ explorationId, entryId }) => this.tracked("explore_remove_step", { explorationId, entryId }, async () => {
@@ -7729,9 +5927,9 @@ var GenerateDslFromExplorationTool = class extends BaseTool {
       "generate_dsl_from_exploration",
       {
         title: "Render the session log as a DSL test",
-        description: "Returns { draftDsl, warnings } from the current ActionLog. Pure function \u2014 does not mutate the log. Warnings: FRAGILE_LOCATOR (selector lacks stable identifier), NO_DSL_PRIMITIVE (entry skipped \u2014 selector shape has no DSL function), BUNDLE_ID_IGNORED (app_launch with explicit bundleId \u2014 DSL appLaunch reads it from APP_BUNDLE_ID env). Adjacent same-section entries collapse into one //@collapse \u2026 //@endcollapse block.",
+        description: 'Returns { draftDsl, warnings } from the current ActionLog. Pure function \u2014 does not mutate the log. Warnings: FRAGILE_LOCATOR (selector lacks stable identifier), NO_DSL_PRIMITIVE (entry skipped \u2014 selector shape has no DSL function), BUNDLE_ID_IGNORED (app_launch with explicit bundleId \u2014 DSL appLaunch reads it from APP_BUNDLE_ID env). Adjacent same-section entries group into one step("section", () => { ... }) block - the mandatory test_* body structure.',
         inputSchema: {
-          explorationId: z7.string().min(1)
+          explorationId: z9.string().min(1)
         }
       },
       async ({ explorationId }) => this.tracked("generate_dsl_from_exploration", { explorationId }, async () => {
@@ -7753,12 +5951,12 @@ var SaveExplorationAsTestTool = class extends BaseTool {
       "save_exploration_as_test",
       {
         title: "Persist the generated DSL as a runnable scenario",
-        description: "Renders the ActionLog as DSL and writes it to unotest/e2e/<scenarioName>.js. Returns { path, actionCount, warnings }. Policy: by default, NO_DSL_PRIMITIVE warnings block the save \u2014 pass force: true to write anyway with `// SKIPPED \u2026` comments inline. If the file already exists, pass overwrite: true to replace it.",
+        description: "Renders the ActionLog as DSL and writes it to unotest/e2e-mobile/<scenarioName>.js. Returns { path, actionCount, warnings }. Policy: by default, NO_DSL_PRIMITIVE warnings block the save \u2014 pass force: true to write anyway with `// SKIPPED \u2026` comments inline. If the file already exists, pass overwrite: true to replace it.",
         inputSchema: {
-          explorationId: z7.string().min(1),
-          scenarioName: z7.string().min(1),
-          overwrite: z7.boolean().optional(),
-          force: z7.boolean().optional()
+          explorationId: z9.string().min(1),
+          scenarioName: z9.string().min(1),
+          overwrite: z9.boolean().optional(),
+          force: z9.boolean().optional()
         }
       },
       async ({ explorationId, scenarioName, overwrite, force }) => this.tracked(
@@ -7847,6 +6045,17 @@ function registerAllTools(server, services) {
   new InspectRuntimeTool(dbgServices).register(server);
   new AbortRuntimeTool(dbgServices).register(server);
   new ListRuntimesTool(dbgServices).register(server);
+  const attachState = new AttachState();
+  const attachSlice = { sessionRecorder: services.sessionRecorder };
+  const projectRoot = process.cwd();
+  new GetActiveContextTool(attachSlice, attachState, projectRoot).register(server);
+  new AttachDebugSessionTool(attachSlice, attachState, projectRoot).register(server);
+  new DetachDebugSessionTool(attachSlice, attachState, projectRoot).register(server);
+  new WheelTool(attachSlice, attachState, projectRoot, "agent").register(server);
+  new WheelTool(attachSlice, attachState, projectRoot, "human").register(server);
+  new ListFailuresTool(attachSlice, projectRoot).register(server);
+  new GetFailureScreenshotTool(attachSlice, projectRoot).register(server);
+  new GetFailureA11yTool(attachSlice, projectRoot).register(server);
   new AppInstallTool({
     envConfig: services.envConfig,
     logger: services.logger,