@zohodesk/testinglibrary 0.0.74-n20-experimental → 0.0.81-n20-experimental

package/README.md

@@ -17,6 +17,27 @@
 
      - npm run report
 
+### v4.1.9/v3.3.5 - 03-07-2026
+
+#### Feature
+- PortalDomain option provided in the settings.json.
+- This lets customer portal and related UAT flows resolve the portal URL from configuration instead of hardcoding environment-specific links.
+- It simplifies switching between setups such as dev, QA, and UAT without changing test code.
+
+
+### v4.1.5/v3.3.3 - 19-06-2026
+
+#### Refactor
+- Authenticator module refactored to use static imports instead of dynamic imports
+- Removed unnecessary `extends Authenticator` from concrete authenticator classes (`JWTauthenticator`, `OAuthAuthenticator`, `OrgOAuthAuthenticator`, `CookieAuthenticator`) to eliminate circular dependency
+- Unit test cases updated to align with actual source behavior
+
+### v4.1.4/v3.3.3 - 18-06-2026
+
+#### Bugfix
+- Dependency project failure stats pushed into custom reporter
+- `stepDefinitionsFolder` hardcoded changes removed
+
 ### v4.1.3/v3.3.2 - 08-06-2026
 
 #### Features

package/build/common/data-generator/steps/DataGenerator.spec.js

@@ -4,16 +4,16 @@ import { generateAndCacheTestData } from './DataGeneratorStepsHelper';
 const { Given } = createBdd();
 
 Given('generate a {string} entity {string} with generator {string}', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, generatorName, dataTable) => {
-    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName);
+    await generateAndCacheTestData({ executionContext, type: "template", identifier: generatorName, dataTable, cacheLayer, entityName, page });
 });
 
 Given('generate a {string} entity {string} with API {string}', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, operationId, dataTable) => {
-    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName);
+    await generateAndCacheTestData({ executionContext, type: "API", identifier: operationId, dataTable, cacheLayer, entityName, page });
 });
 Given('generate a {string} entity {string} with generator {string} using {string} profile', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, generatorName, profile, dataTable) => {
-    await generateAndCacheTestData(executionContext, "template", generatorName, dataTable, cacheLayer, entityName, profile);
+    await generateAndCacheTestData({ executionContext, type: "template", identifier: generatorName, dataTable, cacheLayer, entityName, profile, page });
 });
 
 Given('generate a {string} entity {string} with API {string} using {string} profile', async ({ page, context, i18N, cacheLayer, executionContext}, module, entityName, operationId, profile, dataTable) => {
-    await generateAndCacheTestData(executionContext, "API", operationId, dataTable, cacheLayer, entityName, profile);
-});
+    await generateAndCacheTestData({ executionContext, type: "API", identifier: operationId, dataTable, cacheLayer, entityName, profile, page });
+});

package/build/common/data-generator/steps/DataGeneratorStepsHelper.js

@@ -4,7 +4,7 @@ import DataGenerator from '@zohodesk/testinglibrary/DataGenerator';
 
 const dataGenerator = new DataGenerator();
 
-export async function generateAndCacheTestData(executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null) {
+export async function generateAndCacheTestData({ executionContext, type, identifier, dataTable, cacheLayer, entityName, profile = null, page = null }) {
     let actorInfo;
     const testInfo = test.info();
     const scenarioName = testInfo.title.split('/').pop() || 'Unknown Scenario';
@@ -16,6 +16,6 @@ export async function generateAndCacheTestData(executionContext, type, identifie
         actorInfo = executionContext.actorInfo;
     }
     
-    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : []);
+    const generatedData = await dataGenerator.generate(testInfo, actorInfo, type, identifier, scenarioName, dataTable ? dataTable.hashes() : [], page);
     await cacheLayer.set(entityName, generatedData.data);
 }

package/build/core/dataGenerator/DataGenerator.js

@@ -9,6 +9,7 @@ var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _logger = require("../../utils/logger");
 var _DataGeneratorHelper = require("./DataGeneratorHelper");
