@skyramp/mcp 0.4.3-rc.1 → 0.4.3

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

@@ -1,4 +1,5 @@
 import * as path from "path";
+import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 let tsModule;
 /** The compiler, loaded on first use and once per process. Loaded statically it
@@ -41,8 +42,61 @@ const UNRESOLVED_MODULE_CODES = new Set([2307, 2792]);
  *  exit was to rewrite working code. Every other package still resolves from the
  *  repository first, because every other package is the repository's to pin. */
 const EXECUTOR_PROVIDED_PACKAGES = ["@skyramp/skyramp"];
+/** The PEERS of the executor-provided packages — what their type declarations
+ *  import and expect the host to install (`@skyramp/skyramp` declares
+ *  `@playwright/test`, whose `Expect` types its `expect`). Read from each
+ *  package's own manifest under `mcpRoot`, once per root: the SDK already states
+ *  the list, and a second copy here would need a test to keep it in step. A peer
+ *  is resolved from the REPOSITORY first for every file that imports it, the
+ *  MCP's own copy second — including from inside the MCP's SDK declarations.
+ *  Otherwise the SDK's copy came from the MCP's install while the spec's own
+ *  import came from the repository's, and a repository pinned to another
+ *  Playwright version had two `Locator` identities: every `expect(locator)` in
+ *  it typed as the base matchers, and four assertion lines that pre-dated the
+ *  run became blocking `type-error`s against a valid module — which the run then
+ *  deleted. The customer's `tsc` has one node_modules and never sees the split;
+ *  the executor runs the repository's Playwright, so the repository's copy is
+ *  the truth. */
+const peersByRoot = new Map();
+function executorPeerPackages(mcpRoot) {
+    let peers = peersByRoot.get(mcpRoot);
+    if (peers)
+        return peers;
+    peers = [];
+    for (const pkg of EXECUTOR_PROVIDED_PACKAGES) {
+        const manifest = installedManifest(pkg, mcpRoot);
+        if (manifest)
+            peers.push(...Object.keys(manifest.peerDependencies ?? {}));
+        // No manifest reachable from this root: the package resolves from nowhere
+        // and its imports are reported as unresolved gaps, so there is no peer to
+        // route.
+    }
+    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 EXECUTOR_PROVIDED_PACKAGES.some((p) => specifier === p || specifier.startsWith(`${p}/`));
+    return isPackageOrSubpath(specifier, EXECUTOR_PROVIDED_PACKAGES);
+}
+function executorPeer(specifier, mcpRoot) {
+    return isPackageOrSubpath(specifier, executorPeerPackages(mcpRoot));
 }
 export const AMBIENT_DECLARATION_CODES = new Set([
     2304, 2311, 2318, 2468, 2503, 2552, 2580, 2581, 2582, 2583, 2584, 2591, 2592,
@@ -211,26 +265,51 @@ function findConfigs(ts, files) {
  * an error, and its diagnostics are dropped (everything typed by it is `any` and
  * was not checked — the gap is stated instead).
  */
-function runPass(ts, files, options, mcpRoot) {
+function runPass(ts, files, options, mcpRoot, repoDir, baseline) {
     const own = new Set(files.map((f) => path.normalize(f)));
     const unresolved = new Set();
     const host = ts.createCompilerHost(options, true);
+    if (baseline) {
+        // A baseline file is read from the content given, never from disk; a hidden
+        // one does not exist to the compiler, so an import of it is unresolved and
+        // typed `any`, as it was before the run wrote it.
+        const contentOf = (f) => baseline.contents.get(path.normalize(f));
+        const hidden = (f) => baseline.hidden.has(path.normalize(f));
+        const { fileExists, readFile, getSourceFile } = host;
+        host.fileExists = (f) => hidden(f) ? false : contentOf(f) !== undefined || fileExists(f);
+        host.readFile = (f) => hidden(f) ? undefined : (contentOf(f) ?? readFile(f));
+        host.getSourceFile = (f, lang, onError, shouldCreate) => {
+            if (hidden(f))
+                return undefined;
+            const content = contentOf(f);
+            return content === undefined
+                ? getSourceFile(f, lang, onError, shouldCreate)
+                : ts.createSourceFile(f, content, lang, true);
+        };
+    }
     // Global types (`@types/*` pulled in automatically) are looked up from the current
     // directory upward. That must be the repository, not wherever the MCP process
     // happens to run: the MCP's own `@types/jest` made a bare `expect` compile here
     // that the customer's `tsc` cannot see.
-    const repoDir = path.dirname(files[0]);
     host.getCurrentDirectory = () => repoDir;
     // A containing file that does not exist is fine for resolution: only its
     // directory is read, and node_modules is looked up from there.
     const anchor = path.join(mcpRoot, "__skyramp_typecheck_anchor__.ts");
+    // The same device for the repository: a peer imported from INSIDE the MCP's
+    // install must still resolve from the repository first, and the containing
+    // file's directory would find the MCP's copy.
+    const repoAnchor = path.join(repoDir, "__skyramp_typecheck_anchor__.ts");
     host.resolveModuleNameLiterals = (literals, containingFile, _r, opts) => literals.map((literal) => {
         const delivered = own.has(path.normalize(containingFile));
-        // The executor's own packages are read from the MCP's install first;
-        // everything else from the repository first, the MCP second.
+        // The executor's own packages are read from the MCP's install first; their
+        // peers from the repository first wherever the import sits, so both sides of
+        // an SDK type meet ONE copy; everything else from the repository first, the
+        // MCP second.
         const [first, second] = executorProvides(literal.text)
             ? [anchor, containingFile]
-            : [containingFile, anchor];
+            : executorPeer(literal.text, mcpRoot)
+                ? [repoAnchor, anchor]
+                : [containingFile, anchor];
         let resolved = ts.resolveModuleName(literal.text, first, opts, host);
         if (!resolved.resolvedModule) {
             const other = ts.resolveModuleName(literal.text, second, opts, host);
@@ -281,15 +360,17 @@ const findingKey = (f) => `${f.file}\0${f.line}\0${f.code}\0${f.message}`;
  * every repository whether or not `typescript` is installed there.
  *
  * Two passes over the same files. The PERMISSIVE pass has every strictness flag off:
- * an error it reports fails under any configuration and is blocking (`errors`). The
- * SETTINGS pass runs the repository's own tsconfig, when one reaches the files; what
- * it adds is an error only under those settings and is advisory (`settingErrors`).
+ * an error it reports fails under any configuration (`errors`) — the verifier
+ * blocks on it unless the repository already had it at HEAD, which the same
+ * function establishes when called with a `baseline`. The SETTINGS pass runs the
+ * repository's own tsconfig, when one reaches the files; what it adds is an error
+ * only under those settings and is advisory (`settingErrors`).
  * The executor transpiles without typechecking, so neither pass has run before this
  * one, and a delivered file that fails here reaches the customer's own `tsc` first.
  *
  * Never throws: a compiler failure is a result that says the check did not run.
  */
-export async function typecheckDelivered(files, mcpRoot = mcpPackageRoot()) {
+export async function typecheckDelivered(files, { mcpRoot = mcpPackageRoot(), anchor, baseline } = {}) {
     const result = {
         ran: false,
         errors: [],
@@ -310,15 +391,16 @@ export async function typecheckDelivered(files, mcpRoot = mcpPackageRoot()) {
         // import is unresolved here, typed `any`, and its unconditional error then
         // surfaces only in the settings pass — downgraded to an advisory.
         const base = (reaching ?? nearest)?.parsed.options ?? {};
-        const floor = runPass(ts, files, permissiveOptions(ts, base), mcpRoot);
+        const repoDir = path.dirname(anchor ?? files[0]);
+        const floor = runPass(ts, files, permissiveOptions(ts, base), mcpRoot, repoDir, baseline);
         result.ran = true;
         result.errors = floor.findings.filter((f) => !AMBIENT_DECLARATION_CODES.has(f.code));
         result.ambientErrors = floor.findings.filter((f) => AMBIENT_DECLARATION_CODES.has(f.code));
         result.unresolved = [...floor.unresolved].sort();
-        if (reaching) {
+        if (reaching && !baseline) {
             result.tsconfig = reaching.path;
             const seen = new Set([...floor.findings, ...floor.unresolvedFindings].map(findingKey));
-            const settings = runPass(ts, files, settingsOptions(reaching.parsed.options), mcpRoot);
+            const settings = runPass(ts, files, settingsOptions(reaching.parsed.options), mcpRoot, repoDir);
             // An import only the repository's resolution refuses is its `tsc`'s error,
             // not a gap: the permissive pass resolved it, so the module exists.
             result.settingErrors = [

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

@@ -24,6 +24,13 @@ export interface UtilsVerifyResult {
     ok: boolean;
     /** Utils files located for this spec (absolute). Empty = nothing was written or imported. */
     utilsFiles: string[];
+    /** Those of `utilsFiles` that HEAD holds — an earlier run's or the customer's. */
+    incumbentModules: string[];
+    /** Those of `utilsFiles` git could not answer for (outside a repository, or a
+     *  git failure). Neither an incumbent nor this run's: a caller that states
+     *  "this run created it" must not say so for these. The rest of `utilsFiles`
+     *  this run created. */
+    headUnknownModules: string[];
     /** Helpers defined across the utils files. */
     helpers: number;
     /** Helper names the delivered spec imports from those files. */
@@ -86,6 +93,13 @@ export interface UtilsVerifyResult {
      *  `tsconfig-type-error` advisories; this carries the rest (the tsconfig read, the
      *  modules it could not resolve). Absent for Python and JavaScript. */
     typecheck?: UtilsTypecheck;
+    /** What the attribution of compiler errors to this run established — with
+     *  `typecheck`, TypeScript only. `ran` is whether the HEAD compile ran, so an
+     *  error the repository already had could be excused; when it did not, `reason`
+     *  says why and every error blocked as this run's. `headUnknown` lists the
+     *  delivered files git gave no HEAD answer for: each is judged as this run's
+     *  in full, and the pass says so rather than hide it. */
+    attribution?: TypeAttribution;
     /** Modules the spec imports that this pass READ and does not CHECK: the
      *  repository's own modules (tracked at HEAD, no Skyramp header) on a path with no
      *  in-house checks — integration, today — and a module outside the repository.
@@ -110,6 +124,11 @@ export interface UtilsVerifyResult {
      *  Absent when the spec imports no such module. */
     inHouse?: InHouseVerification;
 }
+export interface TypeAttribution {
+    ran: boolean;
+    reason?: string;
+    headUnknown: string[];
+}
 export interface InHouseVerification {
     /** Absolute paths of the in-house modules read. */
     modules: string[];
@@ -177,17 +196,17 @@ export interface VerifyUtilsParams {
  *    returned. See status-once.ts.
  *  - `type-error` (TypeScript): the delivered module or spec fails the compiler with
  *    every strictness flag off — an error under every configuration (a path parameter
- *    typed `unknown`, request options built as a record and handed to `sendRequest`).
- *    An error only the repository's own tsconfig raises is the `tsconfig-type-error`
- *    ADVISORY. See typecheckDelivered.
+ *    typed `unknown`, request options built as a record and handed to `sendRequest`)
+ *    — and this run CAUSED it: an error the file already had at HEAD on an
+ *    unchanged line is the `inherited-type-error` ADVISORY, and an error only the
+ *    repository's own tsconfig raises is the `tsconfig-type-error` ADVISORY. See
+ *    typecheckDelivered and inheritedTypeError.
  *
  * Analyses the utils files' INTERNAL invariants — unlike the POM verifier, which
  * checks a spec's cross-file references — so it reads the utils files, not the spec,
  * except to count what the spec imports.
  */
 export declare function verifyUtils(params: VerifyUtilsParams): Promise<UtilsVerifyResult>;
-/** The compared counts as one phrase, shared by the assertion-loss detail and the
- *  PASSED line's note so the two cannot drift. */
 export declare function describeAssertionCount(c: {
     baseline: number;
     delivered: number;

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

@@ -20,7 +20,8 @@ import { describeFixedSleeps, fixedSleepReplacement } from "./fixed-sleep.js";
 import { singleImporterHelpers } from "./importers.js";
 import { assertsStatusEquality, defaultedStatusParam, pinnedStatusLiteral, restatedStatusAssertions, } from "./status-once.js";
 import { STATUS_ONCE_RULE } from "../../prompts/shared-helper-policy.js";
-import { contentAtHead } from "./head.js";
+import { addedSinceHead, changedSinceHead, contentAtHead, readAtHead, } from "./head.js";
+import { alignLines, BaselineErrors, baselineErrorKey, inheritedTypeError, } from "./changed-lines.js";
 import { incumbentSignatureViolations } from "./incumbent.js";
 import { helperFamilyFor, helperFamilyOf, scenarioNameViolation, utilsSpecFor, utilsSpecForFile, } from "./language-spec.js";
 /** What the compiler says about a name defined twice, which `helper-redefined`
@@ -52,9 +53,11 @@ const REDECLARATION_CODES = new Set([2393, 2323, 2451]);
  *    returned. See status-once.ts.
  *  - `type-error` (TypeScript): the delivered module or spec fails the compiler with
  *    every strictness flag off — an error under every configuration (a path parameter
- *    typed `unknown`, request options built as a record and handed to `sendRequest`).
- *    An error only the repository's own tsconfig raises is the `tsconfig-type-error`
- *    ADVISORY. See typecheckDelivered.
+ *    typed `unknown`, request options built as a record and handed to `sendRequest`)
+ *    — and this run CAUSED it: an error the file already had at HEAD on an
+ *    unchanged line is the `inherited-type-error` ADVISORY, and an error only the
+ *    repository's own tsconfig raises is the `tsconfig-type-error` ADVISORY. See
+ *    typecheckDelivered and inheritedTypeError.
  *
  * Analyses the utils files' INTERNAL invariants — unlike the POM verifier, which
  * checks a spec's cross-file references — so it reads the utils files, not the spec,
@@ -102,6 +105,8 @@ export async function verifyUtils(params) {
     const result = {
         ok: true,
         utilsFiles,
+        incumbentModules: [],
+        headUnknownModules: [],
         helpers: 0,
         imported: 0,
         importedNames: [],
@@ -136,6 +141,11 @@ export async function verifyUtils(params) {
      *  kept: both the status advisory's scope and the restatement's remediation
      *  turn on it. */
     const incumbentsOfFile = new Map();
+    /** Per utils file, the module at HEAD — `undefined` for a module HEAD does not
+     *  hold. The compiler's attribution reads it: an error the module already had at
+     *  HEAD is not this run's. */
+    const headContentOfFile = new Map();
+    const contentOfFile = new Map();
     const allHelpers = [];
     const helpersByFile = new Map();
     const allAllows = [];
@@ -170,10 +180,17 @@ export async function verifyUtils(params) {
         // helpers this run writes, so a defaulted status on an incumbent is not advised
         // — and an incumbent's signature is held to what it was (incumbent.ts). Absent
         // for a module this run created, or outside git: then every helper is this run's.
-        const baseline = await contentAtHead(file);
+        const atHead = await readAtHead(file);
+        const baseline = "content" in atHead ? atHead.content : undefined;
+        if (baseline !== undefined)
+            result.incumbentModules.push(file);
+        else if ("unknown" in atHead)
+            result.headUnknownModules.push(file);
         const headHelpers = baseline === undefined ? [] : parseUtilsFile(baseline, fileSpec);
         const incumbents = new Set(headHelpers.map((h) => h.name));
         incumbentsOfFile.set(file, incumbents);
+        headContentOfFile.set(file, baseline);
+        contentOfFile.set(file, content);
         pending.push(...incumbentSignatureViolations(headHelpers, helpers, file));
         for (const h of helpers) {
             // A static reading of the signature. An unannotated parameter is an error only
@@ -431,8 +448,10 @@ export async function verifyUtils(params) {
     // The compiler over the delivered files: the shared module(s) and the spec that
     // imports them. The executor transpiles TypeScript without typechecking it, so
     // this is the first typecheck the files meet before the customer's own. An error
-    // under the permissive settings fails under every configuration and blocks; one
-    // only the repository's tsconfig raises advises (see typecheckDelivered).
+    // under the permissive settings fails under every configuration and blocks when
+    // this run caused it — one the file already had at HEAD advises (see the
+    // attribution below); one only the repository's tsconfig raises advises (see
+    // typecheckDelivered).
     // Over the TypeScript files only, by extension: a JavaScript module is not
     // typechecked (its spec would be `checkJs`, which no delivered file relies on),
     // and a JavaScript spec is not compiled beside a TypeScript module.
@@ -444,7 +463,7 @@ export async function verifyUtils(params) {
         const realSpec = await realpath(params.testFile);
         const specFile = realSpec && isTs(realSpec) ? realSpec : undefined;
         const files = specFile ? [...tsUtils, specFile] : tsUtils;
-        const tc = await typecheckDelivered(files);
+        const tc = await typecheckDelivered(files, { anchor: specFile });
         result.typecheck = tc;
         const subjectOf = (file, line) => file === specFile
             ? path.basename(specFile).replace(/\W/g, "_")
@@ -459,11 +478,96 @@ export async function verifyUtils(params) {
         const redefined = new Set(pending
             .filter((v) => v.kind === "helper-redefined")
             .map((v) => `${v.file}\0${v.helper}`));
+        // The files as the repository held them BEFORE this run — each at HEAD —
+        // compiled once more, so that an error is excused only when the repository
+        // already had it on the same line: attribution by CAUSE. A file HEAD does not
+        // hold (a module or a spec this run created) is hidden from that compile and
+        // every error in it is this run's — the generator's included: a line any
+        // pass of this run wrote is the run's to fix, and only what the customer or
+        // an earlier run committed is not.
+        const baselineContents = new Map();
+        const hidden = new Set();
+        const attribution = {
+            ran: false,
+            headUnknown: [...result.headUnknownModules],
+        };
+        result.attribution = attribution;
+        for (const file of tsUtils) {
+            const head = headContentOfFile.get(file);
+            if (head === undefined)
+                hidden.add(file);
+            else
+                baselineContents.set(file, head);
+        }
+        if (specFile) {
+            const specAtHead = await readAtHead(specFile);
+            if ("content" in specAtHead)
+                baselineContents.set(specFile, specAtHead.content);
+            else {
+                hidden.add(specFile);
+                if ("unknown" in specAtHead)
+                    attribution.headUnknown.push(specFile);
+            }
+        }
+        // Every OTHER file the program may reach — a page object, an in-house helper,
+        // a config module — as HEAD held it too: one the run changed is served from
+        // HEAD, one the run added does not exist. Read from the working tree, a
+        // page-object edit put its error into both compiles and it was excused as
+        // inherited. Only the extensions the compiler reads; nothing under
+        // node_modules, which the run does not edit.
+        // Nothing to attribute on a clean compile: the HEAD compile — a full second
+        // program build — is skipped, and the skip is stated so the field is never
+        // read as "attribution ran and excused nothing".
+        const baselineErrors = new BaselineErrors();
+        if (tc.errors.length === 0)
+            attribution.reason = "the delivered files compiled clean";
+        else if (baselineContents.size === 0)
+            attribution.reason =
+                "no delivered file exists at HEAD, so there is nothing to inherit from";
+        else if (!(await addBaselineForChangedFiles(root, baselineContents, hidden)))
+            attribution.reason =
+                "the files this run changed could not be listed, so no file could be read at HEAD";
+        else {
+            const before = await typecheckDelivered([...baselineContents.keys()], {
+                anchor: specFile,
+                baseline: { contents: baselineContents, hidden },
+            });
+            if (!before.ran) {
+                // The delivered compile ran and this one did not: something in the HEAD
+                // content or the host. Stated, never silent — the old errors then block
+                // as this run's, which is the outcome attribution exists to prevent.
+                attribution.reason = `the HEAD compile did not run: ${before.reason ?? "unknown cause"}`;
+                logger.warning("The HEAD compile did not run — no type error will be excused as inherited", { testFile: params.testFile, reason: before.reason });
+            }
+            else {
+                attribution.ran = true;
+                for (const e of before.errors)
+                    baselineErrors.add(baselineErrorKey(e.file, e.line, e.code, e.message));
+            }
+        }
+        const unchangedOf = new Map();
+        for (const [file, before] of baselineContents) {
+            const now = file === specFile ? specContent : contentOfFile.get(file);
+            if (now !== undefined)
+                unchangedOf.set(file, alignLines(before, now));
+        }
+        const inherited = inheritedTypeError((file) => unchangedOf.get(file), baselineErrors);
         for (const e of tc.errors) {
             const helper = subjectOf(e.file, e.line);
             if (REDECLARATION_CODES.has(e.code) &&
                 redefined.has(`${e.file}\0${helper}`))
                 continue;
+            const why = inherited(e.file, e.line, e.code, e.message);
+            if (why !== undefined) {
+                result.advisories.push({
+                    kind: "inherited-type-error",
+                    file: e.file,
+                    helper,
+                    line: e.line,
+                    detail: `\`TS${e.code}: ${e.message}\` — ${why}`,
+                });
+                continue;
+            }
             pending.push({
                 kind: "type-error",
                 file: e.file,
@@ -686,6 +790,50 @@ function remediation(helper, literal, incumbent) {
 }
 /** The compared counts as one phrase, shared by the assertion-loss detail and the
  *  PASSED line's note so the two cannot drift. */
+/** Extensions the compiler reads as source. */
+const COMPILED_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+]);
+/**
+ * Add to the baseline every compiled file in the repository that differs from
+ * HEAD and is not already accounted for: changed files served from HEAD, added
+ * files hidden. Returns whether the listing succeeded — a baseline that cannot
+ * be completed must excuse NOTHING, since any file it reads from disk may carry
+ * the run's own edit; the caller then compiles no baseline and every error
+ * blocks, as before attribution existed.
+ */
+async function addBaselineForChangedFiles(root, contents, hidden) {
+    if (!root)
+        return true; // outside git nothing has a HEAD; nothing is excused
+    const compiled = (f) => COMPILED_EXTENSIONS.has(path.extname(f)) &&
+        !f.split(path.sep).includes("node_modules");
+    try {
+        for (const file of await changedSinceHead(root, { filter: "M" })) {
+            if (!compiled(file) || contents.has(file) || hidden.has(file))
+                continue;
+            const head = await contentAtHead(file, root);
+            if (head === undefined)
+                return false; // git did not answer: excuse nothing
+            contents.set(file, head);
+        }
+        for (const file of await addedSinceHead(root))
+            if (compiled(file) && !contents.has(file))
+                hidden.add(file);
+        return true;
+    }
+    catch (err) {
+        logger.warning("Could not list the files this run changed — no type error will be excused as inherited", { root, error: String(err) });
+        return false;
+    }
+}
 export function describeAssertionCount(c) {
     return `${c.baseline} assertions at the modularization hand-out, ${c.delivered} delivered (${c.inSpec} in the test, ${c.inHelpers} in the helpers it imports and calls)`;
 }

package/build/utils/versions.d.ts

@@ -1,4 +1,4 @@
-export declare const SKYRAMP_IMAGE_VERSION = "v1.3.46";
-export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.46";
-export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.46";
+export declare const SKYRAMP_IMAGE_VERSION = "v1.3.47";
+export declare const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.47";
+export declare const WORKER_DOCKER_IMAGE = "skyramp/worker:v1.3.47";
 export declare const WORKER_CONTROL_PORT = 35142;

package/build/utils/versions.js

@@ -1,4 +1,4 @@
-export const SKYRAMP_IMAGE_VERSION = "v1.3.46";
+export const SKYRAMP_IMAGE_VERSION = "v1.3.47";
 export const EXECUTOR_DOCKER_IMAGE = `skyramp/executor:${SKYRAMP_IMAGE_VERSION}`;
 export const WORKER_DOCKER_IMAGE = `skyramp/worker:${SKYRAMP_IMAGE_VERSION}`;
 // Control port the Skyramp worker listens on (SDK `CONTAINER_PORT`).

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

@@ -88,10 +88,12 @@ Requested path: ${outputZip}` }],
         counter++;
       outputZip = `${base}_${counter}${ext}`;
     }
-    const { jsonl: jsonlContent, actionCount, skipped } = (0, import_skyRampExport.buildJsonlContent)(ctx.trackedActions, "chromium", ctx.harPath);
+    const { jsonl: jsonlContent, actionCount, skipped, simplified } = (0, import_skyRampExport.buildJsonlContent)(ctx.trackedActions, "chromium", ctx.harPath);
     await (0, import_skyRampExport.writeSkyrampZip)(outputZip, jsonlContent, ctx.harPath);
     const skippedNote = skipped.length ? `
 Skipped (not exportable): ${[...new Set(skipped)].join(", ")}` : "";
+    const simplifiedNote = simplified.length ? `
+Exported with a simplified locator (a part the trace format cannot carry was dropped, so the step may match more elements at replay): ${[...new Set(simplified)].join("; ")}` : "";
     const dropped = ctx.droppedActions ?? [];
     const droppedNote = dropped.length ? `
 Failed & dropped (not recorded): ${summarizeDropped(dropped)}` : "";
@@ -102,7 +104,7 @@ Failed & dropped (not recorded): ${summarizeDropped(dropped)}` : "";
 Skyramp zip written to ${outputZip}
 
 Contains:
-- skyramp_playwright.txt (${actionCount} actions)${skippedNote}${droppedNote}`
+- skyramp_playwright.txt (${actionCount} actions)${skippedNote}${simplifiedNote}${droppedNote}`
       }]
     };
   };