@skyramp/mcp 0.4.3 → 0.4.4-rc.1

package/build/types/TestTypes.js

@@ -291,6 +291,28 @@ export const codeRefactoringSchema = z.object({
         .default(false)
         .describe("Whether to modularize the code"),
 });
+/** The `testName` field for a recording-driven generation tool.
+ *
+ *  Single-sourced because the description is prompt text: it is the only thing
+ *  steering the agent's choice of title, it gets re-tuned against eval results,
+ *  and two copies would let the UI and E2E tools drift apart silently. Each
+ *  tool passes the title its own generator falls back to (SKYR-4468). */
+export const testNameField = (fallbackTitle) => z
+    .string()
+    // .trim() normalises incidental whitespace and, combined with .min(1),
+    // rejects a whitespace-only title, which would otherwise produce a
+    // meaningless test title and identifier (SKYR-4468).
+    .trim()
+    .min(1)
+    .optional()
+    .describe("Title for the generated test. Name the BEHAVIOUR this recording verifies, " +
+    "taken from the recommendation the recording came from — not the page it happens on. " +
+    "Keep it to one short phrase, under about 60 characters. " +
+    'Example: "Add to cart from search results", not "Search page". ' +
+    "Skyramp emits it verbatim as the Playwright test title for TypeScript/JavaScript. " +
+    "Python and Java get it as a comment above the test, and a function name built from " +
+    "its ASCII words and cut at 80 characters. " +
+    `Omit it and the test stays titled \`${fallbackTitle}\`, which claims nothing.`);
 /** Test types skyramp_enhance_assertions supports — single-sourced so the
  *  tool's schema enum and generation-time baseline seeding cannot drift
  *  (contract additionally requires provider mode at the seeding site). */

package/build/types/TestbotReport.d.ts