+var _Authenticator = _interopRequireDefault(require("./authenticator/Authenticator.js"));
 var _helpers = require("@zohodesk/testinglibrary/helpers");
 var _DataGeneratorError = require("./DataGeneratorError");
 function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
@@ -19,16 +20,21 @@ class DataGenerator {
   constructor() {
     _classPrivateMethodInitSpec(this, _DataGenerator_brand);
   }
-  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable) {
+  async generate(testInfo, actorInfo, generatorType, generatorName, scenarioName, dataTable, page = null) {
     try {
       let generators;
+      let domainUrl;
       if (generatorType === 'API') {
         generators = await _assertClassBrand(_DataGenerator_brand, this, _generateAPIGenerator).call(this, generatorName);
       } else {
         generators = await _assertClassBrand(_DataGenerator_brand, this, _getGenerator).call(this, testInfo, generatorName);
       }
+      const generatorOperationIds = generators.map(({
+        generatorOperationId
+      }) => generatorOperationId).filter(Boolean);
+      domainUrl = generatorOperationIds.some(operationId => operationId.startsWith('portal.')) ? process.env.portalDomain : process.env.domain;
       const processedGenerators = await (0, _DataGeneratorHelper.processGenerator)(generators, dataTable);
-      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo);
+      const apiPayload = await _assertClassBrand(_DataGenerator_brand, this, _constructApiPayload).call(this, scenarioName, processedGenerators, actorInfo, domainUrl, page);
       const response = await (0, _DataGeneratorHelper.makeRequest)(process.env.DG_SERVICE_DOMAIN + process.env.DG_SERVICE_API_PATH, apiPayload);
       _logger.Logger.log(_logger.Logger.INFO_TYPE, `Generated response for the generator: ${generatorName} for scenario: ${scenarioName}, Response: ${JSON.stringify(response)}`);
       return response;
@@ -72,12 +78,12 @@ async function _generateAPIGenerator(operationId) {
     name: operationId
   }];
 }
