@zohodesk/testinglibrary 0.0.82-n20-experimental → 0.0.84-n20-experimental

package/build/core/playwright/builtInFixtures/actorContext.js

@@ -25,20 +25,20 @@ class ActorContext {
       };
       const additionalActors = (0, _additionalProfiles.additionProfiles)($tags);
       await Promise.all(Object.entries(additionalActors).map(async ([role, actorInfo]) => {
-        const additionalContext = await browser.newContext();
-        const additionalPage = await additionalContext.newPage();
-        const ctxTestDetails = {
-          page: additionalPage,
+        let context = await browser.newContext();
+        let page = await context.newPage();
+        let ctxTestDetails = {
+          page,
           $tags,
-          context: additionalContext,
+          context,
           ...actorInfo
         };
-        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(additionalContext, testInfo, ctxTestDetails, actorInfo);
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
         this.actorsObj[role] = {
           role,
           browser,
-          context: additionalContext,
-          page: additionalPage,
+          context,
+          page,
           executionContext: {
             actorInfo
           }
@@ -69,10 +69,7 @@ var _default = exports.default = {
   }, use, testInfo) => {
     const ctxObject = new ActorContext();
     await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
-    try {
-      await use(ctxObject);
-    } finally {
-      await ctxObject.cleanup();
-    }
+    await use(ctxObject);
+    await ctxObject.cleanup();
   }
 };

package/build/core/playwright/builtInFixtures/context.js

@@ -8,6 +8,8 @@ exports.default = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
 var _logCollector = require("../helpers/logCollector");
+var _failureTagClassifier = require("../helpers/failureTagClassifier");
+var _runtimeLogPath = require("../helpers/runtimeLogPath");
 const {
   testSetup,
   uatDirectory,
@@ -17,12 +19,6 @@ const {
 // Keep runtime logs OUTSIDE reportPath (HTML reporter wipes it on onEnd) and
 // outside test-results (Playwright outputDir is cleaned each run).
 const LOGS_DIR = _path.default.join(uatDirectory, 'runtime-logs');
-const MAX_FILENAME_LENGTH = 120;
-function sanitizeForFilename(name) {
-  if (!name) return 'test';
-  const cleaned = name.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '').slice(0, MAX_FILENAME_LENGTH);
-  return cleaned || 'test';
-}
 async function performDefaultContextSteps({
   context
 }) {
@@ -44,7 +40,6 @@ var _default = exports.default = {
     });
     const collector = new _logCollector.LogCollector(browserLogs.limits);
     collector.attachToContext(context);
-    testInfo.runtimeLogs = collector;
     try {
       await use(context);
     } finally {
@@ -52,20 +47,25 @@ var _default = exports.default = {
       const failureOnly = browserLogs.mode === 'failure-only';
       const isFailure = testInfo.status && testInfo.status !== testInfo.expectedStatus;
       const shouldFlush = !failureOnly || isFailure;
-      const summary = collector.toSummary();
-      let filePath = null;
       if (shouldFlush) {
-        const base = `w${testInfo.workerIndex}-${sanitizeForFilename(testInfo.title)}-${testInfo.retry}`;
-        filePath = collector.flushToFile(LOGS_DIR, base);
+        const base = (0, _runtimeLogPath.resolveRuntimeLogBaseName)({
+          workerIndex: testInfo.workerIndex,
+          retry: testInfo.retry,
+          title: testInfo.title,
+          titlePath: testInfo.titlePath
+        });
+        collector.flushToFile(LOGS_DIR, base);
+      }
+      if (isFailure) {
+        const metadata = (0, _failureTagClassifier.classifyFailureDetailsFromEvents)(collector.events);
+        const attachment = (0, _failureTagClassifier.buildFailureTagMetadataAttachment)(metadata);
+        if (attachment) {
+          await testInfo.attach(attachment.name, {
+            contentType: attachment.contentType,
+            body: attachment.body
+          });
+        }
       }
-      await testInfo.attach('runtime-log', {
-        contentType: 'application/json',
-        body: Buffer.from(JSON.stringify({
-          schemaVersion: 1,
-          summary,
-          file: filePath
-        }))
-      });
     }
   }
 };

package/build/core/playwright/builtInFixtures/page.js

@@ -32,6 +32,7 @@ var _default = exports.default = {
     } finally {
       await (0, _loginDefaultStepsHelper.performDefaultPageSteps)(testDetails);
       await use(page);
+      await context.close();
     }
   }
 };

package/build/core/playwright/constants/failureTagConstants.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_METADATA_SCHEMA_VERSION = exports.FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAGS = void 0;
+const FAILURE_TAGS = exports.FAILURE_TAGS = {
+  CASE: 'CASE',
+  CODE: 'CODE',
+  ENVIRONMENT: 'ENVIRONMENT',
+  FLAKY: 'FLAKY',
+  TOOL: 'TOOL'
+};
+
+// Suffix appended to a category when merging into the existing spec.tags array,
+// e.g. "CODE" -> "CODE_failure". The flaky category is emitted as-is ("FLAKY").
+const FAILURE_TAG_SUFFIX = exports.FAILURE_TAG_SUFFIX = '_failure';
+const FAILURE_TAG_METADATA_ATTACHMENT = exports.FAILURE_TAG_METADATA_ATTACHMENT = 'failure-tag-metadata';
+const FAILURE_TAG_METADATA_SCHEMA_VERSION = exports.FAILURE_TAG_METADATA_SCHEMA_VERSION = 1;

package/build/core/playwright/constants/logCollectorConstants.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IGNORE_URL_PATTERNS = exports.IGNORE_MESSAGE_PATTERNS = void 0;
+// Ignore patterns for the runtime-log LogCollector. Matching events are dropped here so it is never recorded.
+
+// Matched against console-error text, pageerror messages and requestfailed
+
+const IGNORE_MESSAGE_PATTERNS = exports.IGNORE_MESSAGE_PATTERNS = [/Access is denied for this document/i, /enableDarkTheme is not a function/i, /enableZohoSearchAskZia is not a function/i, /enableSMSBridge is not a function/i, /Unexpected token '<'[\s\S]*not valid JSON/i, /blocked by CORS policy/i, /ERR_BLOCKED_BY_ORB/i];
+
+// Matched against request/response/requestfailed URLs and console-error source URLs.
+
+const IGNORE_URL_PATTERNS = exports.IGNORE_URL_PATTERNS = [/\.(png|jpe?g|gif|svg|webp|woff2?|ttf|css|map)(\?|$)/i, /google-analytics\.com|googletagmanager\.com|sentry\.io/i, /getHamburgerMenu\.do/i, /_chat\/unreadzmsg\.do/i, /_chat\/chatbarsync\.do/i, /agentAvailabilityConfig/i, /notifyAvailabilityStatus/i, /murphysdk/i, /phonebridge/i, /inproductsdk/i, /zquartz-tracker/i, /zohosearch\/.*gshandler/i, /stratuscdn\.com/i, /zohochat/i];

package/build/core/playwright/helpers/failureTagClassifier.js

@@ -0,0 +1,266 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildFailureTagMetadataAttachment = buildFailureTagMetadataAttachment;
+exports.classifyFailureDetails = classifyFailureDetails;
+exports.classifyFailureDetailsFromEvents = classifyFailureDetailsFromEvents;
+exports.classifyFailureDetailsFromResult = classifyFailureDetailsFromResult;
+exports.classifyFailureTags = classifyFailureTags;
+exports.mergeFailureTags = mergeFailureTags;
+exports.upsertFailureTagMetadataAttachment = upsertFailureTagMetadataAttachment;
+var _path = _interopRequireDefault(require("path"));
+var _failureTagConstants = require("../constants/failureTagConstants");
+var _patterns = require("../patterns");
+var _readConfigFile = require("../readConfigFile");
+var _runtimeLogReader = require("./runtimeLogReader");
+// A failing test is tagged purely on presence: if its runtime log contains an
+// environment pattern it gets `ENVIRONMENT`, if it contains a code pattern it
+// gets `CODE`, and if its stdout/stderr contains a tool pattern it gets `TOOL`
+// or a case pattern it gets `CASE` (any may apply). A `CASE` match also adds
+// `CODE` for now via case-implied metadata. `FLAKY` comes from the Playwright
+// retry outcome, not the log.
+
+const FAILING_RESULT_STATUSES = new Set(['failed', 'timedOut', 'interrupted']);
+const UNEXPECTED_OUTCOME = 'unexpected';
+const FLAKY_OUTCOME = 'flaky';
+const RUNTIME_LOG_SOURCE = 'runtime-log';
+const MAX_MATCH_TEXT_LENGTH = 500;
+const TAG_ORDER = [_failureTagConstants.FAILURE_TAGS.FLAKY, _failureTagConstants.FAILURE_TAGS.ENVIRONMENT, _failureTagConstants.FAILURE_TAGS.CASE, _failureTagConstants.FAILURE_TAGS.CODE, _failureTagConstants.FAILURE_TAGS.TOOL];
+const RUNTIME_LOG_RULES = [{
+  tag: _failureTagConstants.FAILURE_TAGS.ENVIRONMENT,
+  patterns: _patterns.ENVIRONMENT_PATTERNS
+}, {
+  tag: _failureTagConstants.FAILURE_TAGS.CODE,
+  patterns: _patterns.CODE_PATTERNS
+}];
+const STDIO_RULES = [{
+  tag: _failureTagConstants.FAILURE_TAGS.TOOL,
+  patterns: _patterns.TOOL_PATTERNS
+}, {
+  tag: _failureTagConstants.FAILURE_TAGS.CASE,
+  patterns: _patterns.CASE_PATTERNS,
+  impliesCode: true
+}];
+function resolveLogsDir(logsDir) {
+  if (logsDir) {
+    return logsDir;
+  }
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.join(uatDirectory, 'runtime-logs');
+}
+function patternLabel(pattern) {
+  return pattern.source;
+}
+function testPattern(pattern, text) {
+  if (pattern.global || pattern.sticky) {
+    pattern.lastIndex = 0;
+  }
+  return pattern.test(text);
+}
+function truncateText(text) {
+  if (!text || text.length <= MAX_MATCH_TEXT_LENGTH) {
+    return text || '';
+  }
+  return `${text.slice(0, MAX_MATCH_TEXT_LENGTH)}...`;
+}
+function eventToText(event) {
+  var _event$location;
+  switch (event.kind) {
+    case 'pageerror':
+      return `pageerror ${event.name || ''} ${event.message || ''}`;
+    case 'console':
+      return `console ${event.text || ''} ${((_event$location = event.location) === null || _event$location === void 0 ? void 0 : _event$location.url) || ''}`;
+    case 'requestfailed':
+      return `requestfailed ${event.resourceType || ''} ${event.method || ''} ${event.url || ''} ${event.failure || ''}`;
+    case 'response':
+      return `response ${event.status || ''} ${event.method || ''} ${event.url || ''}`;
+    default:
+      return JSON.stringify(event);
+  }
+}
+function findEventMatch(events, patterns, tag, source) {
+  for (const event of events) {
+    const text = eventToText(event);
+    for (const pattern of patterns) {
+      if (testPattern(pattern, text)) {
+        return {
+          tag,
+          pattern: patternLabel(pattern),
+          source,
+          text: truncateText(text)
+        };
+      }
+    }
+  }
+  return null;
+}
+function stdioToText(entries = []) {
+  return entries.map(entry => {
+    if (typeof entry === 'string') {
+      return entry;
+    }
+    if (!entry || typeof entry !== 'object') {
+      return '';
+    }
+    if (entry.text) {
+      return entry.text;
+    }
+    if (entry.buffer) {
+      try {
+        return Buffer.from(entry.buffer, 'base64').toString('utf8');
+      } catch {
+        return '';
+      }
+    }
+    return '';
+  }).join('\n');
+}
+function buildStdioText(result = {}) {
+  return `${stdioToText(result.stdout)}\n${stdioToText(result.stderr)}`;
+}
+function findStdioMatch(stdio, patterns, tag) {
+  for (const pattern of patterns) {
+    if (testPattern(pattern, stdio)) {
+      return {
+        tag,
+        pattern: patternLabel(pattern),
+        source: 'stdio',
+        text: truncateText(stdio)
+      };
+    }
+  }
+  return null;
+}
+function collectRuntimeLogMatches(events, matches) {
+  for (const rule of RUNTIME_LOG_RULES) {
+    const match = findEventMatch(events, rule.patterns, rule.tag, RUNTIME_LOG_SOURCE);
+    if (match) {
+      matches.push(match);
+    }
+  }
+}
+function collectStdioMatches(stdio, matches) {
+  for (const rule of STDIO_RULES) {
+    const match = findStdioMatch(stdio, rule.patterns, rule.tag);
+    if (!match) {
+      continue;
+    }
+    matches.push(match);
+    if (rule.impliesCode) {
+      implyCodeFromCase(matches, match);
+    }
+  }
+}
+function implyCodeFromCase(matches, caseMatch) {
+  if (matches.some(match => match.tag === _failureTagConstants.FAILURE_TAGS.CODE)) {
+    return;
+  }
+  matches.push({
+    tag: _failureTagConstants.FAILURE_TAGS.CODE,
+    pattern: null,
+    source: 'case-implied',
+    text: caseMatch.text
+  });
+}
+function classifyFailureDetailsFromEvents(events = []) {
+  const matches = [];
+  collectRuntimeLogMatches(events, matches);
+  return buildFailureTagMetadata(matches);
+}
+function classifyFailureDetailsFromResult(result, testTitle, logsDir) {
+  const resolvedLogsDir = resolveLogsDir(logsDir);
+  const events = (0, _runtimeLogReader.readRuntimeLogEventsForResult)(result, testTitle, resolvedLogsDir);
+  const matches = [];
+  collectRuntimeLogMatches(events, matches);
+  collectStdioMatches(buildStdioText(result), matches);
+  return buildFailureTagMetadata(matches);
+}
+function buildFailureTagMetadata(matches = []) {
+  const tags = TAG_ORDER.filter(tag => matches.some(match => match.tag === tag));
+  return {
+    schemaVersion: _failureTagConstants.FAILURE_TAG_METADATA_SCHEMA_VERSION,
+    tags,
+    matches
+  };
+}
+function classifyFailureDetails(testDetails = [], testTitle = 'test', logsDir) {
+  const resolvedLogsDir = resolveLogsDir(logsDir);
+  const matches = [];
+  for (const detail of testDetails) {
+    if (detail.status === FLAKY_OUTCOME) {
+      matches.push({
+        tag: _failureTagConstants.FAILURE_TAGS.FLAKY,
+        pattern: null,
+        source: 'retry-outcome',
+        text: null
+      });
+      continue;
+    }
+    if (detail.status !== UNEXPECTED_OUTCOME) {
+      continue;
+    }
+    const failingResult = pickFailingResult(detail.results);
+    if (!failingResult) {
+      continue;
+    }
+    const resultDetails = classifyFailureDetailsFromResult(failingResult, testTitle, resolvedLogsDir);
+    matches.push(...resultDetails.matches);
+  }
+  const uniqueMatches = [];
+  for (const match of matches) {
+    if (!uniqueMatches.some(existing => existing.tag === match.tag)) {
+      uniqueMatches.push(match);
+    }
+  }
+  return buildFailureTagMetadata(uniqueMatches);
+}
+function classifyFailureTags(testDetails = [], testTitle = 'test', logsDir) {
+  return classifyFailureDetails(testDetails, testTitle, logsDir).tags;
+}
+function pickFailingResult(results = []) {
+  const failing = results.filter(result => FAILING_RESULT_STATUSES.has(result.status));
+  if (failing.length === 0) {
+    return null;
+  }
+  return failing[failing.length - 1];
+}
+function formatFailureTag(tag) {
+  if (tag === _failureTagConstants.FAILURE_TAGS.FLAKY) {
+    return tag;
+  }
+  return `${tag}${_failureTagConstants.FAILURE_TAG_SUFFIX}`;
+}
+function mergeFailureTags(existingTags = [], failureTags = []) {
+  const formatted = failureTags.map(formatFailureTag);
+  const merged = [...formatted];
+  for (const tag of existingTags) {
+    if (!merged.includes(tag)) {
+      merged.push(tag);
+    }
+  }
+  return merged;
+}
+function buildFailureTagMetadataAttachment(details) {
+  var _details$tags;
+  if (!(details !== null && details !== void 0 && (_details$tags = details.tags) !== null && _details$tags !== void 0 && _details$tags.length)) {
+    return null;
+  }
+  return {
+    name: _failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT,
+    contentType: 'application/json',
+    body: Buffer.from(JSON.stringify(details, null, 2))
+  };
+}
+function upsertFailureTagMetadataAttachment(attachments = [], details) {
+  const metadataAttachment = buildFailureTagMetadataAttachment(details);
+  if (!metadataAttachment) {
+    return attachments;
+  }
+  const withoutMetadata = attachments.filter(item => item.name !== _failureTagConstants.FAILURE_TAG_METADATA_ATTACHMENT);
+  return [...withoutMetadata, metadataAttachment];
+}

package/build/core/playwright/helpers/logCollector.js

@@ -7,16 +7,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.LogCollector = void 0;
 var _path = _interopRequireDefault(require("path"));
 var _fileUtils = require("../../../utils/fileUtils");
+var _logCollectorConstants = require("../constants/logCollectorConstants");
 // Per-context Playwright runtime event collector — network failures,
 // console errors, page errors and crashes. Buffered in-memory and flushed
-// once per test via writeFileContents.
+// to the project runtime-logs folder per test.
 
 const DEFAULT_CONFIG = {
   maxEvents: 2000,
-  maxBodyBytes: 0,
-  captureHeaders: false,
-  ignoreMessagePatterns: [/n\.enableDarkTheme is not a function/],
-  ignoreUrlPatterns: [/\.(png|jpe?g|gif|svg|webp|woff2?|ttf|css|map)(\?|$)/i, /google-analytics\.com|googletagmanager\.com|sentry\.io/i]
+  ignoreMessagePatterns: _logCollectorConstants.IGNORE_MESSAGE_PATTERNS,
+  ignoreUrlPatterns: _logCollectorConstants.IGNORE_URL_PATTERNS
 };
 class LogCollector {
   constructor(config = {}) {
@@ -25,21 +24,10 @@ class LogCollector {
       ...config
     };
     this.events = [];
-    this.truncated = false;
-    this.counts = {
-      console: 0,
-      consoleError: 0,
-      pageError: 0,
-      request: 0,
-      response: 0,
-      failed: 0,
-      crash: 0
-    };
     this._bound = [];
   }
   _push(evt) {
     if (this.events.length >= this.config.maxEvents) {
-      this.truncated = true;
       this.events.shift();
     }
     this.events.push({
@@ -48,6 +36,9 @@ class LogCollector {
     });
   }
   _shouldIgnore(url) {
+    if (!url) {
+      return false;
+    }
     return this.config.ignoreUrlPatterns.some(re => re.test(url));
   }
   _shouldIgnoreMessage(message) {
@@ -63,18 +54,11 @@ class LogCollector {
   attachToContext(context) {
     context.pages().forEach(p => this._attachPage(p));
     this._bind(context, 'page', p => this._attachPage(p));
-    this._bind(context, 'request', req => {
-      if (this._shouldIgnore(req.url())) {
-        return;
-      }
-      this.counts.request++;
-    });
     this._bind(context, 'response', res => {
       const url = res.url();
       if (this._shouldIgnore(url)) {
         return;
       }
-      this.counts.response++;
       if (res.status() >= 400) {
         this._push({
           kind: 'response',
@@ -87,12 +71,16 @@ class LogCollector {
     });
     this._bind(context, 'requestfailed', req => {
       var _req$failure;
-      this.counts.failed++;
+      const url = req.url();
+      const failure = (_req$failure = req.failure()) === null || _req$failure === void 0 ? void 0 : _req$failure.errorText;
+      if (this._shouldIgnore(url) || this._shouldIgnoreMessage(failure)) {
+        return;
+      }
       this._push({
         kind: 'requestfailed',
         method: req.method(),
-        url: req.url(),
-        failure: (_req$failure = req.failure()) === null || _req$failure === void 0 ? void 0 : _req$failure.errorText,
+        url,
+        failure,
         resourceType: req.resourceType()
       });
     });
@@ -100,27 +88,25 @@ class LogCollector {
   _attachPage(page) {
     this._bind(page, 'console', msg => {
       const type = msg.type();
-      this.counts.console++;
       if (type !== 'error') {
         return;
       }
       const text = msg.text();
-      if (this._shouldIgnoreMessage(text)) {
+      const location = msg.location();
+      if (this._shouldIgnoreMessage(text) || this._shouldIgnore(location === null || location === void 0 ? void 0 : location.url)) {
         return;
       }
-      this.counts.consoleError++;
       this._push({
         kind: 'console',
         level: type,
         text,
-        location: msg.location()
+        location
       });
     });
     this._bind(page, 'pageerror', err => {
       if (this._shouldIgnoreMessage(err.message)) {
         return;
       }
-      this.counts.pageError++;
       this._push({
         kind: 'pageerror',
         name: err.name,
@@ -129,7 +115,6 @@ class LogCollector {
       });
     });
     this._bind(page, 'crash', () => {
-      this.counts.crash++;
       this._push({
         kind: 'crash',
         url: page.url()
@@ -146,13 +131,6 @@ class LogCollector {
     }
     this._bound.length = 0;
   }
-  toSummary() {
-    return {
-      ...this.counts,
-      total: this.events.length,
-      truncated: this.truncated
-    };
-  }
   flushToFile(dir, baseName) {
     if (this.events.length === 0) {
       return null;
@@ -160,7 +138,6 @@ class LogCollector {
     const file = _path.default.join(dir, `${baseName}.jsonl`);
     const body = this.events.map(e => JSON.stringify(e)).join('\n') + '\n';
     (0, _fileUtils.writeFileContents)(file, body);
-    this.events.length = 0;
     return file;
   }
 }

package/build/core/playwright/helpers/runtimeLogPath.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveRuntimeLogBaseName = resolveRuntimeLogBaseName;
+exports.resolveRuntimeLogFilePath = resolveRuntimeLogFilePath;
+exports.sanitizeForFilename = sanitizeForFilename;
+var _path = _interopRequireDefault(require("path"));
+const MAX_FILENAME_LENGTH = 200;
+const EXAMPLE_TITLE = /^Example\s*#\d+$/i;
+const SPEC_FILE = /\.(js|ts)$/;
+function sanitizeForFilename(name) {
+  if (!name) return 'test';
+  const cleaned = name.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+  return cleaned || 'test';
+}
+
+// playwright-bdd nests Example rows under test.describe(scenario.name).
+function extractOutlineScenarioName(titlePath = []) {
+  const segments = titlePath.filter(Boolean);
+  if (segments.length < 2 || !EXAMPLE_TITLE.test(segments[segments.length - 1])) {
+    return null;
+  }
+  for (let i = segments.length - 2; i >= 0; i--) {
+    const segment = segments[i];
+    if (segment && !SPEC_FILE.test(segment)) {
+      return segment;
+    }
+  }
+  return null;
+}
+function resolveRuntimeLogBaseName({
+  workerIndex = 0,
+  retry = 0,
+  title = 'test',
+  titlePath = []
+}) {
+  const scenarioName = extractOutlineScenarioName(titlePath);
+  const label = scenarioName ? `${scenarioName} ${title}` : title;
+  const base = `w${workerIndex}-${sanitizeForFilename(label)}-${retry}`;
+  if (base.length <= MAX_FILENAME_LENGTH) {
+    return base;
+  }
+  return base.slice(0, MAX_FILENAME_LENGTH).replace(/-$/, '');
+}
+function resolveRuntimeLogFilePath(logsDir, {
+  workerIndex,
+  retry,
+  title,
+  titlePath = []
+}) {
+  const base = resolveRuntimeLogBaseName({
+    workerIndex,
+    retry,
+    title,
+    titlePath
+  });
+  return _path.default.join(logsDir, `${base}.jsonl`);
+}

package/build/core/playwright/helpers/runtimeLogReader.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readRuntimeLogEvents = readRuntimeLogEvents;
+exports.readRuntimeLogEventsForResult = readRuntimeLogEventsForResult;
+var _fs = _interopRequireDefault(require("fs"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _runtimeLogPath = require("./runtimeLogPath");
+// Reads per-test runtime browser logs from the project runtime-logs folder.
+// Used by the failure-tag classifier to correlate browser events with a test failure.
+
+function parseJsonlContent(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const events = [];
+  for (const line of trimmed.split('\n')) {
+    const lineTrimmed = line.trim();
+    if (!lineTrimmed) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(lineTrimmed));
+    } catch {
+      // skip malformed line
+    }
+  }
+  return events;
+}
+function readRuntimeLogEvents(filePath) {
+  if (!filePath || !_fs.default.existsSync(filePath)) {
+    return [];
+  }
+  const rawContent = (0, _fileUtils.readFileContents)(filePath);
+  if (typeof rawContent !== 'string') {
+    return [];
+  }
+  return parseJsonlContent(rawContent);
+}
+function readRuntimeLogEventsForResult(result, testTitle, logsDir) {
+  if (!logsDir) {
+    return [];
+  }
+  const filePath = (0, _runtimeLogPath.resolveRuntimeLogFilePath)(logsDir, {
+    workerIndex: (result === null || result === void 0 ? void 0 : result.workerIndex) ?? 0,
+    retry: (result === null || result === void 0 ? void 0 : result.retry) ?? 0,
+    title: testTitle
+  });
+  return readRuntimeLogEvents(filePath);
+}