@molecule/api-ai-tools 1.16.2 → 1.16.4

package/dist/browser-probe.js

@@ -36,6 +36,7 @@
  *
  * @module
  */
+import { codeWithModuleSpecifiers as codeOnly } from './source-code.js';
 /** A `const|let|var <name> = await [qualifier.]chromium|firefox|webkit.launch(` binding. */
 const LAUNCH = /(?<![\w$.])(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=\n]+)?=\s*await\s+(?:([A-Za-z_$][\w$]*)\s*\.\s*)?(chromium|firefox|webkit)\s*\.\s*launch\s*\(/g;
 /** A browser method that does not close the browser, so calling it leaves the handle alive. */
@@ -57,217 +58,6 @@ const ANY_CLEANUP = /\.\s*(?:close|disconnect|dispose)\s*\(|[A-Za-z_$][\w$]*\s*\
 const CLEANUP_HINT = /cleanup|teardown|close|dispose|shutdown|quit/i;
 /** The packages whose `chromium`/`firefox`/`webkit` export really launches a browser. */
 const PLAYWRIGHT_PACKAGE = '(?:playwright-core|playwright|@playwright/test)';
-/** The characters after which a `/` starts a regex literal rather than a division. */
-const REGEX_AFTER = new Set([
-    '',
-    '(',
-    '[',
-    '{',
-    ',',
-    ';',
-    ':',
-    '=',
-    '!',
-    '&',
-    '|',
-    '?',
-    '+',
-    '-',
-    '*',
-    '%',
-    '^',
-    '~',
-    '<',
-    '>',
-    '}',
-]);
-/**
- * A source with every comment and every string, template and regex literal blanked to spaces,
- * preserving offsets and newlines so a match's position still indexes the original source.
- *
- * A launch mentioned in prose is not a launch: a review proved scripts that only PRINT
- * `const browser = await chromium.launch()` — in a string, a comment and a template literal — and
- * a raw substring match refused all of them. Template `${…}` substitutions stay code (a `close()`
- * written there is a real cleanup path), nested braces are tracked so the substitution's end is
- * found, and regex literals are recognised by the token before them so a quote inside a character
- * class cannot blank the rest of the file.
- *
- * @param source - The script's source.
- * @returns The same text with literal/comment spans replaced by spaces.
- */
-function codeOnly(source) {
-    const out = source.split('');
-    const blank = (from, to) => {
-        for (let i = from; i < to; i++)
-            if (out[i] !== '\n')
-                out[i] = ' ';
-    };
-    const stack = [{ mode: 'code', braces: 0 }];
-    const top = () => stack[stack.length - 1];
-    /** The last non-whitespace CODE character: decides whether a `/` opens a regex. */
-    let lastCode = '';
-    /** The last identifier word and the word being read — a module specifier follows `from`. */
-    let lastWord = '';
-    let word = '';
-    /** A specifier (`from 'playwright'`, `require('playwright')`) stays readable to provenance. */
-    const specifierAhead = () => lastWord === 'from' || lastWord === 'require' || lastWord === 'import';
-    let i = 0;
-    while (i < source.length) {
-        const frame = top();
-        const char = source[i] ?? '';
-        const next = source[i + 1];
-        if (frame.mode === 'code') {
-            if (char === '/' && next === '/') {
-                stack.push({ mode: 'line' });
-                blank(i, i + 2);
-                i += 2;
-                continue;
-            }
-            if (char === '/' && next === '*') {
-                stack.push({ mode: 'block' });
-                blank(i, i + 2);
-                i += 2;
-                continue;
-            }
-            if (char === "'" || char === '"') {
-                stack.push({ mode: 'string', quote: char, keep: specifierAhead() });
-                if (!specifierAhead())
-                    out[i] = ' ';
-                i += 1;
-                continue;
-            }
-            if (char === '`') {
-                stack.push({ mode: 'template' });
-                out[i] = ' ';
-                i += 1;
-                continue;
-            }
-            if (char === '/' && REGEX_AFTER.has(lastCode)) {
-                stack.push({ mode: 'regex', inClass: false });
-                out[i] = ' ';
-                i += 1;
-                continue;
-            }
-            if (frame.braces > 0) {
-                if (char === '{')
-                    frame.braces += 1;
-                else if (char === '}') {
-                    frame.braces -= 1;
-                    if (frame.braces === 0) {
-                        stack.pop();
-                        out[i] = ' ';
-                        i += 1;
-                        continue;
-                    }
-                }
-            }
-            if (/[\w$]/.test(char))
-                word += char;
-            else if (word !== '') {
-                lastWord = word;
-                word = '';
-            }
-            if (!/\s/.test(char))
-                lastCode = char;
-            i += 1;
-            continue;
-        }
-        if (frame.mode === 'line') {
-            if (char === '\n') {
-                stack.pop();
-                i += 1;
-                continue;
-            }
-            out[i] = ' ';
-            i += 1;
-            continue;
-        }
-        if (frame.mode === 'block') {
-            if (char === '*' && next === '/') {
-                blank(i, i + 2);
-                stack.pop();
-                i += 2;
-                continue;
-            }
-            if (char !== '\n')
-                out[i] = ' ';
-            i += 1;
-            continue;
-        }
-        if (frame.mode === 'string') {
-            if (char === '\\') {
-                if (!frame.keep)
-                    blank(i, i + 2);
-                i += 2;
-                continue;
-            }
-            if (char === frame.quote) {
-                if (!frame.keep)
-                    out[i] = ' ';
-                stack.pop();
-                // A string is an operand: the next `/` is division, not a regex.
-                lastCode = 'x';
-                i += 1;
-                continue;
-            }
-            if (!frame.keep && char !== '\n')
-                out[i] = ' ';
-            i += 1;
-            continue;
-        }
-        if (frame.mode === 'template') {
-            if (char === '\\') {
-                blank(i, i + 2);
-                i += 2;
-                continue;
-            }
-            if (char === '`') {
-                out[i] = ' ';
-                stack.pop();
-                lastCode = 'x';
-                i += 1;
-                continue;
-            }
-            if (char === '$' && next === '{') {
-                // The substitution is code: keep it visible and track its closing brace.
-                blank(i, i + 2);
-                stack.push({ mode: 'code', braces: 1 });
-                lastCode = '{';
-                i += 2;
-                continue;
-            }
-            if (char !== '\n')
-                out[i] = ' ';
-            i += 1;
-            continue;
-        }
-        // Regex literal: blank it, honour escapes and character classes, then its flags.
-        if (char === '\\') {
-            blank(i, i + 2);
-            i += 2;
-            continue;
-        }
-        if (char === '[')
-            frame.inClass = true;
-        else if (char === ']')
-            frame.inClass = false;
-        else if (char === '/' && !frame.inClass) {
-            out[i] = ' ';
-            stack.pop();
-            lastCode = 'x';
-            i += 1;
-            while (i < source.length && /[a-z]/i.test(source[i] ?? '')) {
-                out[i] = ' ';
-                i += 1;
-            }
-            continue;
-        }
-        if (char !== '\n')
-            out[i] = ' ';
-        i += 1;
-    }
-    return out.join('');
-}
 /**
  * How many `{ … }` blocks are open at one offset of the code-only text.
  *

package/dist/source-code.d.ts

@@ -0,0 +1,17 @@
+/** Shared lexical masking for source inspection without executing a module. */
+/**
+ * A source with every comment and every string, template and regex literal blanked to spaces,
+ * preserving offsets and newlines so a match's position still indexes the original source.
+ *
+ * A launch mentioned in prose is not a launch: a review proved scripts that only PRINT
+ * `const browser = await chromium.launch()` — in a string, a comment and a template literal — and
+ * a raw substring match refused all of them. Template `${…}` substitutions stay code (a `close()`
+ * written there is a real cleanup path), nested braces are tracked so the substitution's end is
+ * found, and regex literals are recognised by the token before them so a quote inside a character
+ * class cannot blank the rest of the file.
+ *
+ * @param source - The script's source.
+ * @returns The same text with literal/comment spans replaced by spaces.
+ */
+export declare function codeWithModuleSpecifiers(source: string): string;
+//# sourceMappingURL=source-code.d.ts.map

package/dist/source-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-code.d.ts","sourceRoot":"","sources":["../src/source-code.ts"],"names":[],"mappings":"AAAA,+EAA+E;AA2B/E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwK/D"}

package/dist/source-code.js

@@ -0,0 +1,214 @@
+/** Shared lexical masking for source inspection without executing a module. */
+/** The characters after which a `/` starts a regex literal rather than a division. */
+const REGEX_AFTER = new Set([
+    '',
+    '(',
+    '[',
+    '{',
+    ',',
+    ';',
+    ':',
+    '=',
+    '!',
+    '&',
+    '|',
+    '?',
+    '+',
+    '-',
+    '*',
+    '%',
+    '^',
+    '~',
+    '<',
+    '>',
+    '}',
+]);
+/**
+ * A source with every comment and every string, template and regex literal blanked to spaces,
+ * preserving offsets and newlines so a match's position still indexes the original source.
+ *
+ * A launch mentioned in prose is not a launch: a review proved scripts that only PRINT
+ * `const browser = await chromium.launch()` — in a string, a comment and a template literal — and
+ * a raw substring match refused all of them. Template `${…}` substitutions stay code (a `close()`
+ * written there is a real cleanup path), nested braces are tracked so the substitution's end is
+ * found, and regex literals are recognised by the token before them so a quote inside a character
+ * class cannot blank the rest of the file.
+ *
+ * @param source - The script's source.
+ * @returns The same text with literal/comment spans replaced by spaces.
+ */
+export function codeWithModuleSpecifiers(source) {
+    const out = source.split('');
+    const blank = (from, to) => {
+        for (let i = from; i < to; i++)
+            if (out[i] !== '\n')
+                out[i] = ' ';
+    };
+    const stack = [{ mode: 'code', braces: 0 }];
+    const top = () => stack[stack.length - 1];
+    /** The last non-whitespace CODE character: decides whether a `/` opens a regex. */
+    let lastCode = '';
+    /** The last identifier word and the word being read — a module specifier follows `from`. */
+    let lastWord = '';
+    let word = '';
+    /** A specifier (`from 'playwright'`, `require('playwright')`) stays readable to provenance. */
+    const specifierAhead = () => (lastWord === 'from' && lastCode === 'm') ||
+        (lastWord === 'import' && lastCode === 't') ||
+        ((lastWord === 'require' || lastWord === 'import') && lastCode === '(');
+    let i = 0;
+    while (i < source.length) {
+        const frame = top();
+        const char = source[i] ?? '';
+        const next = source[i + 1];
+        if (frame.mode === 'code') {
+            if (char === '/' && next === '/') {
+                stack.push({ mode: 'line' });
+                blank(i, i + 2);
+                i += 2;
+                continue;
+            }
+            if (char === '/' && next === '*') {
+                stack.push({ mode: 'block' });
+                blank(i, i + 2);
+                i += 2;
+                continue;
+            }
+            if (char === "'" || char === '"') {
+                stack.push({ mode: 'string', quote: char, keep: specifierAhead() });
+                if (!specifierAhead())
+                    out[i] = ' ';
+                i += 1;
+                continue;
+            }
+            if (char === '`') {
+                stack.push({ mode: 'template' });
+                out[i] = ' ';
+                i += 1;
+                continue;
+            }
+            if (char === '/' && REGEX_AFTER.has(lastCode)) {
+                stack.push({ mode: 'regex', inClass: false });
+                out[i] = ' ';
+                i += 1;
+                continue;
+            }
+            if (frame.braces > 0) {
+                if (char === '{')
+                    frame.braces += 1;
+                else if (char === '}') {
+                    frame.braces -= 1;
+                    if (frame.braces === 0) {
+                        stack.pop();
+                        out[i] = ' ';
+                        i += 1;
+                        continue;
+                    }
+                }
+            }
+            if (/[\w$]/.test(char))
+                word += char;
+            else if (word !== '') {
+                lastWord = word;
+                word = '';
+            }
+            if (!/\s/.test(char))
+                lastCode = char;
+            i += 1;
+            continue;
+        }
+        if (frame.mode === 'line') {
+            if (char === '\n') {
+                stack.pop();
+                i += 1;
+                continue;
+            }
+            out[i] = ' ';
+            i += 1;
+            continue;
+        }
+        if (frame.mode === 'block') {
+            if (char === '*' && next === '/') {
+                blank(i, i + 2);
+                stack.pop();
+                i += 2;
+                continue;
+            }
+            if (char !== '\n')
+                out[i] = ' ';
+            i += 1;
+            continue;
+        }
+        if (frame.mode === 'string') {
+            if (char === '\\') {
+                if (!frame.keep)
+                    blank(i, i + 2);
+                i += 2;
+                continue;
+            }
+            if (char === frame.quote) {
+                if (!frame.keep)
+                    out[i] = ' ';
+                stack.pop();
+                // A string is an operand: the next `/` is division, not a regex.
+                lastCode = 'x';
+                i += 1;
+                continue;
+            }
+            if (!frame.keep && char !== '\n')
+                out[i] = ' ';
+            i += 1;
+            continue;
+        }
+        if (frame.mode === 'template') {
+            if (char === '\\') {
+                blank(i, i + 2);
+                i += 2;
+                continue;
+            }
+            if (char === '`') {
+                out[i] = ' ';
+                stack.pop();
+                lastCode = 'x';
+                i += 1;
+                continue;
+            }
+            if (char === '$' && next === '{') {
+                // The substitution is code: keep it visible and track its closing brace.
+                blank(i, i + 2);
+                stack.push({ mode: 'code', braces: 1 });
+                lastCode = '{';
+                i += 2;
+                continue;
+            }
+            if (char !== '\n')
+                out[i] = ' ';
+            i += 1;
+            continue;
+        }
+        // Regex literal: blank it, honour escapes and character classes, then its flags.
+        if (char === '\\') {
+            blank(i, i + 2);
+            i += 2;
+            continue;
+        }
+        if (char === '[')
+            frame.inClass = true;
+        else if (char === ']')
+            frame.inClass = false;
+        else if (char === '/' && !frame.inClass) {
+            out[i] = ' ';
+            stack.pop();
+            lastCode = 'x';
+            i += 1;
+            while (i < source.length && /[a-z]/i.test(source[i] ?? '')) {
+                out[i] = ' ';
+                i += 1;
+            }
+            continue;
+        }
+        if (char !== '\n')
+            out[i] = ' ';
+        i += 1;
+    }
+    return out.join('');
+}

package/dist/suite-overlap.d.ts

@@ -50,6 +50,14 @@ export declare function withoutHeredocs(command: string): string;
  * @returns The target key.
  */
 export declare function suiteCommandTarget(command: string): string;
+/**
+ * The target of the actual Playwright step, including inherited exports. URLs and option names
+ * in another program or a quoted title cannot decide whether this step is deployed.
+ * @param command - The shell command.
+ * @param last - Read the last Playwright invocation, for the background launch rewrite.
+ * @returns The comparable target key, or local when no target setting is present.
+ */
+export declare function playwrightCommandTarget(command: string, last?: boolean): string;
 /**
  * Whether a Playwright statement names its own config — the reading {@link withSuiteConfig} and
  * {@link scopedRerunCommand} share, so neither adds a second `--config` to a command that has one.
@@ -147,6 +155,22 @@ export interface RunEnvSetting {
  * @returns The command, or the command unchanged when it already carries every setting.
  */
 export declare function withRunEnv(command: string, settings?: readonly RunEnvSetting[]): string;
+/**
+ * The absolute directory the Playwright statement in a command runs in, or null when the command
+ * does not say.
+ *
+ * The reporter prints a failing test's file relative to the process directory the runner started
+ * in (`../fixtures/…` from a run whose suite lives outside its own tree), so the directory has to
+ * come from the command itself: `exec_command`'s `cwd` when it was given, then each `cd` before
+ * the runner. Only a literal `cd` is followed — a target holding a variable, a glob or `~`
+ * resolves nowhere useful, and a guessed absolute path is worse than the relative one the
+ * reporter printed.
+ *
+ * @param command - The shell command.
+ * @param cwd - The `cwd` the tool was given, when it was.
+ * @returns The absolute directory, or null.
+ */
+export declare function suiteRunDirectory(command: string, cwd?: string | null): string | null;
 /**
  * Resolve literal `./`/`../` Playwright file selections against the runner's own directory.
  *

package/dist/suite-overlap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAaH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AA2VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,EAClC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,MAAM,CA2DR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AA2PD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAa5F;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqHD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAA4D,CAAA;AAEhG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CA2BtF"}
+{"version":3,"file":"suite-overlap.d.ts","sourceRoot":"","sources":["../src/suite-overlap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAaH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAoB1D;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,MAAM,CAwB7E;AAKD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAS1F;AA2VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,QAAQ,GAAE,SAAS,MAAM,EAAO,EAChC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,EACtB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EACnB,GAAG,GAAE,SAAS,aAAa,EAAO,EAClC,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,MAAM,CA2DR;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CACd;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,SAAS,aAAa,EAAO,GAAG,MAAM,CAe3F;AAQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAiCrF;AAkND;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAa5F;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+FAA+F;IAC/F,SAAS,EAAE,OAAO,CAAA;IAClB,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,EACzD,SAAS,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAC7B,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAMV;AAqHD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,EAAE,OAAO,MAA4D,CAAA;AAEhG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAM7D;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CA2BtF"}

package/dist/suite-overlap.js

@@ -75,6 +75,31 @@ export function suiteCommandTarget(command) {
     }
     return 'local';
 }
+/**
+ * The target of the actual Playwright step, including inherited exports. URLs and option names
+ * in another program or a quoted title cannot decide whether this step is deployed.
+ * @param command - The shell command.
+ * @param last - Read the last Playwright invocation, for the background launch rewrite.
+ * @returns The comparable target key, or local when no target setting is present.
+ */
+export function playwrightCommandTarget(command, last = false) {
+    const steps = locatedCommandSegments(command);
+    const runners = steps.filter((step) => step.segment?.program === 'playwright' && step.segment.args[0] === 'test');
+    const runner = runners.at(last ? -1 : 0);
+    if (!runner)
+        return suiteCommandTarget(command);
+    const inherited = steps
+        .slice(0, steps.indexOf(runner))
+        .filter((step) => (step.shellScope ?? []).every((scope, i) => scope === runner.shellScope?.[i]) &&
+        (step.segment === null || step.segment.program === 'export'));
+    const prefix = runner.start !== null && runner.programOffset !== null
+        ? command.slice(runner.start, runner.programOffset)
+        : runner.assignments.join(' ');
+    return suiteCommandTarget([
+        prefix,
+        ...inherited.reverse().map((step) => step.segment?.text ?? step.assignments.join(' ')),
+    ].join('; '));
+}
 /** Whether a Playwright statement already names its own config (`-c`, `--config`, `--config=`). */
 const NAMES_CONFIG = /(?:^|\s)(?:-c|--config)(?:\s+|=)/;
 /**
@@ -619,29 +644,40 @@ const unquoted = (word) => word.replace(/^['"]|['"]$/g, '');
  * @param cwd - The `cwd` the tool was given, when it was.
  * @returns The absolute directory, or null.
  */
-function suiteRunDirectory(command, cwd) {
-    let dir = typeof cwd === 'string' && cwd.startsWith('/') ? posix.normalize(cwd) : null;
-    for (const { segment } of locatedCommandSegments(command)) {
+export function suiteRunDirectory(command, cwd) {
+    const dirs = new Map([
+        ['', typeof cwd === 'string' && cwd.startsWith('/') ? posix.normalize(cwd) : null],
+    ]);
+    for (const located of locatedCommandSegments(command)) {
+        const scope = located.shellScope ?? [];
+        const key = scope.join('\0');
+        if (!dirs.has(key)) {
+            let parent = scope.slice(0, -1);
+            while (!dirs.has(parent.join('\0')))
+                parent = parent.slice(0, -1);
+            dirs.set(key, dirs.get(parent.join('\0')) ?? null);
+        }
+        const { segment } = located;
         if (segment === null)
             continue;
         if (segment.program === 'cd') {
-            const target = unquoted(segment.args[0] ?? '').replace(/\/+$/, '');
-            if (!target || target.startsWith('-') || target.startsWith('~') || !LITERAL_DIR.test(target))
-                return null;
-            // A shell `cd /abs` DISCARDS the directory before it; only a relative target resolves
-            // against the one the run started in.
-            if (target.startsWith('/'))
-                dir = posix.normalize(target);
-            else if (dir === null)
-                return null;
-            else
-                dir = posix.normalize(posix.join(dir, target));
-            continue;
+            const words = segment.args.map(unquoted);
+            while (words[0] === '--' || words[0] === '-L' || words[0] === '-P')
+                words.shift();
+            const target = words[0] ?? '';
+            const dir = dirs.get(key) ?? null;
+            dirs.set(key, !target || target.startsWith('-') || target.startsWith('~') || !LITERAL_DIR.test(target)
+                ? null
+                : target.startsWith('/')
+                    ? posix.normalize(target)
+                    : dir === null
+                        ? null
+                        : posix.normalize(posix.join(dir, target)));
         }
         if (segment.program === 'playwright' && segment.args[0] === 'test')
-            break;
+            return dirs.get(key) ?? null;
     }
-    return dir;
+    return null;
 }
 /** A failure location's path and its `:line[:column]` suffix, split the way Playwright does. */
 const LOCATION_LINE = /^(.*?)(:\d+(?::\d+)?)$/;

package/dist/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA2B9C,OAAO,EAIL,KAAK,mBAAmB,EAEzB,MAAM,wBAAwB,CAAA;AAsC/B;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,KAAK,CAAC,EACnD,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAmB9B;AAuLD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAwdD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAkInE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA0DlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CA6pGxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AA2B9C,OAAO,EAIL,KAAK,mBAAmB,EAEzB,MAAM,wBAAwB,CAAA;AAsC/B;;;;;;;;;;GAUG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,KAAK,CAAC,EACnD,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GACjC,OAAO,CAAC,mBAAmB,CAAC,CAmB9B;AAuLD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAahG;AAwdD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAkInE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,QAEA,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,QAI6C,CAAA;AA0DlF;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUhE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAA;AAoBpF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,CAAC,GACxE,qBAAqB,CAkBvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiCxB;AA2GD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CAypGxF"}

package/dist/tools.js

@@ -2819,17 +2819,13 @@ export function buildTools(backend, config) {
                     };
                 }
             }
-            // A Playwright run of a suite whose config records no trace gets one recorded anyway
-            // (`diagnosisTraceCommand`, trace-artifacts.ts): the failing tests' own network log is what
-            // tells a swallowed request error from a selector, and X1 xr-molecule-flash-m100 spent the
-            // last minutes of its run hand-writing Chromium probes for what the trace it never wrote
-            // down would have said. The whole rule is that function's; the whole-suite proof run gets it
-            // too, since a trace is retained only for a failing test (m163's proof run left none and the
-            // executor hunted one that did not exist).
+            // Diagnostic runs need readable failure traces. A proof-capable deployed run retains its
+            // own settings; diagnosisTraceCommand owns both decisions and uses the backend's readers.
             const traced = await diagnosisTraceCommand({
                 command: rawCommand,
                 cwd,
                 readFile: (path) => backend.readFile(path),
+                readDir: (path) => backend.readDir(path),
             });
             let command = traced.command;
             // A leading `sleep N; <read of a background task's log>` is a hand-rolled poll, and the

package/dist/trace-artifacts.d.ts

@@ -853,6 +853,11 @@ export declare function suiteRecordsTraces(configText: string): boolean;
 export declare function namesNoRetries(command: string): boolean;
 /** The `--trace` flag this platform adds, and the only value it adds it with. */
 export declare const DIAGNOSIS_TRACE_FLAG = "--trace=retain-on-failure";
+/** The backend's existing directory capability, when available. */
+type ReadConfigDirectory = (path: string) => Promise<Array<{
+    name: string;
+    type: 'file' | 'directory';
+}>>;
 /** A command with the trace flag this platform decided to add, and the sentence to report it in. */
 export interface DiagnosisTraceRewrite {
     /** The command to run. */
@@ -904,6 +909,7 @@ export declare function diagnosisTraceCommand(args: {
     command: string;
     cwd: string;
     readFile: (path: string) => Promise<string>;
+    readDir?: ReadConfigDirectory;
 }): Promise<DiagnosisTraceRewrite>;
 export {};
 //# sourceMappingURL=trace-artifacts.d.ts.map