@@ -227,7 +227,10 @@ export interface TestbotReport {
         /** Files an UPDATE or REGENERATE verdict edited, minus any already counted as
          *  generated — one file owes one run however it was written. */
         updated: number;
-        /** How many of those `generated + updated` files were passed to
+        /** Files a VERIFY verdict names in the primary repository, minus any already
+         *  counted above. Never edited, but each owes one run. */
+        verified: number;
+        /** How many of those `generated + updated + verified` files were passed to
          *  skyramp_execute_test. The file reached the runner; that is not proof a test
          *  ran, because a runner can exit 0 having executed nothing. */
         executed: number;

package/build/utils/assertion-verify/metrics.js

@@ -197,6 +197,18 @@ function expectSites(raw, stripped) {
             matcher = link[1];
             break;
         }
+        // `expect(async () => { ... }).toPass()` is a retry wrapper, not an
+        // assertion: the assertions are the expect() calls inside it. Record none
+        // for the wrapper and resume scanning inside its argument, so the inner
+        // ones are scored for what they check (the generated order assertion
+        // compares boundingBox() geometry inside toPass()).
+        // `.not.toPass()` inverts the block (it must keep failing), so its inner
+        // assertions are not positive checks: it falls through to ordinary wrapper
+        // scoring (weight 1). Python's Playwright has no to_pass equivalent.
+        if (matcher === "toPass" && !links.includes("not")) {
+            re.lastIndex = openIdx + 1;
+            continue;
+        }
         let matcherArgs;
         if (matcher !== undefined) {
             const matcherOpen = /^\s*\(/.exec(stripped.slice(cursor));

package/build/utils/findUp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The first `<dir>/<candidate>` that exists, checking `from` and then each
+ * ancestor, or undefined.
+ *
+ * With `stopAtRepoRoot`, only the directories up to the nearest one holding
+ * `.git` (a directory or a file, so worktrees count) are searched, and a `from`
+ * outside any checkout searches nothing: a parent directory is not the
+ * repository's to answer for. The walk never passes the filesystem root or
+ * MAX_LEVELS.
+ */
+export declare function findUp(from: string, candidates: readonly string[], { stopAtRepoRoot }?: {
+    stopAtRepoRoot?: boolean;
+}): string | undefined;
+/** The package's manifest as Node would find it from `from`: the nearest
+ *  `node_modules/<pkg>/package.json` walking UP from there. Node's own lookup
+ *  never reads NODE_PATH for this, and neither does this one. A manifest that
+ *  does not parse is logged and treated as absent. */
+export declare function installedManifest(pkg: string, from: string, options?: {
+    stopAtRepoRoot?: boolean;
+}): Record<string, unknown> | undefined;

package/build/utils/findUp.js

@@ -0,0 +1,59 @@
+import * as fs from "fs";
+import * as path from "path";
+import { logger } from "./logger.js";
+/** Deeper than any real checkout; a bound so a walk can never run away. */
+const MAX_LEVELS = 64;
+/**
+ * The first `<dir>/<candidate>` that exists, checking `from` and then each
+ * ancestor, or undefined.
+ *
+ * With `stopAtRepoRoot`, only the directories up to the nearest one holding
+ * `.git` (a directory or a file, so worktrees count) are searched, and a `from`
+ * outside any checkout searches nothing: a parent directory is not the
+ * repository's to answer for. The walk never passes the filesystem root or
+ * MAX_LEVELS.
+ */
+export function findUp(from, candidates, { stopAtRepoRoot = false } = {}) {
+    const dirs = ancestors(from);
+    if (stopAtRepoRoot) {
+        const root = dirs.findIndex((dir) => fs.existsSync(path.join(dir, ".git")));
+        if (root === -1)
+            return undefined;
+        dirs.length = root + 1;
+    }
+    for (const dir of dirs) {
+        for (const candidate of candidates) {
+            const found = path.join(dir, candidate);
+            if (fs.existsSync(found))
+                return found;
+        }
+    }
+    return undefined;
+}
+/** `from` and each ancestor, nearest first, up to the filesystem root. */
+function ancestors(from) {
+    const dirs = [path.resolve(from)];
+    while (dirs.length < MAX_LEVELS) {
+        const parent = path.dirname(dirs[dirs.length - 1]);
+        if (parent === dirs[dirs.length - 1])
+            break;
+        dirs.push(parent);
+    }
+    return dirs;
+}
+/** The package's manifest as Node would find it from `from`: the nearest
+ *  `node_modules/<pkg>/package.json` walking UP from there. Node's own lookup
+ *  never reads NODE_PATH for this, and neither does this one. A manifest that
+ *  does not parse is logged and treated as absent. */
+export function installedManifest(pkg, from, options) {
+    const manifest = findUp(from, [path.join("node_modules", pkg, "package.json")], options);
+    if (!manifest)
+        return undefined;
+    try {
+        return JSON.parse(fs.readFileSync(manifest, "utf8"));
+    }
+    catch (error) {
+        logger.warning(`Could not read ${manifest}`, { error: String(error) });
+        return undefined;
+    }
+}

package/build/utils/language-helper.js

@@ -36,7 +36,7 @@ npx playwright test <test-file>.spec.${extension} --reporter=list
  *  a mock is deployed rather than run as a test — it needs no SDK. */
 const SDK_DECLARATION = {
     python: "Declare `skyramp` in the same development manifest.",
-    javascript: `If @skyramp/skyramp is not already declared, add ${npmSdkSpec} as a devDependency. If it is declared, leave its version alone and report the mismatch if the verifier refuses it.`,
+    javascript: `If @skyramp/skyramp is not already declared, add ${npmSdkSpec} as a devDependency. If it is declared, keep its version unless skyramp_execute_test refuses the run for an older SDK.`,
     java: "Declare `dev.skyramp:skyramp-library` with test scope. An existing manifest resolves the version through its own dependency management; a manifest you created has none, so give a concrete version there.",
 };
 /** The SDK line for a language, or nothing when the language has none. */

package/build/utils/repoSdkVersion.d.ts

@@ -0,0 +1,16 @@
+import { SdkEcosystem } from "./testDependencyPolicy.js";
+/**
+ * The Skyramp SDK version the repository that owns `testFile` runs, as far as it
+ * can be read without its toolchain: the installed npm package, else the exact
+ * pin in the nearest manifest. Undefined when neither says. Both lookups stop at
+ * the repository root.
+ */
+export declare function repoSkyrampSdkVersion(testFile: string, ecosystem: SdkEcosystem): string | undefined;
+/**
+ * SKYR-4548: the refusal for a host run whose repository uses an older Skyramp
+ * SDK than the one that generated the test, or undefined when the run may go
+ * ahead. Such a run fails at import, which reads as a broken test. No readable
+ * version means no refusal: a missing SDK is an import error that
+ * fix-test-import-errors owns.
+ */
+export declare function staleSdkRefusal(testFile: string, language: string, serverVersion?: string): string | undefined;

package/build/utils/repoSdkVersion.js

@@ -0,0 +1,88 @@
+import * as fs from "fs";
+import * as path from "path";
+import semver from "semver";
+import { ProgrammingLanguage } from "../types/TestTypes.js";
+import { findUp, installedManifest } from "./findUp.js";
+import { logger } from "./logger.js";
+import { SKYRAMP_SDK_VERSION } from "./skyrampSdkVersion.js";
+import { manifestNames, pinnedSkyrampSdkVersion, SKYRAMP_SDK_PACKAGE, } from "./testDependencyPolicy.js";
+const ECOSYSTEM = {
+    [ProgrammingLanguage.TYPESCRIPT]: "javascript",
+    [ProgrammingLanguage.JAVASCRIPT]: "javascript",
+    [ProgrammingLanguage.PYTHON]: "python",
+    [ProgrammingLanguage.JAVA]: "java",
+};
+/** The one edit that moves the repository onto the SDK that generated the
+ *  test, and that skyramp_verify_test_dependencies accepts. */
+const PIN_EDIT = {
+    javascript: (v) => `Declare ${SKYRAMP_SDK_PACKAGE.javascript} under devDependencies only (move it out of dependencies if it is there), at exactly "${SKYRAMP_SDK_PACKAGE.javascript}": "${v}" with no range operator`,
+    python: (v) => `Change only the requirement to ${SKYRAMP_SDK_PACKAGE.python}==${v}`,
+    java: (v) => `Change only the ${SKYRAMP_SDK_PACKAGE.java} version to ${v}`,
+};
+/**
+ * The Skyramp SDK version the repository that owns `testFile` runs, as far as it
+ * can be read without its toolchain: the installed npm package, else the exact
+ * pin in the nearest manifest. Undefined when neither says. Both lookups stop at
+ * the repository root.
+ */
+export function repoSkyrampSdkVersion(testFile, ecosystem) {
+    const from = path.dirname(path.resolve(testFile));
+    if (ecosystem === "javascript") {
+        const version = installedManifest(SKYRAMP_SDK_PACKAGE.javascript, from, {
+            stopAtRepoRoot: true,
+        })?.version;
+        if (typeof version === "string")
+            return version;
+    }
+    const names = manifestNames(ecosystem);
+    const nearest = findUp(from, names, { stopAtRepoRoot: true });
+    if (!nearest)
+        return undefined;
+    for (const name of names) {
+        const manifest = path.join(path.dirname(nearest), name);
+        if (!fs.existsSync(manifest))
+            continue;
+        try {
+            const pinned = pinnedSkyrampSdkVersion(name, fs.readFileSync(manifest, "utf8"));
+            if (pinned)
+                return pinned;
+        }
+        catch (error) {
+            logger.warning(`Could not read the Skyramp SDK version in ${manifest}`, {
+                error: String(error),
+            });
+        }
+    }
+    return undefined;
+}
+/**
+ * SKYR-4548: the refusal for a host run whose repository uses an older Skyramp
+ * SDK than the one that generated the test, or undefined when the run may go
+ * ahead. Such a run fails at import, which reads as a broken test. No readable
+ * version means no refusal: a missing SDK is an import error that
+ * fix-test-import-errors owns.
+ */
+export function staleSdkRefusal(testFile, language, serverVersion = SKYRAMP_SDK_VERSION) {
+    const ecosystem = ECOSYSTEM[language];
+    if (!ecosystem)
+        return undefined;
+    const repoVersion = repoSkyrampSdkVersion(testFile, ecosystem);
+    if (!isOlderRelease(repoVersion, serverVersion))
+        return undefined;
+    return (`Not executed: this repository uses Skyramp SDK ${repoVersion}, but the test was generated by ${serverVersion}. ` +
+        `${PIN_EDIT[ecosystem](serverVersion)}, update the lockfile if the repository commits one, reinstall, ` +
+        `run skyramp_verify_test_dependencies, and call this tool again. Report the SDK change as an issuesFound entry with category config.`);
+}
+/** True when `repo` is an older release than `server`. Pre-release tags are
+ *  ignored (1.3.47-rc.1 is 1.3.47), and a version semver cannot read is never
+ *  older: the gate must not refuse a run on a guess. */
+function isOlderRelease(repo, server) {
+    const a = repo ? semver.parse(repo) : null;
+    const b = semver.parse(server);
+    if (!a || !b) {
+        if (repo)
+            logger.warning(`Cannot compare Skyramp SDK ${repo} to ${server}`);
+        return false;
+    }
+    return a.compareMain(b) < 0;
+}

package/build/utils/testDependencyPolicy.d.ts

@@ -7,3 +7,23 @@ export interface TestDependencyVerification {
     violations: string[];
 }
 export declare function verifyTestDependencyChanges(repositoryPath: string): Promise<TestDependencyVerification>;
+/** The Skyramp SDK's name in each ecosystem. All three are released in lockstep
+ *  with the npm SDK this server imports, so SKYRAMP_SDK_VERSION is the version
+ *  that generated a test in any of them. */
+export declare const SKYRAMP_SDK_PACKAGE: {
+    readonly javascript: "@skyramp/skyramp";
+    readonly python: "skyramp";
+    readonly java: "dev.skyramp:skyramp-library";
+};
+export type SdkEcosystem = keyof typeof SKYRAMP_SDK_PACKAGE;
+/** The manifest file names an ecosystem declares its dependencies in. */
+export declare function manifestNames(ecosystem: SdkEcosystem): readonly string[];
+/**
+ * The exact Skyramp SDK version a manifest pins where the change verifier lets
+ * the agent raise it, or undefined: the SDK is absent, declared as a range,
+ * resolved elsewhere (a Maven property or BOM, a Gradle catalog), or pinned in
+ * a place the verifier refuses to change (`dependencies`, requirements.txt, a
+ * Maven block without test scope, a Gradle `implementation` line). A refusal
+ * over such a pin would have no fix the agent may make.
+ */
+export declare function pinnedSkyrampSdkVersion(fileName: string, raw: string): string | undefined;

package/build/utils/testDependencyPolicy.js

@@ -4,6 +4,7 @@ import * as path from "path";
 import { parse as parseToml } from "smol-toml";
 import { promisify } from "util";
 import fg from "fast-glob";
+import semver from "semver";
 import { canonicalJson as canonical, isPlainObject as isObject, } from "./canonicalJson.js";
 import { listChangedFiles } from "./reportVerification.js";
 import { contentAtHead } from "./utils-verify/head.js";
@@ -278,18 +279,77 @@ function verifyPackageJson(file, beforeRaw, afterRaw, violations) {
         canonical(beforeDev) !== canonical(afterDev));
 }
 /** The SDK the tests were generated by is the one this server imports, so the
- *  repository must declare exactly that version. Only the npm spelling carries
- *  a version: the Python and Java manifests declare the SDK without one, so
- *  neither is checked here.
+ *  repository must declare exactly that version. Only a changed npm entry is
+ *  checked here: the guidance declares the Python and Java SDK without a
+ *  version. A pin a repository already has is read by pinnedSkyrampSdkVersion.
  *
  *  The specifier must be the bare version. A range is refused, including
  *  `^1.2.3`: it permits 1.3.0, so a clean install elsewhere can resolve an SDK
  *  that did not write these tests, which is the whole thing this prevents. */
 function declaresServerSdkVersion(name, specifier) {
-    if (name !== "@skyramp/skyramp")
+    if (name !== SKYRAMP_SDK_PACKAGE.javascript)
         return true;
     return specifier.trim() === SKYRAMP_SDK_VERSION;
 }
+/** The Skyramp SDK's name in each ecosystem. All three are released in lockstep
+ *  with the npm SDK this server imports, so SKYRAMP_SDK_VERSION is the version
+ *  that generated a test in any of them. */
+export const SKYRAMP_SDK_PACKAGE = {
+    javascript: "@skyramp/skyramp",
+    python: "skyramp",
+    java: "dev.skyramp:skyramp-library",
+};
+/** The manifest file names an ecosystem declares its dependencies in. */
+export function manifestNames(ecosystem) {
+    return DEPENDENCY_FILES[ecosystem].manifests;
+}
+/**
+ * The exact Skyramp SDK version a manifest pins where the change verifier lets
+ * the agent raise it, or undefined: the SDK is absent, declared as a range,
+ * resolved elsewhere (a Maven property or BOM, a Gradle catalog), or pinned in
+ * a place the verifier refuses to change (`dependencies`, requirements.txt, a
+ * Maven block without test scope, a Gradle `implementation` line). A refusal
+ * over such a pin would have no fix the agent may make.
+ */
+export function pinnedSkyrampSdkVersion(fileName, raw) {
+    switch (fileName) {
+        case "package.json":
+            return exactVersion(stringMap(JSON.parse(raw).devDependencies)[SKYRAMP_SDK_PACKAGE.javascript]);
+        case "requirements-dev.txt":
+            return pep440Pin(requirementsMap(raw).dependencies[SKYRAMP_SDK_PACKAGE.python]);
+        case "pyproject.toml": {
+            // Poetry reads a bare version as an exact pin; PEP 735 carries `==`.
+            const spec = pythonDevView(raw).dependencies[SKYRAMP_SDK_PACKAGE.python];
+            return pep440Pin(spec) ?? exactVersion(spec);
+        }
+        case "pom.xml": {
+            const blocks = mavenView(raw.replace(/<!--[\s\S]*?-->/g, ""))
+                .dependencies[SKYRAMP_SDK_PACKAGE.java];
+            return blocks?.length === 1 && !mavenDependency(blocks[0]).error
+                ? exactVersion(singleXmlTag(blocks[0], "version"))
+                : undefined;
+        }
+        case "build.gradle":
+        case "build.gradle.kts": {
+            const lines = gradleView(raw).dependencies[SKYRAMP_SDK_PACKAGE.java];
+            if (lines?.length !== 1)
+                return undefined;
+            const [configuration, value] = lines[0].split("\0");
+            return configuration === "testImplementation" ||
+                configuration === "testRuntimeOnly"
+                ? exactVersion(value.split(":")[2])
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function exactVersion(spec) {
+    return (spec && semver.valid(spec.trim())) || undefined;
+}
+function pep440Pin(requirement) {
+    return exactVersion(/==\s*([^,;\s]+)/.exec(requirement ?? "")?.[1]);
+}
 function verifyPyproject(file, beforeRaw, afterRaw, violations) {
     const before = pythonDevView(beforeRaw);
     const after = pythonDevView(afterRaw);

package/build/utils/utils-verify/typecheck.js

@@ -1,5 +1,5 @@
 import * as path from "path";
-import { readFileSync } from "fs";
+import { installedManifest } from "../findUp.js";
 import { fileURLToPath } from "url";
 let tsModule;
 /** The compiler, loaded on first use and once per process. Loaded statically it
@@ -64,6 +64,8 @@ function executorPeerPackages(mcpRoot) {
         return peers;
     peers = [];
     for (const pkg of EXECUTOR_PROVIDED_PACKAGES) {
+        // Nearest `node_modules/<pkg>` walking UP: `npm install @skyramp/mcp`,
+        // testbot's default, hoists the MCP's dependencies BESIDE it, not under it.
         const manifest = installedManifest(pkg, mcpRoot);
         if (manifest)
             peers.push(...Object.keys(manifest.peerDependencies ?? {}));
@@ -74,23 +76,6 @@ function executorPeerPackages(mcpRoot) {
     peersByRoot.set(mcpRoot, peers);
     return peers;
 }
-/** The package's manifest as Node would find it from `from`: the nearest
- *  `node_modules/<pkg>` walking UP from there. The MCP's dependencies are not
- *  always nested under its own root — `npm install @skyramp/mcp`, testbot's
- *  default, hoists them BESIDE `@skyramp/mcp` — and a read at one fixed path
- *  found nothing on that layout, left the peer list empty, and brought the two
- *  Playwright identities back exactly where customers run. */
-function installedManifest(pkg, from) {
-    for (let dir = from;; dir = path.dirname(dir)) {
-        try {
-            return JSON.parse(readFileSync(path.join(dir, "node_modules", pkg, "package.json"), "utf8"));
-        }
-        catch {
-            if (path.dirname(dir) === dir)
-                return undefined;
-        }
-    }
-}
 const isPackageOrSubpath = (specifier, packages) => packages.some((p) => specifier === p || specifier.startsWith(`${p}/`));
 function executorProvides(specifier) {
     return isPackageOrSubpath(specifier, EXECUTOR_PROVIDED_PACKAGES);

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

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assertOrder_exports = {};
+__export(assertOrder_exports, {
+  checkOrderArgs: () => checkOrderArgs,
+  containmentError: () => containmentError,
+  contains: () => contains,
+  describeOrderResult: () => describeOrderResult
+});
+module.exports = __toCommonJS(assertOrder_exports);
+var import_utils = require("playwright-core/lib/utils");
+function checkOrderArgs(params) {
+  if (!(0, import_utils.isOrderRelation)(params.expected))
+    return { error: `For "order" assertions, "expected" must be one of ${import_utils.ORDER_RELATIONS.map((r) => `"${r}"`).join(", ")}.` };
+  if (!params.otherRef?.trim())
+    return { error: 'For "order" assertions, "otherRef" (the element this one is compared with) is required.' };
+  if (params.otherRef === params.ref)
+    return { error: '"ref" and "otherRef" are the same element; an order assertion compares two different elements.' };
+  return { relation: params.expected, otherElement: params.otherElement?.trim() || `ref ${params.otherRef}` };
+}
+function contains(outer, inner) {
+  return outer.x <= inner.x && outer.y <= inner.y && outer.x + outer.width >= inner.x + inner.width && outer.y + outer.height >= inner.y + inner.height;
+}
+function containmentError(a, b, boxA, boxB) {
+  if (!contains(boxA, boxB) && !contains(boxB, boxA))
+    return void 0;
+  const [outer, inner] = contains(boxA, boxB) ? [a, b] : [b, a];
+  return `"${outer.element}" contains "${inner.element}", so they have no order. Assert the order of two sibling blocks (e.g. the two columns), not of a block and something inside it.`;
+}
+function describeOrderResult(relation, a, b, boxA, boxB) {
+  const result = (0, import_utils.orderHolds)(relation, boxA, boxB);
+  const { axis, edgeA, edgeB } = result;
+  const round = (v) => Math.round(v * 10) / 10;
+  const words = (r) => r.replace("-", " ");
+  if (result.ok)
+    return { result, details: `Order assertion passed: "${a.element}" (${axis}=${round(edgeA)}) is ${words(relation)} "${b.element}" (${axis}=${round(edgeB)}).` };
+  const actual = edgeA === edgeB ? `at the same ${axis} as` : axis === "x" ? edgeA < edgeB ? "left of" : "right of" : edgeA < edgeB ? "above" : "below";
+  const lowFirst = relation === "left-of" || relation === "above";
+  return {
+    result,
+    details: `Order assertion FAILED: "${a.element}" (${axis}=${round(edgeA)}) is ${actual} "${b.element}" (${axis}=${round(edgeB)}), expected ${words(relation)}. Nothing was recorded. If a requirement demands ${relation}, add the comparison to the generated test with these locators (JavaScript syntax; write them in the test's language): ${(0, import_utils.asLocator)("javascript", a.selector)} and ${(0, import_utils.asLocator)("javascript", b.selector)} (compare boundingBox().${axis}; the first must be ${lowFirst ? "smaller" : "greater"}).`
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkOrderArgs,
+  containmentError,
+  contains,
+  describeOrderResult
+});

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

@@ -18,11 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var assertTool_exports = {};
 __export(assertTool_exports, {
+  ORDER_RELATIONS: () => import_utils.ORDER_RELATIONS,
   assertMcpTool: () => assertMcpTool,
   assertToolSchema: () => assertToolSchema
 });
 module.exports = __toCommonJS(assertTool_exports);
 var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_utils = require("playwright-core/lib/utils");
 var import_tool = require("../sdk/tool");
 const assertToolSchema = {
   name: "browser_assert",
@@ -38,17 +40,23 @@ const assertToolSchema = {
     "across the page, e.g. ref one option of an open dropdown to assert the number of options.",
     '"css" checks a computed style property (property "background-color", expected "rgb(37, 99, 235)"; a 3- or 6-digit #hex colour is accepted and recorded as the computed rgb),',
     '"class" checks the element carries a class ("expected" = one class name),',
-    '"attribute" checks an attribute value ("property" = the attribute name, "expected" = its value).',
+    '"attribute" checks an attribute value ("property" = the attribute name, "expected" = its value),',
+    '"order" checks where the element sits relative to another one; "otherRef" and "expected" are REQUIRED for it ("otherRef" = the other element, "expected" = "left-of", "right-of", "above" or "below").',
+    'It compares where the two elements START: the left edges (x) for left-of/right-of, the top edges (y) for above/below, strictly \u2014 "left-of" means "starts further left", not "wholly to the left", and equal edges fail (side-by-side columns are not "above" each other; full-width stacked blocks are not "left-of" each other).',
+    "Pick the axis the PR actually changes. Both elements must be visible, and one containing the other is refused: assert two sibling blocks.",
+    'Use "order" when the PR swaps, moves or reorders blocks (a left/right column swap, a moved sidebar): it fails when the swap is undone.',
     "Use css/class/attribute for a colour, style or class change the PR makes: a screenshot baseline created on this run cannot fail on it.",
     'css/class/attribute are read with the pointer moved OFF the element, so a value that exists only on hover is never recorded; unlike "count", they cannot be asserted on an option of a menu that closes when the pointer leaves it.',
     "To assert an element is absent or not visible, use `browser_assert_hidden`."
   ].join(" "),
   inputSchema: import_mcpBundle.z.object({
-    type: import_mcpBundle.z.enum(["text", "value", "checked", "disabled", "visible", "count", "css", "class", "attribute"]).describe(`Type of assertion: "text" for text content, "value" for input field value, "checked" for checkbox/radio state, "disabled" for disabled/enabled state ("false" asserts the element is enabled), "visible" for element visibility, "count" for the number of elements with the referenced element's role, "css" for a computed style property, "class" for a class the element carries, "attribute" for an attribute value`),
+    type: import_mcpBundle.z.enum(["text", "value", "checked", "disabled", "visible", "count", "css", "class", "attribute", "order"]).describe(`Type of assertion: "text" for text content, "value" for input field value, "checked" for checkbox/radio state, "disabled" for disabled/enabled state ("false" asserts the element is enabled), "visible" for element visibility, "count" for the number of elements with the referenced element's role, "css" for a computed style property, "class" for a class the element carries, "attribute" for an attribute value, "order" for the element's position relative to another element`),
     ref: import_mcpBundle.z.string().describe('Element reference from the latest snapshot. For "count", reference one exemplar element (e.g. one option in an open dropdown).'),
     element: import_mcpBundle.z.string().describe("Human-readable description of the element being asserted"),
+    otherRef: import_mcpBundle.z.string().optional().describe(`Required for "order": the other element's reference from the latest snapshot. Not used by other types.`),
+    otherElement: import_mcpBundle.z.string().optional().describe('For "order": human-readable description of the other element. Not used by other types.'),
     property: import_mcpBundle.z.string().optional().describe('For "css": the CSS property (e.g. "background-color", "flex-direction"). For "attribute": the attribute name (e.g. "aria-expanded", "data-state"). Not used by other types.'),
-    expected: import_mcpBundle.z.string().optional().describe('Expected text or value ("text"/"value"), "true"/"false" ("checked"/"disabled", default "true"; "disabled" with "false" asserts enabled), the expected element count ("count"), the computed style value ("css"; a 3- or 6-digit #hex colour is converted to rgb), one class name ("class"), the attribute value ("attribute"). Not used for "visible".'),
+    expected: import_mcpBundle.z.string().optional().describe('Expected text or value ("text"/"value"), "true"/"false" ("checked"/"disabled", default "true"; "disabled" with "false" asserts enabled), the expected element count ("count"), the computed style value ("css"; a 3- or 6-digit #hex colour is converted to rgb), one class name ("class"), the attribute value ("attribute"), "left-of" / "right-of" / "above" / "below" ("order"). Not used for "visible".'),
     substring: import_mcpBundle.z.boolean().optional().default(true).describe("For text assertions: match as substring (true) or exact match (false)")
   }),
   type: "readOnly"
@@ -58,6 +66,7 @@ function assertMcpTool() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ORDER_RELATIONS,
   assertMcpTool,
   assertToolSchema
 });

package/node_modules/playwright/lib/mcp/skyramp/common/liveReadError.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var liveReadError_exports = {};
+__export(liveReadError_exports, {
+  liveReadError: () => liveReadError
+});
+module.exports = __toCommonJS(liveReadError_exports);
+function liveReadError(e, o) {
+  const err = (text) => ({ content: [{ type: "text", text: `### Error
+${text}` }], isError: true });
+  const msg = String(e?.message ?? e);
+  if (/strict mode violation/i.test(msg))
+    return err(`Target ${o.selector} matches multiple elements, so ${o.ambiguity}${o.pinFailure ? `, and ${o.pinFailure}` : ""}. Use a more specific target (a data-testid, or role + exact name). ${msg.split("\n")[0]}`);
+  if (e?.name === "TimeoutError") {
+    if (o.timeoutMs === void 0)
+      return void 0;
+    return err(`"${o.element}" (${o.selector}) did not resolve within ${o.timeoutMs} ms. Re-snapshot and retry with a fresh ref.`);
+  }
+  return err(`Could not ${o.failedTo} "${o.element}": ${msg}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  liveReadError
+});

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

@@ -113,6 +113,8 @@ function describeStep(action, index) {
     detail += ` .${a.className}`;
   else if (a.name === "assertAttribute")
     detail += ` [${a.attrName}=${JSON.stringify(a.attrValue)}]`;
+  else if (a.name === "assertOrder")
+    detail += ` ${a.relation} ${a.otherSelector}`;
   else if (a.name === "press" && a.key !== void 0)
     detail += ` ${a.key}`;
   else if (a.name === "visualSnapshot")
@@ -389,6 +391,25 @@ async function performClientAction(page, actionInContext) {
         throw new Error(`assertAttribute failed: expected ${action.attrName}=${JSON.stringify(action.attrValue)}, got ${JSON.stringify(actual)}`);
       return;
     }
+    // SKYR-4544: the comparison the recorder verified and the generated test
+    // runs — each box's origin, the left edge (x) for left-of/right-of and the
+    // top edge (y) for above/below, compared strictly — after waiting for both
+    // elements to be visible, as the generated test does.
+    case "assertOrder": {
+      const fields = (0, import_utils.parseOrderFields)(action);
+      if (!fields)
+        throw new Error(`assertOrder failed: trace line needs "otherSelector" and a relation of ${import_utils.ORDER_RELATIONS.join("/")}, got ${JSON.stringify(action.relation)}`);
+      const other = page.locator(buildFullSelector(actionInContext.frame.framePath, fields.otherSelector));
+      await locator.waitFor({ state: "visible", ...opts });
+      await other.waitFor({ state: "visible", ...opts });
+      const [boxA, boxB] = [await locator.boundingBox(opts), await other.boundingBox(opts)];
+      if (!boxA || !boxB)
+        throw new Error(`assertOrder failed: ${!boxA ? fields.selector : fields.otherSelector} has no box on the page`);
+      const { ok, axis, edgeA, edgeB } = (0, import_utils.orderHolds)(fields.relation, boxA, boxB);
+      if (!ok)
+        throw new Error(`assertOrder failed: expected ${fields.selector} ${fields.relation} ${fields.otherSelector}, got ${axis} ${edgeA} vs ${edgeB}`);
+      return;
+    }
     case "assertChecked": {
       const checked = await locator.isChecked(opts);
       if (checked !== !!action.checked)

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

@@ -70,6 +70,7 @@ const ACTION_NAMES = /* @__PURE__ */ new Set([
   "assertCSS",
   "assertClass",
   "assertAttribute",
+  "assertOrder",
   "dragTo",
   "dragAndDrop",
   "diagramNodeAdd",
@@ -143,7 +144,7 @@ function parseLine(line) {
   if (!entry.name || !isActionName(entry.name))
     return null;
   const { pageGuid, pageAlias, framePath, locator, ...actionFields } = entry;
-  if (entry.name === "assertHidden" && locator && typeof locator === "object")
+  if ((entry.name === "assertHidden" || entry.name === "assertOrder") && locator && typeof locator === "object")
     actionFields.locator = locator;
   const frame = {
     pageGuid: pageGuid ?? "",