-async function _constructApiPayload(scenarioName, processedGenerators, actorInfo) {
+async function _constructApiPayload(scenarioName, processedGenerators, actorInfo, domainUrl, page = null) {
   const dataGeneratorObj = actorInfo['data-generator'];
   if (!dataGeneratorObj) {
     throw new _DataGeneratorError.DataGeneratorConfigurationError(`Data Generator configuration is missing for the profile: ${actorInfo['profile']}`);
   }
-  const apiPayload = {
+  let apiPayload = {
     scenario_name: scenarioName,
     data_generation_templates: processedGenerators,
     ...dataGeneratorObj
@@ -90,10 +96,14 @@ async function _constructApiPayload(scenarioName, processedGenerators, actorInfo
   const environmentDetails = apiPayload.environmentDetails || {};
   if (environmentDetails) {
     environmentDetails.iam_url = process.env.DG_IAM_DOMAIN;
-    const domainUrl = new URL(process.env.domain);
-    environmentDetails.host = domainUrl.origin;
+    const selectedDomain = new URL(domainUrl || process.env.domain);
+    environmentDetails.host = selectedDomain.origin;
   }
   apiPayload.environmentDetails = environmentDetails;
+
+  // Only perform auth augmentation via Authenticator
+  apiPayload = await new _Authenticator.default().constructPayload(apiPayload, actorInfo, page);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Final API Payload after authentication augmentation: ${JSON.stringify(apiPayload)}`);
   return apiPayload;
 }
 var _default = exports.default = DataGenerator;

package/build/core/dataGenerator/DataGeneratorError.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = void 0;
+exports.GeneratorError = exports.DataGeneratorError = exports.DataGeneratorConfigurationError = exports.AuthenticationError = void 0;
 class DataGeneratorError extends Error {
   constructor(message) {
     super(message);
@@ -47,4 +47,14 @@ class GeneratorError extends DataGeneratorError {
     }
   }
 }
-exports.GeneratorError = GeneratorError;
+exports.GeneratorError = GeneratorError;
+class AuthenticationError extends DataGeneratorError {
+  constructor(message) {
+    super(message);
+    this.name = 'AuthenticationError';
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AuthenticationError);
+    }
+  }
+}
+exports.AuthenticationError = AuthenticationError;

package/build/core/dataGenerator/authenticator/Authenticator.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+var _JWTauthenticator = _interopRequireDefault(require("./JWTauthenticator.js"));
+var _OAuthAuthenticator = _interopRequireDefault(require("./OAuthAuthenticator.js"));
+var _OrgOAuthAuthenticator = _interopRequireDefault(require("./OrgOAuthAuthenticator.js"));
+var _CookieAuthenticator = _interopRequireDefault(require("./CookieAuthenticator.js"));
+class Authenticator {
+  // Only route authentication augmentations; do not modify environment or base payload here.
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    var _actorInfo$dataGener;
+    const authenticationLoaders = {
+      'jwt-auth': () => new _JWTauthenticator.default(),
+      'oauth2': () => new _OAuthAuthenticator.default(),
+      'org-oauth': () => new _OrgOAuthAuthenticator.default(),
+      'cookie-auth': () => new _CookieAuthenticator.default()
+    };
+    const authentications = (actorInfo === null || actorInfo === void 0 || (_actorInfo$dataGener = actorInfo['data-generator']) === null || _actorInfo$dataGener === void 0 || (_actorInfo$dataGener = _actorInfo$dataGener.account) === null || _actorInfo$dataGener === void 0 ? void 0 : _actorInfo$dataGener.authentications) || [];
+    const authenticationTypes = authentications.map(auth => String(auth).toLowerCase()).filter(Boolean);
+    for (const authenticationType of authenticationTypes) {
+      const authenticatorLoader = authenticationLoaders[authenticationType];
+      if (!authenticatorLoader) {
+        throw new _DataGeneratorError.AuthenticationError(`Unknown authentication type: "${authenticationType}". Supported types are: ${Object.keys(authenticationLoaders).join(', ')}`);
+      }
+      const authenticatorInstance = await authenticatorLoader();
+      apiPayload = await authenticatorInstance.constructPayload(apiPayload, actorInfo, page);
+      break;
+    }
+    return apiPayload;
+  }
+}
+exports.default = Authenticator;

package/build/core/dataGenerator/authenticator/CookieAuthenticator.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cookieAuthConfig = require("./cookieAuthConfig.js");
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * CookieAuthenticator prepares the payload for cookie-based authentication.
+ * It extracts cookies from the browser page context and attaches them
+ * as cookieAuthHeaders in the account block for the data generator service.
+ */
+class CookieAuthenticator {
+  async constructPayload(apiPayload, actorInfo, page = null) {
+    if (!page) {
+      throw new _DataGeneratorError.AuthenticationError('Cookie authentication failed: "page" is required but was not provided');
+    }
+    const {
+      csrfHeaderName
+    } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+    const {
+      csrfToken,
+      cookieString
+    } = await _getCookies.call(CookieAuthenticator, page);
+    apiPayload.account.authHeaders = {
+      Cookie: cookieString,
+      [csrfHeaderName]: csrfToken
+    };
+    return apiPayload;
+  }
+}
+async function _getCookies(page) {
+  const {
+    csrfCookieName,
+    csrfParamName
+  } = _cookieAuthConfig.COOKIE_AUTH_CONFIG;
+  const context = page.context();
+  const pageUrl = new URL(page.url());
+  const currentDomain = pageUrl.hostname;
+  const cookies = await context.cookies([page.url()]);
+  const csrfCookies = cookies.filter(cookie => cookie.domain.includes(currentDomain) && cookie.name === csrfCookieName);
+  return {
+    csrfToken: csrfCookies.map(c => `${csrfParamName}=${c.value}`).join('; '),
+    cookieString: cookies.map(c => `${c.name}=${c.value}`).join('; ')
+  };
+}
+var _default = exports.default = CookieAuthenticator;

package/build/core/dataGenerator/authenticator/JWTauthenticator.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * JWTauthenticator constructs payload by fetching a JWT access token
+ * from the authenticator app and attaching it to the account.jwt config.
+ */
+class JWTauthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "account" is missing in actor configuration');
+    }
+    const jwtConf = account['jwt-oauth'];
+    if (!jwtConf) {
+      throw new _DataGeneratorError.AuthenticationError('JWT authentication failed: "jwt-oauth" is missing in actor configuration');
+    }
+
+    // Build payload for authenticator service
+    const userToken = encodeURIComponent((actorInfo === null || actorInfo === void 0 ? void 0 : actorInfo.email) || '');
+    const jwtAuthUrl = process.env.DG_JWT_AUTH_URL;
+    const responseType = jwtConf.response_type;
+    const clientId = jwtConf.client_id;
+    const tokenUrl = jwtConf.token_url;
+    const domainUrl = process.env.DG_DOMAIN_URL;
+    const authPayload = {
+      user_token: userToken,
+      jwt_secret: jwtConf.jwt_secret,
+      jwt_auth_url: jwtAuthUrl,
+      response_type: responseType,
+      client_id: clientId,
+      token_url: tokenUrl,
+      domain_url: domainUrl
+    };
+    const authenticatorApi = process.env.DG_JWT_AUTHENTICATOR_API;
+    const resp = await fetch(authenticatorApi, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(authPayload)
+    });
+    if (!resp.ok) {
+      const errorBody = await resp.text();
+      throw new Error(`JWT authenticator error! status: ${resp.status}, body: ${errorBody}`);
+    }
+    const json = await resp.json();
+    const accessToken = json === null || json === void 0 ? void 0 : json.access_token;
+    if (!accessToken) {
+      throw new Error('JWT authenticator did not return access_token');
+    }
+
+    // Attach access token to authHeaders so downstream API calls can use it directly
+    apiPayload.account = apiPayload.account || {};
+    apiPayload.account.authHeaders = apiPayload.account.authHeaders || {};
+    apiPayload.account.authHeaders.Authorization = `Zoho-oauthtoken ${accessToken}`;
+    return apiPayload;
+  }
+}
+var _default = exports.default = JWTauthenticator;

package/build/core/dataGenerator/authenticator/OAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OAuthAuthenticator prepares the payload for OAuth2-based authentication.
+ * It ensures oauth2 config is present in the account block so the
+ * data generator service can use it.
+ */
+class OAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.oauth2) {
+      throw new _DataGeneratorError.AuthenticationError('OAuth2 authentication failed: "oauth2" is missing in actor configuration');
+    }
+    apiPayload.account.oauth2 = account.oauth2;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OAuthAuthenticator;

package/build/core/dataGenerator/authenticator/OrgOAuthAuthenticator.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DataGeneratorError = require("../DataGeneratorError.js");
+/**
+ * OrgOAuthAuthenticator prepares the payload for org_oauth authentication.
+ * It ensures org_oauth config is present in the account block so the
+ * data generator service can use it.
+ */
+class OrgOAuthAuthenticator {
+  async constructPayload(apiPayload, actorInfo) {
+    const account = actorInfo['data-generator'].account;
+    if (!account) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "account" is missing in actor configuration');
+    }
+    if (!account.org_oauth) {
+      throw new _DataGeneratorError.AuthenticationError('OrgOAuth authentication failed: "org_oauth" is missing in actor configuration');
+    }
+    apiPayload.account.org_oauth = account.org_oauth;
+    return apiPayload;
+  }
+}
+var _default = exports.default = OrgOAuthAuthenticator;

package/build/core/dataGenerator/authenticator/cookieAuthConfig.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COOKIE_AUTH_CONFIG = void 0;
+const COOKIE_AUTH_CONFIG = exports.COOKIE_AUTH_CONFIG = {
+  csrfHeaderName: 'X-ZCSRF-TOKEN',
+  csrfCookieName: 'crmcsr',
+  csrfParamName: 'crmcsrfparam'
+};

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]) => {
-        let context = await browser.newContext();
-        let page = await context.newPage();
-        let ctxTestDetails = {
-          page,
+        const additionalContext = await browser.newContext();
+        const additionalPage = await additionalContext.newPage();
+        const ctxTestDetails = {
+          page: additionalPage,
           $tags,
-          context,
+          context: additionalContext,
           ...actorInfo
         };
-        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(context, testInfo, ctxTestDetails, actorInfo);
+        await (0, _loginDefaultStepsHelper.executeDefaultLoginSteps)(additionalContext, testInfo, ctxTestDetails, actorInfo);
         this.actorsObj[role] = {
           role,
           browser,
-          context,
-          page,
+          context: additionalContext,
+          page: additionalPage,
           executionContext: {
             actorInfo
           }
@@ -69,7 +69,10 @@ var _default = exports.default = {
   }, use, testInfo) => {
     const ctxObject = new ActorContext();
     await ctxObject.setup(browser, $tags, testInfo, context, page, executionContext);
-    await use(ctxObject);
-    await ctxObject.cleanup();
+    try {
+      await use(ctxObject);
+    } finally {
+      await ctxObject.cleanup();
+    }
   }
 };

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

@@ -1,13 +1,28 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
 var _readConfigFile = require("../readConfigFile");
+var _logCollector = require("../helpers/logCollector");
 const {
-  testSetup
+  testSetup,
+  uatDirectory,
+  browserLogs = {}
 } = (0, _readConfigFile.generateConfigFromFile)();
+
+// 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
 }) {
@@ -20,13 +35,37 @@ async function performDefaultContextSteps({
 var _default = exports.default = {
   context: async ({
     context
-  }, use) => {
+  }, use, testInfo) => {
     await context.addInitScript(() =>
     // eslint-disable-next-line no-undef
     window.localStorage.setItem('isDnBannerHide', true));
     await performDefaultContextSteps({
       context
     });
-    await use(context);
+    const collector = new _logCollector.LogCollector(browserLogs.limits);
+    collector.attachToContext(context);
+    testInfo.runtimeLogs = collector;
+    try {
+      await use(context);
+    } finally {
+      collector.detach();
+      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);
+      }
+      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,7 +32,6 @@ var _default = exports.default = {
     } finally {
       await (0, _loginDefaultStepsHelper.performDefaultPageSteps)(testDetails);
       await use(page);
-      await context.close();
     }
   }
 };

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

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LogCollector = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fileUtils = require("../../../utils/fileUtils");
+// Per-context Playwright runtime event collector — network failures,
+// console errors, page errors and crashes. Buffered in-memory and flushed
+// once per test via writeFileContents.
+
+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]
+};
+class LogCollector {
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...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({
+      ts: Date.now(),
+      ...evt
+    });
+  }
+  _shouldIgnore(url) {
+    return this.config.ignoreUrlPatterns.some(re => re.test(url));
+  }
+  _shouldIgnoreMessage(message) {
+    if (!message) {
+      return false;
+    }
+    return this.config.ignoreMessagePatterns.some(re => re.test(message));
+  }
+  _bind(target, event, handler) {
+    target.on(event, handler);
+    this._bound.push([target, event, handler]);
+  }
+  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',
+          status: res.status(),
+          method: res.request().method(),
+          url,
+          fromCache: res.fromServiceWorker()
+        });
+      }
+    });
+    this._bind(context, 'requestfailed', req => {
+      var _req$failure;
+      this.counts.failed++;
+      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,
+        resourceType: req.resourceType()
+      });
+    });
+  }
+  _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)) {
+        return;
+      }
+      this.counts.consoleError++;
+      this._push({
+        kind: 'console',
+        level: type,
+        text,
+        location: msg.location()
+      });
+    });
+    this._bind(page, 'pageerror', err => {
+      if (this._shouldIgnoreMessage(err.message)) {
+        return;
+      }
+      this.counts.pageError++;
+      this._push({
+        kind: 'pageerror',
+        name: err.name,
+        message: err.message,
+        stack: err.stack
+      });
+    });
+    this._bind(page, 'crash', () => {
+      this.counts.crash++;
+      this._push({
+        kind: 'crash',
+        url: page.url()
+      });
+    });
+  }
+  detach() {
+    for (const [target, event, handler] of this._bound) {
+      try {
+        target.removeListener(event, handler);
+      } catch {
+        // context may already be closed
+      }
+    }
+    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;
+    }
+    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;
+  }
+}
+exports.LogCollector = LogCollector;