@unotest/mobile 0.8.3 → 0.10.0

package/dist/dsl/mobile-dsl-language-service.js

@@ -0,0 +1,1056 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/dsl/mobile-dsl-language-service.ts
+import { Lexer } from "@unotest/dsl";
+import { Parser } from "@unotest/dsl";
+
+// 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)}`
+    );
+  }
+  if (node.enabled !== expected) {
+    throw new Error(
+      `${fnName} failed: node.enabled=${node.enabled}, expected ${expected}. Selector: ${JSON.stringify(selector)}`
+    );
+  }
+}
+__name(assertEnabledState, "assertEnabledState");
+var assertEnabled = {
+  name: "assertEnabled",
+  argTypes: ["selector"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg) => {
+    await assertEnabledState(runtime, selectorArg, true, "assertEnabled");
+  }, "invoke")
+};
+var assertDisabled = {
+  name: "assertDisabled",
+  argTypes: ["selector"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg) => {
+    await assertEnabledState(runtime, selectorArg, false, "assertDisabled");
+  }, "invoke")
+};
+var ASSERT_FUNCTIONS = [
+  assertEqual,
+  assertVisible,
+  assertCount,
+  assertEnabled,
+  assertDisabled
+];
+
+// src/dsl/functions/data.ts
+function asString2(x, fn, idx) {
+  if (typeof x !== "string") throw new Error(`${fn}(): arg ${idx} must be a string. Got ${typeof x}.`);
+  return x;
+}
+__name(asString2, "asString");
+function toSqlParam(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return v;
+  throw new Error(`dbQuery/dbExec arg type unsupported: ${typeof v}`);
+}
+__name(toSqlParam, "toSqlParam");
+var dbQuery = {
+  name: "dbQuery",
+  argTypes: ["string"],
+  returnType: "string",
+  variadic: true,
+  invoke: /* @__PURE__ */ __name(async (runtime, sqlArg, ...rest) => {
+    const sql = asString2(sqlArg, "dbQuery", 0);
+    const params = rest.map((a, i) => {
+      try {
+        return toSqlParam(a);
+      } catch (e) {
+        throw new Error(`dbQuery: arg ${i + 1} ${e.message}`);
+      }
+    });
+    runtime.logger.debug(`dbQuery ${sql.slice(0, 200)} params=${JSON.stringify(params).slice(0, 200)}`);
+    const rows = await runtime.db.query(sql, params);
+    if (rows.length === 0) return "";
+    const firstKey = Object.keys(rows[0])[0];
+    if (!firstKey) return "";
+    const cell = rows[0][firstKey];
+    return cell == null ? "" : String(cell);
+  }, "invoke")
+};
+var dbExec = {
+  name: "dbExec",
+  argTypes: ["string"],
+  returnType: "string",
+  variadic: true,
+  invoke: /* @__PURE__ */ __name(async (runtime, sqlArg, ...rest) => {
+    const sql = asString2(sqlArg, "dbExec", 0);
+    const params = rest.map((a, i) => {
+      try {
+        return toSqlParam(a);
+      } catch (e) {
+        throw new Error(`dbExec: arg ${i + 1} ${e.message}`);
+      }
+    });
+    runtime.logger.debug(`dbExec ${sql.slice(0, 200)} params=${JSON.stringify(params).slice(0, 200)}`);
+    const result = await runtime.db.exec(sql, params);
+    if (result.rows.length === 0) return "";
+    const firstRow = result.rows[0];
+    const firstKey = Object.keys(firstRow)[0];
+    if (!firstKey) return "";
+    const cell = firstRow[firstKey];
+    return cell == null ? "" : String(cell);
+  }, "invoke")
+};
+var shell = {
+  name: "shell",
+  argTypes: ["string"],
+  returnType: "string",
+  variadic: true,
+  invoke: /* @__PURE__ */ __name(async (runtime, cmdArg, ...rest) => {
+    const cmd = asString2(cmdArg, "shell", 0);
+    const args = rest.map((a, i) => {
+      if (a === null || a === void 0) return "";
+      if (typeof a === "string") return a;
+      if (typeof a === "number" || typeof a === "boolean") return String(a);
+      throw new Error(`shell: arg ${i + 1} must be string|number|boolean|null. Got ${typeof a}.`);
+    });
+    runtime.logger.debug(`shell ${cmd} ${args.join(" ")}`);
+    const result = await runtime.shell.exec(cmd, args);
+    return result.stdout;
+  }, "invoke")
+};
+var apiCall = {
+  name: "apiCall",
+  argTypes: ["string", "string", "string"],
+  returnType: "string",
+  minArgs: 2,
+  invoke: /* @__PURE__ */ __name(async (runtime, methodArg, pathArg, bodyArg) => {
+    const method = asString2(methodArg, "apiCall", 0).toUpperCase();
+    const path = asString2(pathArg, "apiCall", 1);
+    if (method !== "GET" && method !== "POST" && method !== "PUT" && method !== "PATCH" && method !== "DELETE") {
+      throw new Error(`apiCall(): unsupported method "${method}"`);
+    }
+    let body;
+    if (bodyArg !== void 0) {
+      const bodyJson = asString2(bodyArg, "apiCall", 2);
+      try {
+        body = JSON.parse(bodyJson);
+      } catch (e) {
+        throw new Error(`apiCall(): body arg must be valid JSON. ${e.message}`);
+      }
+    }
+    runtime.logger.debug(`apiCall ${method} ${path}`);
+    const opts = { method, path };
+    if (body !== void 0) opts.body = body;
+    const resp = await runtime.api.call(opts);
+    if (!resp.ok) {
+      throw new Error(`apiCall ${method} ${path} \u2192 HTTP ${resp.status}: ${resp.raw.slice(0, 500)}`);
+    }
+    return resp.raw;
+  }, "invoke")
+};
+var DATA_FUNCTIONS = [dbQuery, dbExec, apiCall, shell];
+
+// src/dsl/functions/device.ts
+function asString3(x, fn, idx) {
+  if (typeof x !== "string") throw new Error(`${fn}(): arg ${idx} must be a string. Got ${typeof x}.`);
+  return x;
+}
+__name(asString3, "asString");
+function asBoolean(x, fn, idx) {
+  if (typeof x !== "boolean") throw new Error(`${fn}(): arg ${idx} must be a boolean. Got ${typeof x}.`);
+  return x;
+}
+__name(asBoolean, "asBoolean");
+var setDevice = {
+  name: "setDevice",
+  argTypes: ["string"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name((runtime, slotArg) => {
+    const slot = asString3(slotArg, "setDevice", 0);
+    runtime.setCurrentDeviceSlot(slot);
+  }, "invoke")
+};
+var appLaunch = {
+  name: "appLaunch",
+  argTypes: ["boolean"],
+  returnType: "void",
+  minArgs: 0,
+  invoke: /* @__PURE__ */ __name(async (runtime, cleanArg) => {
+    const clean = cleanArg !== void 0 ? asBoolean(cleanArg, "appLaunch", 0) : false;
+    await runtime.driver.appLaunch(runtime.currentDeviceSlot, { clean });
+  }, "invoke")
+};
+var openDeeplink = {
+  name: "openDeeplink",
+  argTypes: ["string"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, urlArg) => {
+    const url = asString3(urlArg, "openDeeplink", 0);
+    await runtime.driver.openDeeplink(runtime.currentDeviceSlot, url);
+  }, "invoke")
+};
+var DEVICE_FUNCTIONS = [setDevice, appLaunch, openDeeplink];
+
+// src/dsl/functions/selectors.ts
+function assertSelector(x, fnName, argIndex) {
+  if (typeof x !== "object" || x === null) {
+    throw new Error(
+      `${fnName}(): arg ${argIndex} must be a Selector (from getByTestId/getByText/getByLabel/ordinal/near). Got ${typeof x}.`
+    );
+  }
+  return x;
+}
+__name(assertSelector, "assertSelector");
+function assertString(x, fnName, argIndex) {
+  if (typeof x !== "string") {
+    throw new Error(`${fnName}(): arg ${argIndex} must be a string. Got ${typeof x}.`);
+  }
+  return x;
+}
+__name(assertString, "assertString");
+function assertNumber(x, fnName, argIndex) {
+  if (typeof x !== "number") {
+    throw new Error(`${fnName}(): arg ${argIndex} must be a number. Got ${typeof x}.`);
+  }
+  return x;
+}
+__name(assertNumber, "assertNumber");
+var getByTestId = {
+  name: "getByTestId",
+  argTypes: ["string"],
+  returnType: "selector",
+  invoke: /* @__PURE__ */ __name((_rt, testId) => {
+    return { testId: assertString(testId, "getByTestId", 0) };
+  }, "invoke")
+};
+var getByText = {
+  name: "getByText",
+  argTypes: ["string"],
+  returnType: "selector",
+  invoke: /* @__PURE__ */ __name((_rt, text) => {
+    return { text: assertString(text, "getByText", 0) };
+  }, "invoke")
+};
+var getByLabel = {
+  name: "getByLabel",
+  argTypes: ["string"],
+  returnType: "selector",
+  invoke: /* @__PURE__ */ __name((_rt, label) => {
+    return { label: assertString(label, "getByLabel", 0) };
+  }, "invoke")
+};
+var ordinal = {
+  name: "ordinal",
+  argTypes: ["selector", "number"],
+  returnType: "selector",
+  invoke: /* @__PURE__ */ __name((_rt, target, n) => {
+    return { ...assertSelector(target, "ordinal", 0), ordinal: assertNumber(n, "ordinal", 1) };
+  }, "invoke")
+};
+var near = {
+  name: "near",
+  argTypes: ["selector", "selector", "number"],
+  returnType: "selector",
+  minArgs: 2,
+  invoke: /* @__PURE__ */ __name((_rt, target, anchor, maxDist) => {
+    const t = assertSelector(target, "near", 0);
+    const a = assertSelector(anchor, "near", 1);
+    const near2 = { anchor: a };
+    if (maxDist !== void 0) near2.maxDistancePx = assertNumber(maxDist, "near", 2);
+    return { ...t, near: near2 };
+  }, "invoke")
+};
+var SELECTOR_FUNCTIONS = [getByTestId, getByText, getByLabel, ordinal, near];
+
+// src/dsl/functions/time.ts
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+__name(pad2, "pad2");
+function isoDate(ms) {
+  const d = new Date(ms);
+  return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+}
+__name(isoDate, "isoDate");
+var todayFn = {
+  name: "today",
+  argTypes: [],
+  returnType: "string",
+  invoke: /* @__PURE__ */ __name((runtime) => isoDate(runtime.now()), "invoke")
+};
+var daysFromNow = {
+  name: "daysFromNow",
+  argTypes: ["number"],
+  returnType: "string",
+  invoke: /* @__PURE__ */ __name((runtime, nArg) => {
+    if (typeof nArg !== "number" || !Number.isFinite(nArg)) {
+      throw new Error(`daysFromNow(): arg 0 must be a finite number. Got ${nArg}.`);
+    }
+    const dayMs = 24 * 60 * 60 * 1e3;
+    return isoDate(runtime.now() + Math.trunc(nArg) * dayMs);
+  }, "invoke")
+};
+var nowMs = {
+  name: "nowMs",
+  argTypes: [],
+  returnType: "number",
+  invoke: /* @__PURE__ */ __name((runtime) => runtime.now(), "invoke")
+};
+var TIME_FUNCTIONS = [todayFn, daysFromNow, nowMs];
+
+// src/dsl/functions/ui.ts
+import { setTimeout as wait } from "timers/promises";
+function asSelector2(x, fn, idx) {
+  if (typeof x !== "object" || x === null) {
+    throw new Error(`${fn}(): arg ${idx} must be a Selector (use getByTestId/Text/Label). Got ${typeof x}.`);
+  }
+  return x;
+}
+__name(asSelector2, "asSelector");
+function asString4(x, fn, idx) {
+  if (typeof x !== "string") throw new Error(`${fn}(): arg ${idx} must be a string. Got ${typeof x}.`);
+  return x;
+}
+__name(asString4, "asString");
+function asNumber2(x, fn, idx) {
+  if (typeof x !== "number") throw new Error(`${fn}(): arg ${idx} must be a number. Got ${typeof x}.`);
+  return x;
+}
+__name(asNumber2, "asNumber");
+async function pollUntilFound(runtime, selector, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastFailure = null;
+  while (Date.now() < deadline) {
+    const tree = await runtime.driver.a11yTree(runtime.currentDeviceSlot);
+    const r = runtime.selectorResolver.resolve(tree, selector);
+    if (r.ok) return;
+    lastFailure = { reason: r.reason, candidates: r.candidates };
+    await wait(150);
+  }
+  throw new Error(
+    `Selector not found within ${timeoutMs}ms on slot "${runtime.currentDeviceSlot}": ${JSON.stringify(selector)}
+  reason: ${lastFailure?.reason ?? "unknown"}
+  candidates: ${JSON.stringify(lastFailure?.candidates ?? [], null, 2).slice(0, 600)}`
+  );
+}
+__name(pollUntilFound, "pollUntilFound");
+var tap = {
+  name: "tap",
+  argTypes: ["selector"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg) => {
+    const selector = asSelector2(selectorArg, "tap", 0);
+    await pollUntilFound(runtime, selector, runtime.envConfig.defaultActionWaitMs);
+    await runtime.driver.tap(runtime.currentDeviceSlot, selector);
+  }, "invoke")
+};
+var type_ = {
+  name: "type",
+  argTypes: ["selector", "string"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, selectorArg, textArg) => {
+    const selector = asSelector2(selectorArg, "type", 0);
+    const text = asString4(textArg, "type", 1);
+    await pollUntilFound(runtime, selector, runtime.envConfig.defaultActionWaitMs);
+    await runtime.driver.type(runtime.currentDeviceSlot, selector, text);
+  }, "invoke")
+};
+var swipe = {
+  name: "swipe",
+  argTypes: ["string", "selector"],
+  returnType: "void",
+  minArgs: 1,
+  invoke: /* @__PURE__ */ __name(async (runtime, directionArg, fromArg) => {
+    const direction = asString4(directionArg, "swipe", 0);
+    if (direction !== "up" && direction !== "down" && direction !== "left" && direction !== "right") {
+      throw new Error(`swipe(): direction must be 'up'|'down'|'left'|'right'. Got "${direction}".`);
+    }
+    let from;
+    if (fromArg !== void 0) {
+      from = asSelector2(fromArg, "swipe", 1);
+      await pollUntilFound(runtime, from, runtime.envConfig.defaultActionWaitMs);
+    }
+    await runtime.driver.swipe(runtime.currentDeviceSlot, direction, from);
+  }, "invoke")
+};
+var pressKey = {
+  name: "pressKey",
+  argTypes: ["string"],
+  returnType: "void",
+  invoke: /* @__PURE__ */ __name(async (runtime, keyArg) => {
+    const key = asString4(keyArg, "pressKey", 0);
+    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")
+};
+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
+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";
+
+// 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"
+};
+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" }
+};
+var RETURN_KIND = {
+  void: "void",
+  string: "string",
+  number: "number",
+  boolean: "bool",
+  selector: "locator",
+  any: "unknown"
+};
+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, "MobileDslRegistry");
+  }
+  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));
+    }
+  }
+  resolve(name) {
+    return this.byName.get(name) ?? null;
+  }
+  resolveContract(name) {
+    return this.resolve(name);
+  }
+  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"
+];
+
+// 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;
+  }
+};
+function isBlockMappable(name) {
+  return name.startsWith("test_") || name.startsWith("flow_");
+}
+__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/mobile-dsl-language-service.ts
+var SELECTOR_FNS = /* @__PURE__ */ new Set([
+  "getByTestId",
+  "getByText",
+  "getByLabel",
+  "ordinal",
+  "near"
+]);
+var WAIT_FNS = /* @__PURE__ */ new Set(["waitFor", "pause"]);
+var STATE_FNS = /* @__PURE__ */ new Set(["dbQuery", "dbExec", "apiCall", "shell"]);
+var READ_FNS = /* @__PURE__ */ new Set(["today", "daysFromNow", "nowMs"]);
+function categoryFor(name) {
+  if (name.startsWith("assert")) return "assertion";
+  if (SELECTOR_FNS.has(name)) return "selector";
+  if (WAIT_FNS.has(name)) return "wait";
+  if (STATE_FNS.has(name)) return "state";
+  if (READ_FNS.has(name)) return "read";
+  return "action";
+}
+__name(categoryFor, "categoryFor");
+function vocabEntryFor(fn) {
+  const required = fn.minArgs ?? fn.argTypes.length;
+  const args = fn.argTypes.map((kind, i) => ({
+    label: `arg${i + 1}`,
+    kind,
+    required: i < required
+  }));
+  const placeholders = args.map((a, i) => `\${${i + 1}:${a.label}}`).join(", ");
+  const sigArgs = args.map((a) => a.required ? a.label : `${a.label}?`).join(", ");
+  return {
+    name: fn.name,
+    category: categoryFor(fn.name),
+    args,
+    returns: fn.returnType,
+    insertText: `${fn.name}(${placeholders})`,
+    signature: `${fn.name}(${sigArgs})`,
+    locatorCapability: fn.returnType === "selector" ? "locator" : "none"
+  };
+}
+__name(vocabEntryFor, "vocabEntryFor");
+function toDslDiagnostic(d) {
+  return {
+    severity: d.severity,
+    line: d.line,
+    column: d.col,
+    message: d.message,
+    rule: `linter:${d.code}`,
+    source: "lint"
+  };
+}
+__name(toDslDiagnostic, "toDslDiagnostic");
+var MobileDslLanguageService = class {
+  static {
+    __name(this, "MobileDslLanguageService");
+  }
+  vocab;
+  registry = buildDefaultRegistry();
+  constructor() {
+    this.vocab = ALL_DSL_FUNCTIONS.map(vocabEntryFor).sort(
+      (a, b) => a.name.localeCompare(b.name)
+    );
+  }
+  getVocab() {
+    return this.vocab;
+  }
+  validate(source, ctx) {
+    let ast;
+    try {
+      ast = new Parser(new Lexer(source).tokenize()).parse();
+    } catch (e) {
+      return [
+        {
+          severity: "error",
+          line: 1,
+          column: 1,
+          message: e instanceof Error ? e.message : String(e),
+          rule: "parse",
+          source: "parse"
+        }
+      ];
+    }
+    const userFunctionNames = new Set(ctx?.helperNames ?? []);
+    const linter = new DslLinter({ registry: this.registry, knownSlots: [] });
+    return linter.lint(ast, source, { userFunctionNames }).filter((d) => d.code !== "E3").map(toDslDiagnostic);
+  }
+};
+var mobileDslLanguageService = new MobileDslLanguageService();
+var mobile_dsl_language_service_default = mobileDslLanguageService;
+export {
+  MobileDslLanguageService,
+  mobile_dsl_language_service_default as default,
+  mobileDslLanguageService
+};