@skyramp/mcp 0.4.4 → 0.5.0-rc.10

package/build/utils/assertion-verify/created-add-guard.js

@@ -0,0 +1,173 @@
+/**
+ * Guard for the integration-teardown registration lines codegen emits
+ * (`--emit-integration-teardown`): each created record is registered with
+ * `tracker.track_for_cleanup(...)` (Python) or `tracker.trackForCleanup(...)`
+ * (TS/JS/Java) right after its id capture — only a generated comment line sits
+ * between them — and the client library deletes the registered records when
+ * the scope exits. TS/JS and Python registrations span several lines; Java's
+ * fit on one. An enhancement pass that
+ * edits, moves or removes one of those lines — or inserts an assertion between
+ * the capture and its registration so a failing assertion skips the
+ * registration — silently leaks records.
+ */
+const TRACK_FOR_CLEANUP_PREFIXES = [
+    "tracker.track_for_cleanup(",
+    "tracker.trackForCleanup(",
+];
+const CAPTURE_CALL_RE = /(?:get_response_value|getResponseValue|getValue)\s*\(/;
+// A single `=` that is not part of `==`, `!=`, `<=`, `>=`, `=>` or `===`.
+const ASSIGNMENT_RE = /^(.*?)(?<![=!<>])=(?![=>])(.*)$/;
+const COMMENT_PREFIXES = ["//", "#"];
+const QUOTES = new Set(['"', "'", "`"]);
+function isTrackForCleanupLine(trimmed) {
+    return TRACK_FOR_CLEANUP_PREFIXES.some((p) => trimmed.startsWith(p));
+}
+function isSkippable(trimmed) {
+    return (trimmed.length === 0 || COMMENT_PREFIXES.some((p) => trimmed.startsWith(p)));
+}
+/** The registration call that opens on `lines[start]`: its trimmed lines up to
+ *  the one whose `)` closes the call, joined by a space. A call that never
+ *  closes is just its opening line. */
+function registrationAt(lines, start) {
+    const parts = [];
+    let depth = 0;
+    let quote;
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        parts.push(line.trim());
+        for (let j = 0; j < line.length; j++) {
+            const c = line[j];
+            if (quote !== undefined) {
+                if (c === "\\")
+                    j++;
+                else if (c === quote)
+                    quote = undefined;
+            }
+            else if (QUOTES.has(c))
+                quote = c;
+            else if (c === "(")
+                depth++;
+            else if (c === ")" && --depth === 0)
+                return parts.join(" ");
+        }
+    }
+    return lines[start].trim();
+}
+/** The call with the whitespace outside string literals removed, so a
+ *  re-indented or re-wrapped registration still matches its baseline. */
+function canonical(call) {
+    let out = "";
+    let quote;
+    for (let j = 0; j < call.length; j++) {
+        const c = call[j];
+        if (quote !== undefined) {
+            out += c;
+            if (c === "\\")
+                out += call[++j] ?? "";
+            else if (c === quote)
+                quote = undefined;
+        }
+        else if (QUOTES.has(c)) {
+            quote = c;
+            out += c;
+        }
+        else if (!/\s/.test(c))
+            out += c;
+    }
+    return out;
+}
+/** Each whole `tracker.track_for_cleanup(...)` / `tracker.trackForCleanup(...)`
+ *  call of a file, in order — the baseline the enhanced file is compared
+ *  against. */
+export function collectCreatedAddLines(content) {
+    const lines = content.split("\n");
+    const calls = [];
+    lines.forEach((line, i) => {
+        if (isTrackForCleanupLine(line.trim()))
+            calls.push(registrationAt(lines, i));
+    });
+    return calls;
+}
+function isIdCapture(line) {
+    const m = ASSIGNMENT_RE.exec(line);
+    return m !== null && m[1].trim().length > 0 && CAPTURE_CALL_RE.test(m[2]);
+}
+const REMEDIATION = "Restore the generated `tracker.track_for_cleanup(...)` / `tracker.trackForCleanup(...)` calls exactly as emitted, right after the id capture they belong to (only the generated comment line may sit between them), and put assertions only after the registration.";
+/**
+ * Hard findings when the enhanced file's registration lines differ from the
+ * baseline's (sequence must match exactly: same lines, same count, same order)
+ * or when anything but blank or comment lines sits between an id capture and
+ * its registration. With no baseline only the adjacency check runs.
+ */
+export function lintCreatedAddLines(content, baselineLines) {
+    const findings = [];
+    const lines = content.split("\n");
+    if (baselineLines !== undefined) {
+        const current = collectCreatedAddLines(content);
+        const offending = firstSequenceMismatch(baselineLines, current);
+        if (offending !== undefined)
+            findings.push(offending);
+    }
+    for (let i = 0; i < lines.length; i++) {
+        if (!isTrackForCleanupLine(lines[i].trim()))
+            continue;
+        let prev = i - 1;
+        while (prev >= 0 && isSkippable(lines[prev].trim()))
+            prev--;
+        if (prev >= 0 && isIdCapture(lines[prev].trim()))
+            continue;
+        findings.push({
+            rule: "created-add-separated-from-capture",
+            severity: "hard",
+            line: i + 1,
+            message: `\`${registrationAt(lines, i)}\` no longer directly follows its id capture (the line before it is ${prev >= 0 ? `\`${lines[prev].trim()}\`` : "missing"}). Nothing may sit between an id capture and its registration.`,
+            remediation: REMEDIATION,
+        });
+        break; // The first offender is enough to name; one fix pass restores all.
+    }
+    return findings;
+}
+/** Compares the baseline and current registration sequences (whitespace
+ *  outside strings ignored) and names the first call that is missing, out of
+ *  order, or unexpected. */
+function firstSequenceMismatch(baseline, current) {
+    const baselineKeys = baseline.map(canonical);
+    const currentKeys = current.map(canonical);
+    const currentCounts = new Map();
+    for (const key of currentKeys)
+        currentCounts.set(key, (currentCounts.get(key) ?? 0) + 1);
+    const baselineCounts = new Map();
+    for (const key of baselineKeys)
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    for (const [i, line] of baseline.entries()) {
+        const key = baselineKeys[i];
+        if ((currentCounts.get(key) ?? 0) < (baselineCounts.get(key) ?? 0)) {
+            return {
+                rule: "created-add-removed",
+                severity: "hard",
+                message: `The generated \`${line}\` line was removed or edited.`,
+                remediation: REMEDIATION,
+            };
+        }
+    }
+    for (let i = 0; i < current.length; i++) {
+        const line = current[i];
+        if (!baselineCounts.has(currentKeys[i])) {
+            return {
+                rule: "created-add-added",
+                severity: "hard",
+                message: `\`${line}\` is not one of the generated registration lines.`,
+                remediation: REMEDIATION,
+            };
+        }
+        if (currentKeys[i] !== baselineKeys[i]) {
+            return {
+                rule: "created-add-moved",
+                severity: "hard",
+                message: `\`${line}\` was moved: the generated file had \`${baseline[i]}\` at this position.`,
+                remediation: REMEDIATION,
+            };
+        }
+    }
+    return undefined;
+}

