@skyramp/mcp 0.3.2 → 0.3.4

package/node_modules/playwright/lib/mcp/skyramp/specImport.js

@@ -0,0 +1,781 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var specImport_exports = {};
+__export(specImport_exports, {
+  specLanguageForPath: () => specLanguageForPath,
+  specToActions: () => specToActions
+});
+module.exports = __toCommonJS(specImport_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+const TEST_ID_ATTRIBUTE = "data-testid";
+function specLanguageForPath(specPath) {
+  if (specPath.endsWith(".py"))
+    return "python";
+  if (specPath.endsWith(".ts") || specPath.endsWith(".js") || specPath.endsWith(".mjs") || specPath.endsWith(".cjs"))
+    return "javascript";
+  return void 0;
+}
+function specToActions(content, language, specDir) {
+  const dir = specDir ?? ".";
+  return language === "python" ? new PySpecParser(content, dir).parse() : new JsSpecParser(content, dir).parse();
+}
+function scanStatements(content, commentPrefix) {
+  const statements = [];
+  let buffer = "";
+  let startLine = 0;
+  let indent = 0;
+  let depth = 0;
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i].trim();
+    if (!buffer) {
+      if (!raw || raw.startsWith(commentPrefix))
+        continue;
+      startLine = i + 1;
+      indent = lines[i].length - lines[i].trimStart().length;
+    }
+    buffer = buffer ? `${buffer} ${raw}` : raw;
+    depth = bracketDepth(buffer);
+    if (depth > 0 && !/^test\(/.test(buffer))
+      continue;
+    statements.push({ text: buffer, line: startLine, indent });
+    buffer = "";
+  }
+  if (buffer)
+    statements.push({ text: buffer, line: startLine, indent });
+  return statements;
+}
+function bracketDepth(text) {
+  let depth = 0;
+  let quote;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      if (c === "\\")
+        i++;
+      else if (c === quote)
+        quote = void 0;
+      continue;
+    }
+    if (c === "'" || c === '"' || c === "`")
+      quote = c;
+    else if (c === "(" || c === "{" || c === "[")
+      depth++;
+    else if (c === ")" || c === "}" || c === "]")
+      depth--;
+  }
+  return depth;
+}
+const MODIFIER_MASKS = {
+  "Alt": 1,
+  "Control": 2,
+  "Meta": 4,
+  "Shift": 8,
+  "ControlOrMeta": 6
+};
+class SpecParserBase {
+  constructor(statements, specDir) {
+    this._actions = [];
+    this._diagnostics = [];
+    // const playwrightRequestN / expectedPayloadN = {...} — data bindings whose
+    // values are inlined where getValue() references them.
+    this._bindings = /* @__PURE__ */ new Map();
+    // Variables that hold pages (test fixture `page` + pageN/popupPage
+    // declarations). Value is the pageAlias used in the emitted actions.
+    this._pageAliases = /* @__PURE__ */ new Map([["page", "page"]]);
+    // Variables consumed by the waitForResponse / fileChooser patterns.
+    this._promiseVars = /* @__PURE__ */ new Set();
+    // A pending expect-filechooser: the next click is the chooser trigger and is
+    // folded into the fileChooser action (replay performs the trigger click
+    // itself — see loadTraceTool performClientAction).
+    this._pendingFileChooser = false;
+    this._statements = statements;
+    this._specDir = specDir;
+  }
+  parse() {
+    for (const stmt of this._statements)
+      this._parseStatement(stmt);
+    if (this._pendingFileChooser)
+      this._diagnostics.push({ line: 0, text: "expect filechooser", reason: "file chooser was opened but no setFiles/set_files followed" });
+    return { actions: this._actions, diagnostics: this._diagnostics };
+  }
+  _diag(stmt, reason) {
+    this._diagnostics.push({ line: stmt.line, text: stmt.text.length > 120 ? stmt.text.slice(0, 117) + "..." : stmt.text, reason });
+  }
+  _push(pageAlias, framePath, action) {
+    const index = this._actions.length;
+    this._actions.push({
+      frame: { pageGuid: "", pageAlias, framePath },
+      action: { signals: [], timestamp: String(index + 1), ...action },
+      startTime: index + 1
+    });
+  }
+  /**
+   * Split a locator chain into iframe frame hops + leaf, converting each part
+   * to a selector via the upstream locator parser. Generated chains pierce
+   * frames only via contentFrame()/content_frame:
+   *   locator("iframe[title=\"x\"]").contentFrame().getByRole(...) →
+   *   framePath ['iframe[title="x"]'], leaf getByRole(...)
+   */
+  _resolveLocatorChain(chain) {
+    const segments = chain.split(this._frameHopSplit);
+    const framePath = [];
+    for (let i = 0; i < segments.length - 1; i++) {
+      const hop = (0, import_utils.locatorOrSelectorAsSelector)(this._locatorLanguage, segments[i], TEST_ID_ATTRIBUTE);
+      if (!hop)
+        return void 0;
+      framePath.push(hop);
+    }
+    const leafSource = segments[segments.length - 1];
+    if (!leafSource)
+      return void 0;
+    const selector = (0, import_utils.locatorOrSelectorAsSelector)(this._locatorLanguage, leafSource, TEST_ID_ATTRIBUTE);
+    if (!selector)
+      return void 0;
+    return { selector, framePath };
+  }
+  /** Emit the action for a parsed `<locator chain>.<method>(<args>)` statement. */
+  _emitLocatorAction(stmt, pageAlias, chain, method, args) {
+    const resolved = this._resolveLocatorChain(chain);
+    if (!resolved) {
+      this._diag(stmt, "could not parse the locator chain \u2014 not replayed");
+      return;
+    }
+    const { selector, framePath } = resolved;
+    if (method === "click" && this._pendingFileChooser) {
+      this._pendingFileChooser = false;
+      this._heldChooserTrigger = { selector, framePath, pageAlias };
+      return;
+    }
+    switch (method) {
+      case "click":
+      case "dblclick": {
+        const opts = this._parseCallOptions(args);
+        const action = { name: "click", selector, button: opts.button ?? "left", modifiers: opts.modifiers ?? 0, clickCount: method === "dblclick" ? 2 : opts.clickCount ?? 1 };
+        if (opts.position)
+          action.position = opts.position;
+        this._push(pageAlias, framePath, action);
+        return;
+      }
+      case "hover": {
+        const opts = this._parseCallOptions(args);
+        const action = { name: "hover", selector };
+        if (opts.position)
+          action.position = opts.position;
+        this._push(pageAlias, framePath, action);
+        return;
+      }
+      case "fill":
+      case "pressSequentially": {
+        const text = this._resolveStringArg(args);
+        if (text === void 0) {
+          this._diag(stmt, `could not resolve the ${method}() argument \u2014 not replayed`);
+          return;
+        }
+        this._push(pageAlias, framePath, { name: method, selector, text });
+        return;
+      }
+      case "press": {
+        const shortcut = this._resolveStringArg(args);
+        if (shortcut === void 0) {
+          this._diag(stmt, "could not resolve the press() argument \u2014 not replayed");
+          return;
+        }
+        const parts = shortcut.split("+");
+        const key = parts.pop();
+        let modifiers = 0;
+        for (const p of parts)
+          modifiers |= MODIFIER_MASKS[p] ?? 0;
+        this._push(pageAlias, framePath, { name: "press", selector, key, modifiers });
+        return;
+      }
+      case "check":
+      case "uncheck":
+        this._push(pageAlias, framePath, { name: method, selector });
+        return;
+      case "select": {
+        const options = this._parseStringArray(args);
+        if (!options) {
+          this._diag(stmt, "could not resolve the select option argument \u2014 not replayed");
+          return;
+        }
+        this._push(pageAlias, framePath, { name: "select", selector, options });
+        return;
+      }
+      case "setInputFiles": {
+        this._push(pageAlias, framePath, { name: "setInputFiles", selector, files: this._parseFileArgs(args) });
+        return;
+      }
+      case "dragTo": {
+        const targetMatch = args.match(/^\s*(\w+)\.([\s\S]+?)\s*(?:,\s*\{[\s\S]*\})?$/);
+        const target = targetMatch && this._pageAliases.has(targetMatch[1]) ? this._resolveLocatorChain(targetMatch[2]) : void 0;
+        if (!target) {
+          this._diag(stmt, "could not parse the drag target locator \u2014 not replayed");
+          return;
+        }
+        this._push(pageAlias, framePath, { name: "dragTo", selector, target: target.selector });
+        return;
+      }
+    }
+  }
+  /**
+   * Emit the bare assertApiRequest MARKER for a checkRequestPayload statement.
+   * The payload assertion cannot execute during replay (no primitive), but its
+   * trace-side representation is just a marker whose payload/URL live in the
+   * HAR — the Go codegen re-correlates them at generate time. Emitting the
+   * marker means a combined export + regenerate keeps the assertion instead of
+   * silently losing it (SKYR-4083). Attributed to the last action's tab (the
+   * statement itself names no page).
+   */
+  _emitApiRequestMarker(stmt) {
+    const pageAlias = this._actions.length ? this._actions[this._actions.length - 1].frame.pageAlias : "page";
+    this._push(pageAlias, [], { name: "assertApiRequest" });
+    this._diag(stmt, "payload assertion is not executed during replay; preserved as an assertApiRequest marker for export/regeneration");
+  }
+  /** Emit the fileChooser action for a setFiles/set_files on a chooser variable. */
+  _emitSetFiles(stmt, args) {
+    const trigger = this._heldChooserTrigger;
+    this._heldChooserTrigger = void 0;
+    if (!trigger) {
+      this._diag(stmt, "setFiles without a preceding chooser trigger click \u2014 not replayed");
+      return;
+    }
+    this._push(trigger.pageAlias, trigger.framePath, { name: "fileChooser", selector: trigger.selector, files: this._parseFileArgs(args) });
+  }
+  /** Emit the assert/visualSnapshot action for an expect() statement. */
+  _emitExpect(stmt, subject, matcher, args) {
+    if (matcher === "screenshot") {
+      this._emitScreenshot(stmt, subject, args);
+      return;
+    }
+    const subjMatch = subject.match(/^(\w+)\.([\s\S]+)$/);
+    const resolved = subjMatch && this._pageAliases.has(subjMatch[1]) ? this._resolveLocatorChain(subjMatch[2]) : void 0;
+    if (!resolved) {
+      this._diag(stmt, "could not parse the expect() subject locator \u2014 not replayed");
+      return;
+    }
+    const { selector, framePath } = resolved;
+    const pageAlias = this._pageAliases.get(subjMatch[1]);
+    switch (matcher) {
+      case "assertText":
+      case "assertTextSub": {
+        const text = this._resolveStringArg(args);
+        if (text === void 0) {
+          this._diag(stmt, "could not resolve the text assertion argument \u2014 not replayed");
+          return;
+        }
+        this._push(pageAlias, framePath, { name: "assertText", selector, text, substring: matcher === "assertTextSub" });
+        return;
+      }
+      case "assertValue": {
+        const value = this._resolveStringArg(args);
+        if (value === void 0) {
+          this._diag(stmt, "could not resolve the value assertion argument \u2014 not replayed");
+          return;
+        }
+        this._push(pageAlias, framePath, { name: "assertValue", selector, value });
+        return;
+      }
+      case "assertChecked":
+        this._push(pageAlias, framePath, { name: "assertChecked", selector, checked: !/checked\s*[:=]\s*(false|False)/.test(args) });
+        return;
+      case "assertVisible":
+        this._push(pageAlias, framePath, { name: "assertVisible", selector });
+        return;
+    }
+  }
+  _emitScreenshot(stmt, subject, args) {
+    const filenameMatch = args.match(/^\s*(["'])((?:[^\\]|\\.)*?)\1/);
+    const filename = filenameMatch ? unescapeString(filenameMatch[2]) : "";
+    const fullPage = /full_?[pP]age\s*[:=]\s*(true|True)/.test(args);
+    const clipMatch = args.match(/clip\s*[:=]\s*(\{[^}]*\})/);
+    if (this._pageAliases.has(subject.trim())) {
+      const pageAlias = this._pageAliases.get(subject.trim());
+      if (clipMatch)
+        this._push(pageAlias, [], { name: "visualSnapshot", snapshotType: "region", filename, clip: parseLooseObject(clipMatch[1]) });
+      else
+        this._push(pageAlias, [], { name: "visualSnapshot", snapshotType: "page", filename, ...fullPage ? { fullPage: true } : {} });
+      return;
+    }
+    const subjMatch = subject.match(/^(\w+)\.([\s\S]+)$/);
+    const resolved = subjMatch && this._pageAliases.has(subjMatch[1]) ? this._resolveLocatorChain(subjMatch[2]) : void 0;
+    if (!resolved) {
+      this._diag(stmt, "could not parse the screenshot subject locator \u2014 not replayed");
+      return;
+    }
+    this._push(this._pageAliases.get(subjMatch[1]), resolved.framePath, { name: "visualSnapshot", snapshotType: "element", selector: resolved.selector, filename });
+  }
+  /** Emit page.mouse.* actions (coordinates + kwargs are language-neutral). */
+  _emitMouse(stmt, pageAlias, method, args) {
+    const nums = [...args.matchAll(/-?\d+(?:\.\d+)?/g)].map((m) => Number(m[0]));
+    switch (method) {
+      case "move": {
+        if (nums.length < 2)
+          break;
+        const stepsMatch = args.match(/steps\s*[:=]\s*(\d+)/);
+        const action = { name: "mouse.move", position: { x: nums[0], y: nums[1] } };
+        if (stepsMatch)
+          action.steps = Number(stepsMatch[1]);
+        this._push(pageAlias, [], action);
+        return;
+      }
+      case "down":
+      case "up": {
+        const buttonMatch = args.match(/button\s*[:=]\s*["'](\w+)["']/);
+        const action = { name: `mouse.${method}` };
+        if (buttonMatch)
+          action.button = buttonMatch[1];
+        this._push(pageAlias, [], action);
+        return;
+      }
+      case "wheel": {
+        if (nums.length < 2)
+          break;
+        this._push(pageAlias, [], { name: "mouse.wheel", position: { x: 0, y: 0 }, deltaX: nums[0], deltaY: nums[1], modifiers: 0 });
+        return;
+      }
+      case "click": {
+        if (nums.length < 2)
+          break;
+        this._push(pageAlias, [], { name: "click", selector: "body", position: { x: nums[0], y: nums[1] }, button: "left", modifiers: 0, clickCount: 1 });
+        return;
+      }
+    }
+    this._diag(stmt, `could not parse mouse.${method}() arguments \u2014 not replayed`);
+  }
+  /**
+   * Resolve a single string-valued call argument: a literal, or a
+   * getValue(playwrightRequestN, "key") reference whose value is inlined from
+   * the tracked binding.
+   */
+  _resolveStringArg(args) {
+    const literal = args.match(/^\s*(["'])((?:[^\\]|\\.|(?!\1).)*?)\1\s*$/s);
+    if (literal)
+      return unescapeString(literal[2]);
+    const getValue = this._matchGetValue(args);
+    if (getValue) {
+      const binding = this._bindings.get(getValue.binding);
+      if (binding === void 0)
+        return void 0;
+      let value = binding;
+      for (const part of getValue.key.split("."))
+        value = value?.[part];
+      if (value === void 0)
+        return void 0;
+      return String(value);
+    }
+    return void 0;
+  }
+  /** Parse select-option args: a string literal or an array of string literals. */
+  _parseStringArray(args) {
+    const single = this._resolveStringArg(args);
+    if (single !== void 0)
+      return [single];
+    const arrayMatch = args.match(/^\s*\[([\s\S]*)\]\s*$/);
+    if (arrayMatch)
+      return [...arrayMatch[1].matchAll(/(["'])((?:[^\\]|\\.|(?!\1).)*?)\1/g)].map((m) => unescapeString(m[2]));
+    return void 0;
+  }
+  /**
+   * Parse setFiles/set_input_files arguments into file paths. Generated specs
+   * emit a spec-relative join (`path.join(__dirname, 'fixtures', "data.csv")`
+   * / `os.path.join(os.path.dirname(__file__), ...)`) — resolved against the
+   * spec file's directory — or plain string literals.
+   */
+  _parseFileArgs(args) {
+    const files = [];
+    const joinRe = /(?:path\.join\(\s*__dirname|os\.path\.join\(\s*os\.path\.dirname\(__file__\))\s*((?:,\s*(["'])(?:[^\\]|\\.)*?\2\s*)+)\)/g;
+    let joinMatch;
+    let rest = args;
+    while (joinMatch = joinRe.exec(args)) {
+      const parts = [...joinMatch[1].matchAll(/(["'])((?:[^\\]|\\.)*?)\1/g)].map((m) => unescapeString(m[2]));
+      files.push(import_path.default.join(this._specDir, ...parts));
+      rest = rest.replace(joinMatch[0], "");
+    }
+    for (const m of rest.matchAll(/(["'])((?:[^\\]|\\.)*?)\1/g)) {
+      const p = unescapeString(m[2]);
+      files.push(import_path.default.isAbsolute(p) ? p : import_path.default.join(this._specDir, p));
+    }
+    return files;
+  }
+  /** Parse the trailing options of a click/hover call (button, clickCount/click_count, position, modifiers). */
+  _parseCallOptions(args) {
+    const out = {};
+    const buttonMatch = args.match(/button\s*[:=]\s*["'](left|middle|right)["']/);
+    if (buttonMatch)
+      out.button = buttonMatch[1];
+    const clickCountMatch = args.match(/click_?[cC]ount\s*[:=]\s*(\d+)/);
+    if (clickCountMatch)
+      out.clickCount = Number(clickCountMatch[1]);
+    const positionMatch = args.match(/position\s*[:=]\s*(\{[^}]*\})/);
+    if (positionMatch) {
+      const pos = parseLooseObject(positionMatch[1]);
+      if (typeof pos.x === "number" && typeof pos.y === "number")
+        out.position = { x: pos.x, y: pos.y };
+    }
+    const modifiersMatch = args.match(/modifiers\s*[:=]\s*\[([^\]]*)\]/);
+    if (modifiersMatch) {
+      let mask = 0;
+      for (const m of modifiersMatch[1].matchAll(/["'](\w+)["']/g))
+        mask |= MODIFIER_MASKS[m[1]] ?? 0;
+      out.modifiers = mask;
+    }
+    return out;
+  }
+}
+const JS_SCAFFOLDING = [
+  /^import\b/,
+  /^const\s+.*=\s*require\(/,
+  /^const\s+pageTimeout\b/,
+  /^test\(/,
+  /^test\.setTimeout\(/,
+  /^test\.use\(/,
+  /^\}\)?;?$/,
+  /^(await\s+)?\w+\.setDefaultTimeout\(/,
+  /^page\s*=\s*newSkyrampPlaywrightPage\(/,
+  /^'use strict'/
+];
+const JS_LOCATOR_METHODS = "click|dblclick|hover|fill|press|pressSequentially|check|uncheck|selectOption|setInputFiles|dragTo";
+const JS_METHOD_MAP = {
+  selectOption: "select",
+  dragTo: "dragTo",
+  setInputFiles: "setInputFiles"
+};
+class JsSpecParser extends SpecParserBase {
+  constructor(content, specDir) {
+    super(scanStatements(content, "//"), specDir);
+    this._locatorLanguage = "javascript";
+    this._frameHopSplit = /\.contentFrame\(\)\.?/;
+  }
+  _matchGetValue(args) {
+    const m = args.match(/^\s*getValue\(\s*(\w+)\s*,\s*(["'])((?:[^\\]|\\.)*?)\2\s*\)(\.toString\(\))?\s*$/);
+    return m ? { binding: m[1], key: unescapeString(m[3]) } : void 0;
+  }
+  _parseStatement(stmt) {
+    const text = stmt.text.replace(/;$/, "");
+    for (const re of JS_SCAFFOLDING) {
+      if (re.test(text))
+        return;
+    }
+    const bindingMatch = text.match(/^const\s+(\w+)\s*(?::[^=]+)?=\s*(\{[\s\S]*\})$/);
+    if (bindingMatch) {
+      try {
+        this._bindings.set(bindingMatch[1], JSON.parse(bindingMatch[2]));
+      } catch {
+        this._diag(stmt, "object literal is not plain JSON; getValue() references to it cannot be inlined");
+        this._bindings.set(bindingMatch[1], void 0);
+      }
+      return;
+    }
+    const responsePromiseMatch = text.match(/^const\s+(\w+)\s*=\s*(\w+)\.waitForResponse\(/);
+    if (responsePromiseMatch) {
+      this._promiseVars.add(responsePromiseMatch[1]);
+      this._diag(stmt, "waitForResponse is a codegen enrichment with no replay primitive \u2014 not replayed");
+      return;
+    }
+    const chooserPromiseMatch = text.match(/^const\s+(\w+)\s*=\s*(\w+)\.waitForEvent\(\s*["']filechooser["']\s*\)/);
+    if (chooserPromiseMatch) {
+      this._promiseVars.add(chooserPromiseMatch[1]);
+      this._pendingFileChooser = true;
+      return;
+    }
+    const awaitPromiseMatch = text.match(/^const\s+(\w+)\s*=\s*await\s+(\w+)$/);
+    if (awaitPromiseMatch && this._promiseVars.has(awaitPromiseMatch[2])) {
+      this._promiseVars.add(awaitPromiseMatch[1]);
+      return;
+    }
+    const newPageMatch = text.match(/^const\s+(\w+)\s*=\s*await\s+(\w+)\.context\(\)\.newPage\(\)$/);
+    if (newPageMatch) {
+      this._pageAliases.set(newPageMatch[1], newPageMatch[1]);
+      this._push(newPageMatch[1], [], { name: "openPage", url: "about:blank" });
+      return;
+    }
+    const waitForPageMatch = text.match(/^const\s+(\w+)\s*=\s*await\s+(\w+)\.waitForPage\(/);
+    if (waitForPageMatch) {
+      this._pageAliases.set(waitForPageMatch[1], waitForPageMatch[1]);
+      this._push(waitForPageMatch[1], [], { name: "openPage", url: "about:blank" });
+      return;
+    }
+    const setFilesMatch = text.match(/^await\s+(\w+)\.setFiles\(([\s\S]*)\)$/);
+    if (setFilesMatch && this._promiseVars.has(setFilesMatch[1])) {
+      this._emitSetFiles(stmt, setFilesMatch[2]);
+      return;
+    }
+    if (/^(await\s+)?checkRequestPayload\(/.test(text)) {
+      this._emitApiRequestMarker(stmt);
+      return;
+    }
+    const gotoMatch = text.match(/^await\s+(\w+)\.goto\(\s*(["'])((?:[^\\]|\\.)*?)\2/);
+    if (gotoMatch && this._pageAliases.has(gotoMatch[1])) {
+      this._push(this._pageAliases.get(gotoMatch[1]), [], { name: "navigate", url: unescapeString(gotoMatch[3]) });
+      return;
+    }
+    const waitTimeoutMatch = text.match(/^await\s+(\w+)\.waitForTimeout\(\s*(\d+)\s*\)$/);
+    if (waitTimeoutMatch && this._pageAliases.has(waitTimeoutMatch[1])) {
+      this._push(this._pageAliases.get(waitTimeoutMatch[1]), [], { name: "waitForTimeout", duration: Number(waitTimeoutMatch[2]) });
+      return;
+    }
+    const evaluateMatch = text.match(/^await\s+(\w+)\.evaluate\(([\s\S]*)\)$/);
+    if (evaluateMatch && this._pageAliases.has(evaluateMatch[1])) {
+      this._push(this._pageAliases.get(evaluateMatch[1]), [], { name: "evaluate", expression: evaluateMatch[2].trim() });
+      return;
+    }
+    const closeMatch = text.match(/^await\s+(\w+)\.close\(\)$/);
+    if (closeMatch && this._pageAliases.has(closeMatch[1])) {
+      this._push(this._pageAliases.get(closeMatch[1]), [], { name: "closePage" });
+      return;
+    }
+    const mouseMatch = text.match(/^await\s+(\w+)\.mouse\.(move|down|up|wheel|click)\(([\s\S]*)\)$/);
+    if (mouseMatch && this._pageAliases.has(mouseMatch[1])) {
+      this._emitMouse(stmt, this._pageAliases.get(mouseMatch[1]), mouseMatch[2], mouseMatch[3]);
+      return;
+    }
+    const expectMatch = text.match(/^await\s+expect\(\s*([\s\S]+?)\s*\)\.(not\.)?(\w+)\(([\s\S]*)\)$/);
+    if (expectMatch) {
+      if (expectMatch[2]) {
+        this._diag(stmt, `negated expect matcher .not.${expectMatch[3]} has no trace equivalent \u2014 not replayed`);
+        return;
+      }
+      const matcher = {
+        toHaveScreenshot: "screenshot",
+        toHaveText: "assertText",
+        toContainText: "assertTextSub",
+        toHaveValue: "assertValue",
+        toBeChecked: "assertChecked",
+        toBeVisible: "assertVisible"
+      }[expectMatch[3]];
+      if (!matcher) {
+        this._diag(stmt, `expect matcher .${expectMatch[3]}() has no trace equivalent \u2014 not replayed`);
+        return;
+      }
+      this._emitExpect(stmt, expectMatch[1], matcher, expectMatch[4]);
+      return;
+    }
+    const actionMatch = text.match(new RegExp(`^await\\s+(\\w+)\\.([\\s\\S]+)\\.(${JS_LOCATOR_METHODS})\\(([\\s\\S]*)\\)$`));
+    if (actionMatch && this._pageAliases.has(actionMatch[1])) {
+      this._emitLocatorAction(stmt, this._pageAliases.get(actionMatch[1]), actionMatch[2], JS_METHOD_MAP[actionMatch[3]] ?? actionMatch[3], actionMatch[4]);
+      return;
+    }
+    this._diag(stmt, "unrecognized statement \u2014 not replayed");
+  }
+}
+const PY_SCAFFOLDING = [
+  /^import\b/,
+  /^from\s+[\w.]+\s+import\b/,
+  /^@/,
+  /^def\s+test_\w+\(/,
+  /^\w+\.set_default_timeout\(/,
+  /^page\s*=\s*skyramp\.new_skyramp_playwright_page\(/
+];
+const PY_LOCATOR_METHODS = "click|dblclick|hover|fill|press|press_sequentially|pressSequentially|check|uncheck|select_option|set_input_files|drag_to";
+const PY_METHOD_MAP = {
+  press_sequentially: "pressSequentially",
+  select_option: "select",
+  set_input_files: "setInputFiles",
+  drag_to: "dragTo"
+};
+const PY_EXPECT_MATCHERS = {
+  to_have_screenshot: "screenshot",
+  to_have_text: "assertText",
+  to_contain_text: "assertTextSub",
+  to_have_value: "assertValue",
+  to_be_checked: "assertChecked",
+  to_be_visible: "assertVisible"
+};
+class PySpecParser extends SpecParserBase {
+  constructor(content, specDir) {
+    super(scanStatements(content, "#"), specDir);
+    this._locatorLanguage = "python";
+    this._frameHopSplit = /\.content_frame\./;
+  }
+  _matchGetValue(args) {
+    const m = args.match(/^\s*(?:str\(\s*)?skyramp\.get_value\(\s*(\w+)\s*,\s*(["'])((?:[^\\]|\\.)*?)\2\s*\)\s*\)?\s*$/);
+    return m ? { binding: m[1], key: unescapeString(m[3]) } : void 0;
+  }
+  _parseStatement(stmt) {
+    if (this._skipBlockIndent !== void 0) {
+      if (stmt.indent > this._skipBlockIndent)
+        return;
+      this._skipBlockIndent = void 0;
+    }
+    const defMatch = stmt.text.match(/^def\s+(\w+)\(/);
+    if (defMatch && !defMatch[1].startsWith("test_")) {
+      this._skipBlockIndent = stmt.indent;
+      return;
+    }
+    const text = stmt.text;
+    for (const re of PY_SCAFFOLDING) {
+      if (re.test(text))
+        return;
+    }
+    const expectResponseMatch = text.match(/^with\s+(\w+)\.expect_response\([\s\S]*\)\s+as\s+(\w+)\s*:$/);
+    if (expectResponseMatch) {
+      this._promiseVars.add(expectResponseMatch[2]);
+      this._diag(stmt, "waitForResponse is a codegen enrichment with no replay primitive \u2014 not replayed");
+      return;
+    }
+    const expectChooserMatch = text.match(/^with\s+(\w+)\.expect_file_chooser\(\)\s+as\s+(\w+)\s*:$/);
+    if (expectChooserMatch) {
+      this._promiseVars.add(expectChooserMatch[2]);
+      this._pendingFileChooser = true;
+      return;
+    }
+    const bindingMatch = text.match(/^(\w+)\s*=\s*(\{[\s\S]*\})$/);
+    if (bindingMatch) {
+      const json = pyLiteralToJson(bindingMatch[2]);
+      try {
+        this._bindings.set(bindingMatch[1], JSON.parse(json));
+      } catch {
+        this._diag(stmt, "dict literal could not be parsed; get_value() references to it cannot be inlined");
+        this._bindings.set(bindingMatch[1], void 0);
+      }
+      return;
+    }
+    const newPageMatch = text.match(/^(\w+)\s*=\s*(\w+)\.context\.new_page\(\)$/);
+    if (newPageMatch) {
+      this._pageAliases.set(newPageMatch[1], newPageMatch[1]);
+      this._push(newPageMatch[1], [], { name: "openPage", url: "about:blank" });
+      return;
+    }
+    const waitForPageMatch = text.match(/^(\w+)\s*=\s*(\w+)\.wait_for_page\(/);
+    if (waitForPageMatch) {
+      this._pageAliases.set(waitForPageMatch[1], waitForPageMatch[1]);
+      this._push(waitForPageMatch[1], [], { name: "openPage", url: "about:blank" });
+      return;
+    }
+    const valueMatch = text.match(/^(\w+)\s*=\s*(\w+)\.value$/);
+    if (valueMatch && this._promiseVars.has(valueMatch[2])) {
+      this._promiseVars.add(valueMatch[1]);
+      return;
+    }
+    const setFilesMatch = text.match(/^(\w+)\.set_files\(([\s\S]*)\)$/);
+    if (setFilesMatch && this._promiseVars.has(setFilesMatch[1])) {
+      this._emitSetFiles(stmt, setFilesMatch[2]);
+      return;
+    }
+    if (/^skyramp\.check_request_payload\(/.test(text)) {
+      this._emitApiRequestMarker(stmt);
+      return;
+    }
+    const gotoMatch = text.match(/^(\w+)\.goto\(\s*(["'])((?:[^\\]|\\.)*?)\2/);
+    if (gotoMatch && this._pageAliases.has(gotoMatch[1])) {
+      this._push(this._pageAliases.get(gotoMatch[1]), [], { name: "navigate", url: unescapeString(gotoMatch[3]) });
+      return;
+    }
+    const waitTimeoutMatch = text.match(/^(\w+)\.wait_for_timeout\(\s*(\d+)\s*\)$/);
+    if (waitTimeoutMatch && this._pageAliases.has(waitTimeoutMatch[1])) {
+      this._push(this._pageAliases.get(waitTimeoutMatch[1]), [], { name: "waitForTimeout", duration: Number(waitTimeoutMatch[2]) });
+      return;
+    }
+    const evaluateMatch = text.match(/^(\w+)\.evaluate\(([\s\S]*)\)$/);
+    if (evaluateMatch && this._pageAliases.has(evaluateMatch[1])) {
+      const expression = this._resolveStringArg(evaluateMatch[2]) ?? evaluateMatch[2].trim();
+      this._push(this._pageAliases.get(evaluateMatch[1]), [], { name: "evaluate", expression });
+      return;
+    }
+    const closeMatch = text.match(/^(\w+)\.close\(\)$/);
+    if (closeMatch && this._pageAliases.has(closeMatch[1])) {
+      this._push(this._pageAliases.get(closeMatch[1]), [], { name: "closePage" });
+      return;
+    }
+    const mouseMatch = text.match(/^(\w+)\.mouse\.(move|down|up|wheel|click)\(([\s\S]*)\)$/);
+    if (mouseMatch && this._pageAliases.has(mouseMatch[1])) {
+      this._emitMouse(stmt, this._pageAliases.get(mouseMatch[1]), mouseMatch[2], mouseMatch[3]);
+      return;
+    }
+    const expectMatch = text.match(/^expect\(\s*([\s\S]+?)\s*\)\.(not_)?(\w+)\(([\s\S]*)\)$/);
+    if (expectMatch) {
+      if (expectMatch[2]) {
+        this._diag(stmt, `negated expect matcher .not_${expectMatch[3]} has no trace equivalent \u2014 not replayed`);
+        return;
+      }
+      const matcher = PY_EXPECT_MATCHERS[expectMatch[3]];
+      if (!matcher) {
+        this._diag(stmt, `expect matcher .${expectMatch[3]}() has no trace equivalent \u2014 not replayed`);
+        return;
+      }
+      this._emitExpect(stmt, expectMatch[1], matcher, expectMatch[4]);
+      return;
+    }
+    if (/\bwait_for_frame\(/.test(text)) {
+      this._diag(stmt, "wait_for_frame (extension frame) replay is not supported yet \u2014 not replayed");
+      return;
+    }
+    const actionMatch = text.match(new RegExp(`^(\\w+)\\.([\\s\\S]+)\\.(${PY_LOCATOR_METHODS})\\(([\\s\\S]*)\\)$`));
+    if (actionMatch && this._pageAliases.has(actionMatch[1])) {
+      this._emitLocatorAction(stmt, this._pageAliases.get(actionMatch[1]), actionMatch[2], PY_METHOD_MAP[actionMatch[3]] ?? actionMatch[3], actionMatch[4]);
+      return;
+    }
+    this._diag(stmt, "unrecognized statement \u2014 not replayed");
+  }
+}
+function unescapeString(text) {
+  return text.replace(/\\(.)/g, (_, c) => c === "n" ? "\n" : c === "t" ? "	" : c === "r" ? "\r" : c);
+}
+function pyLiteralToJson(text) {
+  let out = "";
+  let quote;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quote) {
+      out += c;
+      if (c === "\\")
+        out += text[++i] ?? "";
+      else if (c === quote)
+        quote = void 0;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      quote = c;
+      out += c;
+      continue;
+    }
+    if (/\w/.test(c)) {
+      let word = c;
+      while (i + 1 < text.length && /\w/.test(text[i + 1]))
+        word += text[++i];
+      out += word === "True" ? "true" : word === "False" ? "false" : word === "None" ? "null" : word;
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function parseLooseObject(text) {
+  const out = {};
+  for (const m of text.matchAll(/["']?(\w+)["']?\s*[:=]\s*(-?\d+(?:\.\d+)?|true|false|True|False)/g))
+    out[m[1]] = /^true$/i.test(m[2]) ? true : /^false$/i.test(m[2]) ? false : Number(m[2]);
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  specLanguageForPath,
+  specToActions
+});