package/build/utils/assertion-verify/index.d.ts

@@ -1,3 +1,4 @@
 export { detectAssertionLanguage, computeAssertionMetrics } from "./metrics.js";
 export { verifyAssertionEnhancement, sha256Of, type AssertionBaseline, type AssertionEnhanceType, type AssertionVerifyResult, } from "./verify.js";
 export { formatAssertionVerifyReport } from "./format.js";
+export { collectCreatedAddLines } from "./created-add-guard.js";

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

@@ -5,3 +5,4 @@
 export { detectAssertionLanguage, computeAssertionMetrics } from "./metrics.js";
 export { verifyAssertionEnhancement, sha256Of, } from "./verify.js";
 export { formatAssertionVerifyReport } from "./format.js";
+export { collectCreatedAddLines } from "./created-add-guard.js";

package/build/utils/assertion-verify/verify.d.ts

@@ -7,6 +7,9 @@ export interface AssertionBaseline {
     count?: number;
     strengthScore?: number;
     fingerprints?: string[];
+    /** Trimmed `tracker.track_for_cleanup(` registration lines at hand-out time, in order
+     *  (integration teardown). The enhanced file must keep them verbatim. */
+    createdAddLines?: string[];
     /** Copy of the generated file at hand-out time (run artifact dir). */
     baselineFilePath?: string;
 }
@@ -54,9 +57,10 @@ export interface AssertionVerifyResult {
 export declare function sha256Of(content: string): string;
 /**
  * Deterministic verification that the enhancement instructions were applied:
- * hash delta, no assertions removed, rubric lints clean, and (generation only)
- * strength strictly increased unless a documented `assertions complete` marker
- * declines it. Reads the file as delivered — throws if it cannot be read.
+ * hash delta, no assertions removed, rubric lints clean, teardown
+ * `tracker.track_for_cleanup(...)` registrations untouched, and (generation only) strength
+ * strictly increased unless a documented `assertions complete` marker declines
+ * it. Reads the file as delivered — throws if it cannot be read.
  */
 export declare function verifyAssertionEnhancement(params: {
     testFile: string;

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

@@ -8,6 +8,7 @@ import { lintIntegrationTest } from "./integration-lints.js";
 import { lintContractTest } from "./contract-lints.js";
 import { findAssertionsCompleteMarker, findUnparsableAssertionsComplete, markerCommentToken, } from "./marker.js";
 import { importedHelperSubjectCapacities } from "./helper-imports.js";
+import { lintCreatedAddLines } from "./created-add-guard.js";
 /** The mean weight the assertions added since the baseline must reach.
  *  Weights are 3 exact / 2 partial-or-format / 1 existence-tier, so 2 means
  *  "on average at least a format check". A lean enhancement of exact values
@@ -37,9 +38,10 @@ function addedSites(current, baselineFingerprints) {
 }
 /**
  * Deterministic verification that the enhancement instructions were applied:
- * hash delta, no assertions removed, rubric lints clean, and (generation only)
- * strength strictly increased unless a documented `assertions complete` marker
- * declines it. Reads the file as delivered — throws if it cannot be read.
+ * hash delta, no assertions removed, rubric lints clean, teardown
+ * `tracker.track_for_cleanup(...)` registrations untouched, and (generation only) strength
+ * strictly increased unless a documented `assertions complete` marker declines
+ * it. Reads the file as delivered — throws if it cannot be read.
  */
 export async function verifyAssertionEnhancement(params) {
     const { testFile, testType, enhanceType, baseline } = params;
@@ -158,6 +160,10 @@ export async function verifyAssertionEnhancement(params) {
                 : [];
     const marker = findAssertionsCompleteMarker(content, testFile, language);
     const hardFindings = findings.filter((f) => f.severity === "hard");
+    // Teardown registrations are structural, not rubric: they run for every
+    // language (Java included) and are never marker-clearable — a missing or
+    // displaced `tracker.track_for_cleanup(...)` leaks a record on the shared target.
+    hardFindings.push(...lintCreatedAddLines(content, baseline?.createdAddLines));
     const commentToken = markerCommentToken(language);
     for (const line of findUnparsableAssertionsComplete(content, language)) {
         hardFindings.push({

package/build/utils/featureFlags.js

@@ -123,12 +123,15 @@ export function isUtilsReuseEnabled() {
 const UTILS_REUSE_DEFAULT_ORGS = ["skyramp-handson"];
 const POM_REUSE_DEFAULT_ORGS = ["skyramp-handson"];
 function isDefaultOrg(orgs) {
+    // SKYRAMP_REPOSITORY is set by the engine on every provider; its first part
+    // is the owner, or the organization of an Azure DevOps "org/project/repo".
     // GITHUB_REPOSITORY_OWNER is set on GitHub Actions runners; fall back to
     // the owner half of GITHUB_REPOSITORY ("owner/repo") for environments that
     // only set the latter.
-    const owner = process.env.GITHUB_REPOSITORY_OWNER ??
-        process.env.GITHUB_REPOSITORY?.split("/")[0] ??
-        "";
+    const owner = process.env.SKYRAMP_REPOSITORY?.split("/")[0] ||
+        (process.env.GITHUB_REPOSITORY_OWNER ??
+            process.env.GITHUB_REPOSITORY?.split("/")[0] ??
+            "");
     return orgs.includes(owner.toLowerCase());
 }
 /**

package/build/utils/repositorySlug.d.ts

@@ -1,12 +1,26 @@
+/** An Azure DevOps `org/project/repo`; the org is letters, digits and hyphens. */
+export declare const AZURE_REPOSITORY_SLUG: RegExp;
+/** A GitHub `owner/repo` or an Azure DevOps `org/project/repo`. */
+export declare function isRepositorySlug(value: string): boolean;
 /**
  * `owner/repo` from a git remote URL. Accepts the two spellings a checkout's
  * `origin` carries — ssh (`git@host:owner/repo.git`) and https
  * (`https://host/owner/repo`) — with or without the `.git` suffix.
  *
+ * An Azure DevOps remote gives `org/project/repo` instead, with its names
+ * decoded (`%20` is a space), or undefined when the decoded names do not make
+ * an `AZURE_REPOSITORY_SLUG`.
+ *
  * Returns undefined when the URL yields no owner/repo pair, which the callers
  * treat differently: see `repositorySlugOf` and `tryRepositorySlug` below.
  */
 export declare function parseOwnerRepo(remoteUrl: string): string | undefined;
+/**
+ * The repository a CI run works on: `SKYRAMP_REPOSITORY`, which the engine sets
+ * on every provider (`org/project/repo` on Azure DevOps), else GitHub Actions'
+ * own `GITHUB_REPOSITORY`. Undefined outside a run.
+ */
+export declare function runRepository(env?: NodeJS.ProcessEnv): string | undefined;
 /**
  * `owner/repo` of the checkout at `dir`, or undefined when it is not a git repo,
  * has no `origin` remote, or the remote URL names no owner/repo pair.

package/build/utils/repositorySlug.js

@@ -3,21 +3,66 @@ import { promisify } from "util";
 import fs from "fs/promises";
 import path from "path";
 const execFileAsync = promisify(execFile);
+// The https and ssh remotes Azure DevOps gives, on dev.azure.com and on the
+// older {org}.visualstudio.com. An https URL without a project names the
+// project's default repository, which has the project's name.
+const AZURE_REMOTES = [
+    /^https?:\/\/(?:[^@/]+@)?dev\.azure\.com(?::\d+)?\/(?<org>[^/]+)\/(?:(?<project>[^/]+)\/)?_git\/(?<repo>[^/]+?)(?:\.git)?\/?$/i,
+    /^https?:\/\/(?:[^@/]+@)?(?<org>[^./]+)\.visualstudio\.com(?::\d+)?\/(?:DefaultCollection\/)?(?:(?<project>[^/]+)\/)?_git\/(?<repo>[^/]+?)(?:\.git)?\/?$/i,
+    /^(?:[^@/]+@)?(?:ssh\.dev\.azure\.com|vs-ssh\.visualstudio\.com):v3\/(?<org>[^/]+)\/(?<project>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?\/?$/i,
+    /^ssh:\/\/(?:[^@/]+@)?(?:ssh\.dev\.azure\.com|vs-ssh\.visualstudio\.com)(?::\d+)?\/v3\/(?<org>[^/]+)\/(?<project>[^/]+)\/(?<repo>[^/]+?)(?:\.git)?\/?$/i,
+];
+// An Azure DevOps project or repo name: any character but `/`, `\` and control
+// characters, whitespace only inside it, and never `.` or `..`.
+const AZURE_NAME = String.raw `(?!\.\.?(?:/|$))[^/\\\s\x00-\x1f\x7f-\x9f](?:[^/\\\x00-\x1f\x7f-\x9f]*[^/\\\s\x00-\x1f\x7f-\x9f])?`;
+/** An Azure DevOps `org/project/repo`; the org is letters, digits and hyphens. */
+export const AZURE_REPOSITORY_SLUG = new RegExp(`^[A-Za-z0-9][A-Za-z0-9-]*/${AZURE_NAME}/${AZURE_NAME}$`);
+const GITHUB_REPOSITORY_SLUG = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
+/** A GitHub `owner/repo` or an Azure DevOps `org/project/repo`. */
+export function isRepositorySlug(value) {
+    return (GITHUB_REPOSITORY_SLUG.test(value) || AZURE_REPOSITORY_SLUG.test(value));
+}
 /**
  * `owner/repo` from a git remote URL. Accepts the two spellings a checkout's
  * `origin` carries — ssh (`git@host:owner/repo.git`) and https
  * (`https://host/owner/repo`) — with or without the `.git` suffix.
  *
+ * An Azure DevOps remote gives `org/project/repo` instead, with its names
+ * decoded (`%20` is a space), or undefined when the decoded names do not make
+ * an `AZURE_REPOSITORY_SLUG`.
+ *
  * Returns undefined when the URL yields no owner/repo pair, which the callers
  * treat differently: see `repositorySlugOf` and `tryRepositorySlug` below.
  */
 export function parseOwnerRepo(remoteUrl) {
-    const match = remoteUrl.trim().match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+    const url = remoteUrl.trim();
+    const withoutQuery = url.replace(/[?#].*$/, "");
+    const azure = AZURE_REMOTES.map((form) => withoutQuery.match(form)).find(Boolean);
+    if (azure) {
+        const { org, project, repo } = azure.groups;
+        let slug;
+        try {
+            slug = [org, project ?? repo, repo].map(decodeURIComponent).join("/");
+        }
+        catch {
+            return undefined;
+        }
+        return AZURE_REPOSITORY_SLUG.test(slug) ? slug : undefined;
+    }
+    const match = url.match(/[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
     if (!match)
         return undefined;
     const [, owner, repo] = match;
     return `${owner}/${repo}`;
 }
+/**
+ * The repository a CI run works on: `SKYRAMP_REPOSITORY`, which the engine sets
+ * on every provider (`org/project/repo` on Azure DevOps), else GitHub Actions'
+ * own `GITHUB_REPOSITORY`. Undefined outside a run.
+ */
+export function runRepository(env = process.env) {
+    return env.SKYRAMP_REPOSITORY || env.GITHUB_REPOSITORY || undefined;
+}
 // One `git remote get-url` per directory for the life of the process. The
 // value is the resolved slug, or undefined when the directory cannot name one.
 const slugCache = new Map();

package/build/utils/telemetry.d.ts

@@ -21,6 +21,8 @@ export declare function getLocalRepositoryInfo(cwd: string): Promise<RepositoryI
  *
  * - In GitHub Actions (testbot), reads GITHUB_REPOSITORY / GITHUB_REPOSITORY_OWNER
  *   which the MCP subprocess inherits — fast, no shelling out.
+ * - In Azure Pipelines, reads the engine's SKYRAMP_REPOSITORY ("org/project/repo")
+ *   and reports the organization as the owner.
  * - In local/IDE usage, derives "owner/repo" from `git remote get-url origin`.
  *   The lookup directory is the caller-supplied `cwd` (a tool's repositoryPath
  *   or workspacePath) when available, since the MCP server's own process.cwd()

package/build/utils/telemetry.js

@@ -25,6 +25,9 @@ export function getCIPlatform() {
         return "jenkins";
     if (process.env.CIRCLECI === "true")
         return "circleci";
+    // Azure Pipelines sets TF_BUILD to "True".
+    if (process.env.TF_BUILD?.toLowerCase() === "true")
+        return "azure-pipelines";
     return undefined;
 }
 /**
@@ -73,6 +76,8 @@ export async function getLocalRepositoryInfo(cwd) {
  *
  * - In GitHub Actions (testbot), reads GITHUB_REPOSITORY / GITHUB_REPOSITORY_OWNER
  *   which the MCP subprocess inherits — fast, no shelling out.
+ * - In Azure Pipelines, reads the engine's SKYRAMP_REPOSITORY ("org/project/repo")
+ *   and reports the organization as the owner.
  * - In local/IDE usage, derives "owner/repo" from `git remote get-url origin`.
  *   The lookup directory is the caller-supplied `cwd` (a tool's repositoryPath
  *   or workspacePath) when available, since the MCP server's own process.cwd()
@@ -93,5 +98,12 @@ export async function getRepositoryInfo(cwd) {
         }
         return info;
     }
+    const engineRepository = process.env.SKYRAMP_REPOSITORY;
+    if (getCIPlatform() === "azure-pipelines" && engineRepository) {
+        return {
+            repository: engineRepository,
+            repositoryOwner: engineRepository.split("/")[0],
+        };
+    }
     return getLocalRepositoryInfo(cwd || process.cwd());
 }

package/build/utils/utils-verify/action-key.d.ts

@@ -37,7 +37,9 @@ export interface ActionStep {
      *  do not balance. A helper with one such step has no key; a spec's other steps
      *  are still read, so an unreadable step is a boundary no matched run crosses. */
     key?: string;
-    /** 1-based line of the action verb. */
+    /** 1-based line where the action's chain starts (`page` in a prettier-wrapped
+     *  `await page\n  .getByTestId(…)\n  .click()`); the verb's line when the chain
+     *  starts inside the previous action. */
     line: number;
     /** The source between the previous action's closing `)` (or the start of the
      *  body) and this action's chain: what stands between two consecutive actions.
@@ -47,6 +49,11 @@ export interface ActionStep {
     /** The source after this action's closing `)` up to the next action's chain, or
      *  to the end of the body for the last step — the next step's `gapBefore`. */
     gapAfter: string;
+    /** 1-based line of the action's closing `)`, where `gapAfter` starts. */
+    endLine: number;
+    /** The action's first argument as written (`""` when it has none): the value a
+     *  `fill` types, which the key leaves out. */
+    value: string;
 }
 /**
  * Every action in `body`, in order, each keyed as `actionKeyOf` keys it. Where
@@ -55,12 +62,62 @@ export interface ActionStep {
  * copy of a helper's sequence needs. Lines survive the Python and alias rewrites:
  * neither adds or removes a newline.
  */
-export declare function actionStepsOf(body: string, language?: UtilsLanguage): ActionStep[];
+export declare function actionStepsOf(body: string, language?: UtilsLanguage, 
+/** A helper's parameter names: a locator argument (or `name:` option) that is
+ *  one of them keys as the wildcard `paramSlot(name)` instead of failing. */
+params?: ReadonlySet<string>): ActionStep[];
 /** `click empty-cart-btn; fill qty` → `click \`empty-cart-btn\`; fill \`qty\`` — the
  *  key as the agent reads it, selectors quoted so a `#id` never reads as prose. */
 export declare function describeActionKey(key: string): string;
 /** Index of the `)` that closes the `(` at `open`, on a string-blanked copy. */
 export declare function matchingClose(structure: string, open: number): number;
+/** The text a parameter-fed locator argument keys as: a string no selector holds.
+ *  A key holding SLOT_MARK holds a wildcard. */
+export declare const SLOT_MARK = "\u0001";
+export declare function paramSlot(name: string): string;
+/** What an action's value is, as `resolveStepValue` reads it: one of the reading
+ *  helper's parameters, a literal, or another expression (kept as written). */
+export interface StepValue {
+    kind: "param" | "literal" | "expr";
+    text: string;
+    /** The zero-argument calls chained on a resolved `getValue(…)`, spaces dropped:
+     *  `.toString()` for a number the fill types. */
+    suffix?: string;
+}
+/**
+ * An action's value (`ActionStep.value`) as the sibling scan compares it: a bare
+ * parameter of the helper, a literal, or the generated `getValue(playwrightRequestN,
+ * "key")` — a dotted key read through nested objects, a chained `.toString()` kept
+ * as `suffix` — read through the binding that holds it (`requestBindingsOf`), to
+ * the parameter or literal stored under that key. Anything else is an expression,
+ * compared as written.
+ */
+export declare function resolveStepValue(raw: string, bindings: ReadonlyMap<string, string>, params?: ReadonlySet<string>): StepValue;
+/** The generator's `const playwrightRequestN: Record<…> = { … }` bindings in `text`,
+ *  by name, to the object literal as written. A name bound twice is left out. */
+export declare function requestBindingsOf(text: string): Map<string, string>;
+/** The normalised arguments of every `page.waitForResponse(…)` in `text`. */
+export declare function responseWaitsOf(text: string): string[];
+/** A use of the identifier `name`: not part of a longer name or a property access. */
+export declare function identifierUseRe(name: string, flags?: string): RegExp;
+/** A declared parameter's name (see paramName), or `undefined` for a rest or
+ *  destructured one: no single value a call or a wildcard can carry. */
+export declare function simpleParamName(raw: string): string | undefined;
+/** A browser helper's sequence as the sibling scan matches it (SKYR-4537). */
+export interface ActionPattern {
+    /** One key per step, as `actionStepKeys` keys it, except that a locator argument
+     *  fed by a parameter is the wildcard `paramSlot(name)`. */
+    steps: string[];
+    /** Each step's value, read through the helper's own request bindings. */
+    values: StepValue[];
+    /** The helper's `waitForResponse` arguments (see responseWaitsOf). */
+    responseWaits: string[];
+    /** The parameters the body reads: one a call leaves out changes what it does. */
+    usedParams: string[];
+}
+/** The helper's ActionPattern, or `undefined` when a step stays unreadable with
+ *  its parameters as wildcards. `params` are the declared parameters as written. */
+export declare function actionPatternOf(body: string, language: UtilsLanguage, params: readonly string[]): ActionPattern | undefined;
 /** Whitespace and braces dropped outside string literals, `'` normalised to `"` —
  *  the spelling a locator chain has inside a key. */
 export declare function normalizeChain(text: string): string;