@emesoft_company/playwright-core 2.1.0

package/dist/index.cjs

@@ -0,0 +1,1322 @@
+'use strict';
+
+var zod = require('zod');
+var fs = require('fs');
+var dotenv = require('dotenv');
+var test$1 = require('@playwright/test');
+var pino = require('pino');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+
+// src/errors/app-error.ts
+var AppError = class extends Error {
+  code;
+  context;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.code = options.code;
+    this.context = options.context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ConfigValidationError = class extends AppError {
+  constructor(message, issues, context) {
+    super(message, { code: "CONFIG_VALIDATION_ERROR", context: { issues, ...context } });
+  }
+};
+var ApiError = class extends AppError {
+  status;
+  method;
+  url;
+  constructor(message, options) {
+    super(message, options);
+    this.status = options.status;
+    this.method = options.method;
+    this.url = options.url;
+  }
+};
+var AuthError = class extends AppError {
+  constructor(message, options = {}) {
+    super(message, { code: "AUTH_ERROR", ...options });
+  }
+};
+var ConfigMissingError = class extends AppError {
+  constructor(name) {
+    super(`Required environment variable "${name}" is not set`, {
+      code: "ENV_VAR_MISSING",
+      context: { name }
+    });
+  }
+};
+
+// src/utils/deep-merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base2, override) {
+  if (override === void 0) return base2;
+  if (!isPlainObject(base2) || !isPlainObject(override)) {
+    return override;
+  }
+  const result = { ...base2 };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) continue;
+    const baseValue = base2[key];
+    result[key] = isPlainObject(baseValue) && isPlainObject(value) ? deepMerge(baseValue, value) : value;
+  }
+  return result;
+}
+function pruneUndefined(value) {
+  if (Array.isArray(value)) return value.map(pruneUndefined);
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      if (val === void 0) continue;
+      const pruned = pruneUndefined(val);
+      if (isPlainObject(pruned) && Object.keys(pruned).length === 0) continue;
+      result[key] = pruned;
+    }
+    return result;
+  }
+  return value;
+}
+var KNOWN_ENVIRONMENTS = ["local", "dev", "qa", "uat", "staging", "prod"];
+var EnvironmentSchema = zod.z.string().min(1);
+var TimeoutsSchema = zod.z.object({
+  actionMs: zod.z.number().int().positive().default(15e3),
+  navigationMs: zod.z.number().int().positive().default(3e4),
+  testMs: zod.z.number().int().positive().default(6e4),
+  /** Default budget for `waitForCondition` and other non-locator polling. */
+  waitMs: zod.z.number().int().positive().default(3e4)
+});
+var AuthConfigSchema = zod.z.object({
+  tokenUrl: zod.z.string().url().optional(),
+  clientId: zod.z.string().optional(),
+  clientSecret: zod.z.string().optional(),
+  username: zod.z.string().optional(),
+  password: zod.z.string().optional(),
+  /** Single-session storage state file (see `buildGlobalSetup`). */
+  storageStatePath: zod.z.string().optional(),
+  /** Directory used for per-role storage state files in multi-role setups. */
+  storageStateDir: zod.z.string().default(".auth")
+}).default({});
+var ReportingConfigSchema = zod.z.object({
+  allureEnabled: zod.z.boolean().default(false),
+  resultsDir: zod.z.string().default("allure-results"),
+  /** `{id}` is replaced with a test-case id — see `meta()` in `@emesoft_company/playwright-core/reporting`. */
+  testCaseUrlTemplate: zod.z.string().optional()
+}).default({});
+var RetryConfigSchema = zod.z.object({
+  retries: zod.z.number().int().min(0).default(2),
+  minDelayMs: zod.z.number().int().positive().default(200),
+  maxDelayMs: zod.z.number().int().positive().default(5e3)
+}).default({});
+var DiagnosticsConfigSchema = zod.z.object({
+  /** Collect browser console errors + failed requests and attach them to the report. */
+  enabled: zod.z.boolean().default(true),
+  /** Fail the test if the page logged a console error. Off by default — many apps are noisy. */
+  failOnConsoleError: zod.z.boolean().default(false),
+  /** Fail the test on an uncaught page exception. */
+  failOnPageError: zod.z.boolean().default(false),
+  /** Console messages matching any of these substrings are ignored entirely. */
+  ignoreConsolePatterns: zod.z.array(zod.z.string()).default([])
+}).default({});
+var AppConfigSchema = zod.z.object({
+  environment: EnvironmentSchema,
+  baseUrl: zod.z.string().url(),
+  apiBaseUrl: zod.z.string().url().optional(),
+  tenant: zod.z.string().optional(),
+  timeouts: TimeoutsSchema.default({}),
+  auth: AuthConfigSchema,
+  reporting: ReportingConfigSchema,
+  retry: RetryConfigSchema,
+  diagnostics: DiagnosticsConfigSchema,
+  logLevel: zod.z.enum(["fatal", "error", "warn", "info", "debug", "trace", "silent"]).default("info"),
+  custom: zod.z.record(zod.z.string(), zod.z.unknown()).default({})
+});
+
+// src/config/loader.ts
+function readEnvConfig(env) {
+  return {
+    environment: env.TEST_ENV ?? "dev",
+    baseUrl: env.BASE_URL,
+    apiBaseUrl: env.API_BASE_URL,
+    tenant: env.TENANT,
+    logLevel: env.LOG_LEVEL,
+    timeouts: {
+      actionMs: env.ACTION_TIMEOUT_MS ? Number(env.ACTION_TIMEOUT_MS) : void 0,
+      navigationMs: env.NAVIGATION_TIMEOUT_MS ? Number(env.NAVIGATION_TIMEOUT_MS) : void 0,
+      testMs: env.TEST_TIMEOUT_MS ? Number(env.TEST_TIMEOUT_MS) : void 0,
+      waitMs: env.WAIT_TIMEOUT_MS ? Number(env.WAIT_TIMEOUT_MS) : void 0
+    },
+    auth: {
+      tokenUrl: env.AUTH_TOKEN_URL,
+      clientId: env.AUTH_CLIENT_ID,
+      clientSecret: env.AUTH_CLIENT_SECRET,
+      username: env.AUTH_USERNAME,
+      password: env.AUTH_PASSWORD,
+      storageStatePath: env.AUTH_STORAGE_STATE_PATH,
+      storageStateDir: env.AUTH_STORAGE_STATE_DIR
+    },
+    reporting: {
+      allureEnabled: env.REPORT_ALLURE === "true",
+      resultsDir: env.ALLURE_RESULTS_DIR,
+      testCaseUrlTemplate: env.TEST_CASE_URL_TEMPLATE
+    },
+    retry: {
+      retries: env.RETRY_COUNT ? Number(env.RETRY_COUNT) : void 0,
+      minDelayMs: env.RETRY_MIN_DELAY_MS ? Number(env.RETRY_MIN_DELAY_MS) : void 0,
+      maxDelayMs: env.RETRY_MAX_DELAY_MS ? Number(env.RETRY_MAX_DELAY_MS) : void 0
+    },
+    diagnostics: {
+      enabled: env.DIAGNOSTICS === void 0 ? void 0 : env.DIAGNOSTICS !== "false",
+      failOnConsoleError: env.FAIL_ON_CONSOLE_ERROR === void 0 ? void 0 : env.FAIL_ON_CONSOLE_ERROR === "true",
+      failOnPageError: env.FAIL_ON_PAGE_ERROR === void 0 ? void 0 : env.FAIL_ON_PAGE_ERROR === "true"
+    }
+  };
+}
+function requireEnv(name, env = process.env) {
+  const value = env[name];
+  if (value === void 0 || value === "") {
+    throw new ConfigMissingError(name);
+  }
+  return value;
+}
+function loadConfig(options = {}) {
+  const { env = process.env, overrides } = options;
+  const fromEnv = pruneUndefined(readEnvConfig(env));
+  const merged = deepMerge(fromEnv, overrides);
+  const result = AppConfigSchema.safeParse(merged);
+  if (!result.success) {
+    throw new ConfigValidationError(
+      `Invalid application config: ${result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")}`,
+      result.error.issues
+    );
+  }
+  return result.data;
+}
+function loadEnvFiles(files, env = process.env) {
+  const merged = {};
+  const loaded = [];
+  for (const file of files) {
+    if (!fs.existsSync(file)) continue;
+    Object.assign(merged, dotenv.parse(fs.readFileSync(file)));
+    loaded.push(file);
+  }
+  const applied = [];
+  for (const [key, value] of Object.entries(merged)) {
+    if (env[key] === void 0) {
+      env[key] = value;
+      applied.push(key);
+    }
+  }
+  return { loaded, applied };
+}
+function defaultEnvFiles(environment) {
+  return [".env", ".env.local", `.env.${environment}`, `.env.${environment}.local`];
+}
+
+// src/reporting/allure-setup.ts
+function buildReporterConfig(config) {
+  const reporters = [["html", { open: "never" }]];
+  if (config.reporting.allureEnabled) {
+    reporters.push(["allure-playwright", { resultsDir: config.reporting.resultsDir, detail: true }]);
+  }
+  return reporters;
+}
+
+// src/config/define-config.ts
+function resolveEnvFiles(options, environment) {
+  if (options.envFile === false) return [];
+  if (typeof options.envFile === "string") return [options.envFile];
+  if (Array.isArray(options.envFile)) return options.envFile;
+  return defaultEnvFiles(environment);
+}
+function defineE2EConfig(options = {}) {
+  const environment = process.env.TEST_ENV ?? options.defaultEnvironment ?? "dev";
+  loadEnvFiles(resolveEnvFiles(options, environment));
+  const overrides = typeof options.configOverrides === "function" ? options.configOverrides() : options.configOverrides;
+  const appConfig = loadConfig({ overrides: deepMerge({ environment }, overrides) });
+  const browsers = options.browsers ?? ["chromium"];
+  const deviceByBrowser = {
+    chromium: "Desktop Chrome",
+    firefox: "Desktop Firefox",
+    webkit: "Desktop Safari"
+  };
+  const generated = {
+    testDir: options.testDir ?? "./tests",
+    fullyParallel: true,
+    retries: appConfig.retry.retries,
+    timeout: appConfig.timeouts.testMs,
+    reporter: buildReporterConfig(appConfig),
+    // `globalSetup` is only wired when a path is given AND a storage state path is configured —
+    // otherwise a project that hasn't set up login yet would fail on every run.
+    ...options.globalSetup && appConfig.auth.storageStatePath ? { globalSetup: options.globalSetup } : {},
+    ...options.globalTeardown ? { globalTeardown: options.globalTeardown } : {},
+    use: {
+      baseURL: appConfig.baseUrl,
+      actionTimeout: appConfig.timeouts.actionMs,
+      navigationTimeout: appConfig.timeouts.navigationMs,
+      trace: "on-first-retry",
+      screenshot: "only-on-failure",
+      ...options.globalSetup && appConfig.auth.storageStatePath ? { storageState: appConfig.auth.storageStatePath } : {}
+    },
+    projects: browsers.map((browser) => ({
+      name: browser,
+      use: { ...test$1.devices[deviceByBrowser[browser]] }
+    }))
+  };
+  return deepMerge(generated, options.playwright);
+}
+
+// src/auth/token-provider.ts
+var StaticTokenProvider = class {
+  constructor(token) {
+    this.token = token;
+  }
+  token;
+  async getToken() {
+    return this.token;
+  }
+  invalidate() {
+  }
+};
+var NullTokenProvider = class {
+  async getToken() {
+    return "";
+  }
+  invalidate() {
+  }
+};
+var JwtTokenProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  cached;
+  inFlight;
+  async getToken() {
+    if (this.cached && this.cached.expiresAt > Date.now()) {
+      return this.cached.token;
+    }
+    if (!this.inFlight) {
+      this.inFlight = this.fetchToken().finally(() => {
+        this.inFlight = void 0;
+      });
+    }
+    return this.inFlight;
+  }
+  invalidate() {
+    this.cached = void 0;
+  }
+  async fetchToken() {
+    const { tokenUrl, clientId, clientSecret, username, password, refreshSkewSeconds = 30, logger: logger2, fetchImpl = fetch } = this.options;
+    const body = new URLSearchParams();
+    if (username && password) {
+      body.set("grant_type", "password");
+      body.set("username", username);
+      body.set("password", password);
+    } else {
+      body.set("grant_type", "client_credentials");
+    }
+    if (clientId) body.set("client_id", clientId);
+    if (clientSecret) body.set("client_secret", clientSecret);
+    logger2?.debug({ tokenUrl }, "fetching auth token");
+    let response;
+    try {
+      response = await fetchImpl(tokenUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body
+      });
+    } catch (cause) {
+      throw new AuthError(`Failed to reach token endpoint ${tokenUrl}`, { cause });
+    }
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new AuthError(`Token endpoint returned ${response.status}: ${text}`, {
+        context: { status: response.status, tokenUrl }
+      });
+    }
+    const data = await response.json();
+    if (!data.access_token) {
+      throw new AuthError("Token endpoint response missing access_token", { context: { tokenUrl } });
+    }
+    const expiresInSeconds = data.expires_in ?? 300;
+    this.cached = {
+      token: data.access_token,
+      expiresAt: Date.now() + Math.max(expiresInSeconds - refreshSkewSeconds, 0) * 1e3
+    };
+    return this.cached.token;
+  }
+};
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/errors/retry.ts
+function backoffDelay(attempt, minDelayMs, maxDelayMs, factor) {
+  const exponential = minDelayMs * factor ** (attempt - 1);
+  const jitter = Math.random() * minDelayMs;
+  return Math.min(exponential + jitter, maxDelayMs);
+}
+async function withRetry(fn, options = {}) {
+  const {
+    retries = 2,
+    minDelayMs = 200,
+    maxDelayMs = 5e3,
+    factor = 2,
+    retryOn = () => true,
+    onRetry,
+    onGiveUp
+  } = options;
+  const maxAttempts = retries + 1;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const isLastAttempt = attempt >= maxAttempts;
+      if (isLastAttempt || !retryOn(error)) {
+        onGiveUp?.(error, attempt);
+        throw error;
+      }
+      onRetry?.(error, attempt);
+      await sleep(backoffDelay(attempt, minDelayMs, maxDelayMs, factor));
+    }
+  }
+  throw new Error("withRetry: unreachable state");
+}
+
+// src/api/interceptors.ts
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500 && status <= 599;
+}
+
+// src/api/api-client.ts
+var TransientHttpError = class extends Error {
+  constructor(status) {
+    super(`Transient HTTP status ${status}`);
+    this.status = status;
+  }
+  status;
+};
+var ApiClient = class {
+  request;
+  baseUrl;
+  tokenProvider;
+  logger;
+  retryOptions;
+  defaultHeaders;
+  interceptors;
+  constructor(options) {
+    this.request = options.request;
+    this.baseUrl = options.baseUrl;
+    this.tokenProvider = options.tokenProvider ?? new NullTokenProvider();
+    this.logger = options.logger;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+    this.interceptors = options.interceptors ?? {};
+    this.retryOptions = { ...options.retry };
+  }
+  get(path, options) {
+    return this.requestBody("GET", path, options);
+  }
+  post(path, options) {
+    return this.requestBody("POST", path, options);
+  }
+  put(path, options) {
+    return this.requestBody("PUT", path, options);
+  }
+  patch(path, options) {
+    return this.requestBody("PATCH", path, options);
+  }
+  delete(path, options) {
+    return this.requestBody("DELETE", path, options);
+  }
+  /**
+   * Full response including status and headers. Retries transient statuses, then returns
+   * whatever came back — a 404 or 500 is a normal return value here, not an exception.
+   * Network/timeout failures still throw.
+   */
+  async send(method, path, options = {}) {
+    const url = this.resolveUrl(path, options.params);
+    let lastResponse;
+    try {
+      await withRetry(
+        async () => {
+          lastResponse = await this.fetchOnce(method, url, options);
+          if (isRetryableStatus(lastResponse.status) && !this.isExpectedStatus(lastResponse.status, options)) {
+            throw new TransientHttpError(lastResponse.status);
+          }
+        },
+        {
+          ...this.retryOptions,
+          retryOn: (error) => error instanceof TransientHttpError,
+          onRetry: (error, attempt) => this.logger?.warn({ method, url, attempt, err: error }, "retrying API request")
+        }
+      );
+    } catch (error) {
+      if (!(error instanceof TransientHttpError)) throw error;
+    }
+    if (!lastResponse) {
+      throw new AppError(`API request produced no response: ${method} ${url}`, {
+        code: "API_NO_RESPONSE",
+        context: { method, url }
+      });
+    }
+    return lastResponse;
+  }
+  async requestBody(method, path, options = {}) {
+    const response = await this.send(method, path, options);
+    if (!this.isExpectedStatus(response.status, options)) {
+      if (response.status === 401) this.tokenProvider.invalidate();
+      this.logger?.error(
+        { status: response.status, method, url: response.url, body: response.data },
+        "API request failed"
+      );
+      throw new ApiError(
+        `API request failed: ${method} ${response.url} -> ${response.status}` + (options.expectStatus === void 0 ? "" : ` (expected ${String(options.expectStatus)})`),
+        {
+          code: "API_REQUEST_FAILED",
+          status: response.status,
+          method,
+          url: response.url,
+          context: { body: response.data }
+        }
+      );
+    }
+    return response.data;
+  }
+  isExpectedStatus(status, options) {
+    if (options.expectStatus === void 0) return status >= 200 && status < 300;
+    const expected = Array.isArray(options.expectStatus) ? options.expectStatus : [options.expectStatus];
+    return expected.includes(status);
+  }
+  async fetchOnce(method, url, options) {
+    const headers = await this.buildHeaders(method, url, options);
+    const response = await this.request.fetch(url, {
+      method,
+      headers,
+      data: options.data,
+      form: options.form,
+      multipart: options.multipart,
+      timeout: options.timeoutMs
+    });
+    await this.interceptors.onResponse?.({ method, url, status: response.status() });
+    return {
+      status: response.status(),
+      ok: response.ok(),
+      headers: response.headers(),
+      data: await this.parseBody(response, options),
+      url,
+      method
+    };
+  }
+  resolveUrl(path, params) {
+    const base2 = this.baseUrl ? new URL(path, this.baseUrl).toString() : path;
+    if (!params) return base2;
+    const url = new URL(base2);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  async buildHeaders(method, url, options) {
+    let headers = { ...this.defaultHeaders, ...options.headers };
+    if (!options.skipAuth) {
+      const token = await this.tokenProvider.getToken();
+      if (token) headers = { ...headers, Authorization: `Bearer ${token}` };
+    }
+    const overridden = await this.interceptors.onRequest?.({ method, url, headers });
+    return overridden ?? headers;
+  }
+  async parseBody(response, options) {
+    const raw = await this.readBody(response);
+    if (!options.schema) return raw;
+    const result = options.schema.safeParse(raw);
+    if (!result.success) {
+      throw new ApiError(`API response did not match the expected schema: ${response.url()}`, {
+        code: "API_SCHEMA_MISMATCH",
+        status: response.status(),
+        url: response.url(),
+        context: { issues: result.error.issues, body: raw }
+      });
+    }
+    return result.data;
+  }
+  async readBody(response) {
+    const contentType = response.headers()["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+      const text = await response.text();
+      if (text.trim() === "") return void 0;
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    return response.text();
+  }
+};
+function createLogger(options = {}) {
+  const {
+    level = process.env.LOG_LEVEL ?? "info",
+    name = "playwright-core",
+    pretty = process.env.LOG_PRETTY === "true"
+  } = options;
+  return pino__default.default({
+    name,
+    level,
+    ...pretty ? {
+      transport: {
+        target: "pino-pretty",
+        options: { colorize: true, translateTime: "SYS:standard" }
+      }
+    } : {}
+  });
+}
+var logger = createLogger();
+
+// src/reporting/meta.ts
+function toArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function meta(options) {
+  const tags = toArray(options.tag).map((tag) => tag.startsWith("@") ? tag : `@${tag}`);
+  const testCaseAnnotations = toArray(options.testCase).map((id) => ({
+    type: "testCase",
+    description: id
+  }));
+  const annotation = [...testCaseAnnotations, ...options.annotation ?? []];
+  return {
+    ...tags.length > 0 ? { tag: tags } : {},
+    ...annotation.length > 0 ? { annotation } : {}
+  };
+}
+function linkTestCases(testInfo, urlTemplate) {
+  if (!urlTemplate) return;
+  for (const annotation of testInfo.annotations) {
+    if (annotation.type === "testCase" && annotation.description) {
+      annotation.description = urlTemplate.replace("{id}", annotation.description);
+    }
+  }
+}
+
+// src/fixtures/auth.fixture.ts
+function resolveTokenProvider(config, logger2) {
+  const { auth } = config;
+  if (auth.tokenUrl) {
+    return new JwtTokenProvider({
+      tokenUrl: auth.tokenUrl,
+      clientId: auth.clientId,
+      clientSecret: auth.clientSecret,
+      username: auth.username,
+      password: auth.password,
+      logger: logger2
+    });
+  }
+  return new NullTokenProvider();
+}
+
+// src/reporting/attachments.ts
+async function attachText(testInfo, name, body) {
+  await testInfo.attach(name, { body, contentType: "text/plain" });
+}
+async function attachJson(testInfo, name, value) {
+  await testInfo.attach(name, {
+    body: JSON.stringify(value, null, 2),
+    contentType: "application/json"
+  });
+}
+async function attachScreenshot(testInfo, name, buffer) {
+  await testInfo.attach(name, { body: buffer, contentType: "image/png" });
+}
+
+// src/fixtures/diagnostics.fixture.ts
+function collectDiagnostics(page, config) {
+  const collected = { consoleErrors: [], pageErrors: [], failedRequests: [] };
+  const isIgnored = (text) => config.ignoreConsolePatterns.some((pattern) => text.includes(pattern));
+  page.on("console", (message) => {
+    if (message.type() !== "error") return;
+    const text = message.text();
+    if (!isIgnored(text)) collected.consoleErrors.push(text);
+  });
+  page.on("pageerror", (error) => {
+    collected.pageErrors.push(error.message);
+  });
+  page.on("requestfailed", (request) => {
+    collected.failedRequests.push(
+      `${request.method()} ${request.url()} \u2014 ${request.failure()?.errorText ?? "failed"}`
+    );
+  });
+  const report = async (testInfo) => {
+    if (collected.consoleErrors.length > 0) {
+      await attachText(testInfo, "console-errors", collected.consoleErrors.join("\n"));
+    }
+    if (collected.pageErrors.length > 0) {
+      await attachText(testInfo, "page-errors", collected.pageErrors.join("\n"));
+    }
+    if (collected.failedRequests.length > 0) {
+      await attachText(testInfo, "failed-requests", collected.failedRequests.join("\n"));
+    }
+    if (testInfo.status !== "passed") return;
+    if (config.failOnPageError && collected.pageErrors.length > 0) {
+      throw new Error(`Uncaught page error(s):
+${collected.pageErrors.join("\n")}`);
+    }
+    if (config.failOnConsoleError && collected.consoleErrors.length > 0) {
+      throw new Error(`Console error(s):
+${collected.consoleErrors.join("\n")}`);
+    }
+  };
+  return { collected, report };
+}
+var expect = test$1.expect.extend({
+  /**
+   * Asserts the status of an `ApiResponse` from `apiClient.send()`, printing the body on
+   * failure — otherwise a wrong status tells you nothing about why.
+   */
+  toHaveStatus(received, expected) {
+    const pass = received.status === expected;
+    return {
+      pass,
+      name: "toHaveStatus",
+      expected,
+      actual: received.status,
+      message: () => pass ? `Expected status not to be ${expected}` : `Expected ${received.method} ${received.url} to return ${expected}, got ${received.status}
+Body: ${JSON.stringify(received.data, null, 2)}`
+    };
+  },
+  /** Asserts a value matches a zod schema, listing the exact field-level issues on failure. */
+  toMatchSchema(received, schema) {
+    const result = schema.safeParse(received);
+    return {
+      pass: result.success,
+      name: "toMatchSchema",
+      message: () => result.success ? "Expected value not to match the schema" : `Value did not match the schema:
+${result.error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n")}`
+    };
+  }
+});
+
+// src/fixtures/base-test.ts
+var test = test$1.test.extend({
+  workerConfig: [
+    async ({}, use) => {
+      await use(loadConfig());
+    },
+    { scope: "worker" }
+  ],
+  appConfig: async ({ workerConfig }, use) => {
+    await use(workerConfig);
+  },
+  logger: async ({ appConfig }, use, testInfo) => {
+    await use(createLogger({ level: appConfig.logLevel, name: testInfo.title }));
+  },
+  tokenProvider: async ({ appConfig, logger: logger2 }, use) => {
+    await use(resolveTokenProvider(appConfig, logger2));
+  },
+  apiClient: async ({ appConfig, tokenProvider, logger: logger2, request }, use) => {
+    await use(
+      new ApiClient({
+        request,
+        baseUrl: appConfig.apiBaseUrl ?? appConfig.baseUrl,
+        tokenProvider,
+        logger: logger2,
+        retry: {
+          retries: appConfig.retry.retries,
+          minDelayMs: appConfig.retry.minDelayMs,
+          maxDelayMs: appConfig.retry.maxDelayMs
+        }
+      })
+    );
+  },
+  retry: async ({ logger: logger2 }, use) => {
+    const boundRetry = (fn, options) => withRetry(fn, {
+      onRetry: (error, attempt) => logger2.warn({ err: error, attempt }, "retrying operation"),
+      ...options
+    });
+    await use(boundRetry);
+  },
+  cleanup: async ({ logger: logger2 }, use) => {
+    const tasks = [];
+    await use((task) => {
+      tasks.push(task);
+    });
+    for (const task of tasks.reverse()) {
+      try {
+        await task();
+      } catch (error) {
+        logger2.error({ err: error }, "cleanup task failed");
+      }
+    }
+  },
+  // Overriding `page` (instead of an auto fixture) keeps API-only tests from launching a
+  // browser: the override only runs for tests that actually request a page.
+  page: async ({ page, appConfig }, use, testInfo) => {
+    if (!appConfig.diagnostics.enabled) {
+      await use(page);
+      return;
+    }
+    const diagnostics = collectDiagnostics(page, appConfig.diagnostics);
+    await use(page);
+    await diagnostics.report(testInfo);
+  },
+  // testInfo-only, so this is safe to run automatically for every test.
+  _testCaseLinks: [
+    async ({ appConfig }, use, testInfo) => {
+      linkTestCases(testInfo, appConfig.reporting.testCaseUrlTemplate);
+      await use();
+    },
+    { auto: true }
+  ]
+});
+function roleStorageState(role, storageStateDir = process.env.AUTH_STORAGE_STATE_DIR ?? ".auth") {
+  return path.join(storageStateDir, `${role}.json`);
+}
+function buildGlobalSetup(options) {
+  if (!options.login && !options.roles) {
+    throw new AppError("buildGlobalSetup requires either `login` or `roles`", {
+      code: "GLOBAL_SETUP_NO_LOGIN"
+    });
+  }
+  return async function globalSetup() {
+    const config = loadConfig({ overrides: options.configOverrides });
+    const sessions = resolveSessions(options, config);
+    const browser = await test$1.chromium.launch(options.launchOptions);
+    try {
+      for (const session of sessions) {
+        fs.mkdirSync(path.dirname(session.storageStatePath), { recursive: true });
+        const context = await browser.newContext({
+          baseURL: config.baseUrl,
+          ...session.contextOptions ?? options.contextOptions
+        });
+        try {
+          const page = await context.newPage();
+          await session.login(page, config);
+          await context.storageState({ path: session.storageStatePath });
+        } finally {
+          await context.close();
+        }
+      }
+    } finally {
+      await browser.close();
+    }
+  };
+}
+function resolveSessions(options, config) {
+  if (options.roles) {
+    return Object.entries(options.roles).map(([role, setup]) => ({
+      login: setup.login,
+      storageStatePath: setup.storageStatePath ?? roleStorageState(role, config.auth.storageStateDir),
+      contextOptions: setup.contextOptions
+    }));
+  }
+  const storageStatePath = config.auth.storageStatePath;
+  if (!storageStatePath) {
+    throw new AppError(
+      "buildGlobalSetup requires `auth.storageStatePath` to be set (env AUTH_STORAGE_STATE_PATH or a config override) when using single-session `login`",
+      { code: "MISSING_STORAGE_STATE_PATH" }
+    );
+  }
+  return [{ login: options.login, storageStatePath }];
+}
+
+// src/ui/actions.ts
+async function waitForVisible(locator, timeoutMs) {
+  await locator.waitFor({ state: "visible", timeout: timeoutMs });
+}
+async function safeClick(locator, timeoutMs) {
+  await waitForVisible(locator, timeoutMs);
+  await locator.click();
+}
+async function safeDoubleClick(locator, timeoutMs) {
+  await waitForVisible(locator, timeoutMs);
+  await locator.dblclick();
+}
+async function safeFill(locator, value, timeoutMs) {
+  await waitForVisible(locator, timeoutMs);
+  await locator.fill(value);
+}
+async function safeType(locator, value, delayMs = 0) {
+  await waitForVisible(locator);
+  await locator.fill("");
+  await locator.pressSequentially(value, { delay: delayMs });
+}
+async function safeSelect(locator, value) {
+  await waitForVisible(locator);
+  await locator.selectOption(value);
+}
+async function safeCheck(locator, checked = true) {
+  await waitForVisible(locator);
+  if (checked) await locator.check();
+  else await locator.uncheck();
+}
+async function uploadFile(locator, files) {
+  await locator.setInputFiles(files);
+}
+async function scrollIntoView(locator) {
+  await locator.scrollIntoViewIfNeeded();
+}
+async function getText(locator) {
+  return (await locator.textContent())?.trim() ?? "";
+}
+async function getAllTexts(locator) {
+  const texts = await locator.allTextContents();
+  return texts.map((text) => text.trim());
+}
+async function getInputValue(locator) {
+  return locator.inputValue();
+}
+async function exists(locator) {
+  return await locator.count() > 0;
+}
+async function fillFields(page, fields, options = {}) {
+  const resolve = options.resolve ?? ((selector) => page.locator(selector));
+  for (const [selector, value] of Object.entries(fields)) {
+    const locator = resolve(selector);
+    if (typeof value === "boolean") {
+      await safeCheck(locator, value);
+    } else {
+      await safeFill(locator, String(value));
+    }
+  }
+}
+
+// src/ui/components/base-page.ts
+var BasePage = class {
+  page;
+  baseUrl;
+  logger;
+  constructor(options) {
+    this.page = options.page;
+    this.baseUrl = options.baseUrl;
+    this.logger = options.logger;
+  }
+  /** Absolute URL for this page, with optional path override and query string. */
+  url(options = {}) {
+    const path = options.path ?? this.path;
+    const url = this.baseUrl ? new URL(path, this.baseUrl) : new URL(path, "http://localhost");
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) url.searchParams.set(key, String(value));
+      }
+    }
+    return this.baseUrl ? url.toString() : `${url.pathname}${url.search}`;
+  }
+  async goto(options = {}) {
+    const url = this.url(options);
+    this.logger?.debug({ url }, "navigating");
+    return this.page.goto(url, options.waitUntil ? { waitUntil: options.waitUntil } : void 0);
+  }
+  async reload() {
+    await this.page.reload();
+  }
+  currentUrl() {
+    return this.page.url();
+  }
+  async waitForUrl(url, timeoutMs) {
+    await this.page.waitForURL(url, timeoutMs ? { timeout: timeoutMs } : void 0);
+  }
+  async waitForLoadState(state = "load") {
+    await this.page.waitForLoadState(state);
+  }
+  /**
+   * Waits for network activity to settle. Prefer waiting on a specific element when you can —
+   * `networkidle` is discouraged by Playwright for apps that poll or hold sockets open.
+   */
+  async waitForNetworkIdle(timeoutMs) {
+    await this.page.waitForLoadState("networkidle", timeoutMs ? { timeout: timeoutMs } : void 0);
+  }
+  async pressKey(key) {
+    await this.page.keyboard.press(key);
+  }
+  /**
+   * Screenshot as a buffer. Pair with `attachScreenshot()` from
+   * `@emesoft_company/playwright-core/reporting` to put it in the HTML/Allure report.
+   */
+  async screenshot(fullPage = false) {
+    return this.page.screenshot({ fullPage, caret: "hide" });
+  }
+  // --- locator helpers, delegated to the shared actions so components behave identically ---
+  waitForVisible(locator, timeoutMs) {
+    return waitForVisible(locator, timeoutMs);
+  }
+  async safeClick(locator, timeoutMs) {
+    await safeClick(locator, timeoutMs);
+  }
+  async safeFill(locator, value) {
+    await safeFill(locator, value);
+  }
+  async safeType(locator, value, delayMs) {
+    await safeType(locator, value, delayMs);
+  }
+  async safeSelect(locator, value) {
+    await safeSelect(locator, value);
+  }
+  async safeCheck(locator, checked = true) {
+    await safeCheck(locator, checked);
+  }
+  async uploadFile(locator, files) {
+    await uploadFile(locator, files);
+  }
+  async scrollIntoView(locator) {
+    await scrollIntoView(locator);
+  }
+  async getText(locator) {
+    return getText(locator);
+  }
+  async getAllTexts(locator) {
+    return getAllTexts(locator);
+  }
+  /** Fills a form from a `{ selector: value }` map. Booleans check/uncheck. */
+  async fillFields(fields) {
+    await fillFields(this.page, fields);
+  }
+};
+
+// src/ui/components/base-component.ts
+var BaseComponent = class {
+  page;
+  root;
+  constructor(options) {
+    this.page = options.page;
+    this.root = options.root;
+  }
+  // --- scoped lookups ---
+  byTestId(testId) {
+    return this.root.getByTestId(testId);
+  }
+  byRole(...args) {
+    return this.root.getByRole(...args);
+  }
+  byText(...args) {
+    return this.root.getByText(...args);
+  }
+  byLabel(...args) {
+    return this.root.getByLabel(...args);
+  }
+  locator(selector) {
+    return this.root.locator(selector);
+  }
+  // --- state ---
+  async isVisible() {
+    return this.root.isVisible();
+  }
+  async exists() {
+    return exists(this.root);
+  }
+  async text() {
+    return getText(this.root);
+  }
+  async waitForStable(timeoutMs) {
+    await waitForVisible(this.root, timeoutMs);
+  }
+  async waitForHidden(timeoutMs) {
+    await this.root.waitFor({ state: "hidden", timeout: timeoutMs });
+  }
+  // --- actions, same implementations BasePage uses ---
+  async safeClick(locator, timeoutMs) {
+    await safeClick(locator, timeoutMs);
+  }
+  async safeFill(locator, value) {
+    await safeFill(locator, value);
+  }
+  async safeSelect(locator, value) {
+    await safeSelect(locator, value);
+  }
+  async safeCheck(locator, checked = true) {
+    await safeCheck(locator, checked);
+  }
+  async scrollIntoView(locator = this.root) {
+    await scrollIntoView(locator);
+  }
+  async getText(locator) {
+    return getText(locator);
+  }
+  async getAllTexts(locator) {
+    return getAllTexts(locator);
+  }
+  /** Fills fields *within this component*, so selectors don't collide with the rest of the page. */
+  async fillFields(fields) {
+    await fillFields(this.page, fields, { resolve: (selector) => this.root.locator(selector) });
+  }
+};
+
+// src/ui/components/table.component.ts
+var TableComponent = class extends BaseComponent {
+  headerSelector;
+  rowSelector;
+  cellSelector;
+  constructor(options) {
+    super(options);
+    this.headerSelector = options.headerSelector ?? "thead th";
+    this.rowSelector = options.rowSelector ?? "tbody tr";
+    this.cellSelector = options.cellSelector ?? "td";
+  }
+  /** All data rows. A live locator — safe to use with auto-retrying assertions. */
+  get rows() {
+    return this.root.locator(this.rowSelector);
+  }
+  get headerCells() {
+    return this.root.locator(this.headerSelector);
+  }
+  row(index) {
+    return this.rows.nth(index);
+  }
+  cells(rowIndex) {
+    return this.row(rowIndex).locator(this.cellSelector);
+  }
+  async rowCount() {
+    return this.rows.count();
+  }
+  async isEmpty() {
+    return await this.rowCount() === 0;
+  }
+  /** Trimmed header labels, in order. */
+  async headers() {
+    return getAllTexts(this.headerCells);
+  }
+  /**
+   * Zero-based index of a column by its header label (exact match after trimming, falling back
+   * to a case-insensitive contains match). Throws listing the available headers when not found —
+   * a renamed column is otherwise a confusing "cell is empty" failure.
+   */
+  async columnIndex(header) {
+    const headers = await this.headers();
+    const exact = headers.indexOf(header.trim());
+    if (exact !== -1) return exact;
+    const needle = header.trim().toLowerCase();
+    const loose = headers.findIndex((candidate) => candidate.toLowerCase().includes(needle));
+    if (loose !== -1) return loose;
+    throw new AppError(`Column "${header}" not found in table`, {
+      code: "TABLE_COLUMN_NOT_FOUND",
+      context: { requested: header, available: headers }
+    });
+  }
+  /** A cell by row index and either a column index or a header label. */
+  async cell(rowIndex, column) {
+    const index = typeof column === "number" ? column : await this.columnIndex(column);
+    return this.cells(rowIndex).nth(index);
+  }
+  async cellText(rowIndex, column) {
+    return getText(await this.cell(rowIndex, column));
+  }
+  /** Every cell value of one row, in column order. */
+  async rowValues(rowIndex) {
+    return getAllTexts(this.cells(rowIndex));
+  }
+  /**
+   * The whole table as `{ header: cellText }` objects — the most convenient shape for
+   * assertions (`expect(await table.records()).toContainEqual({ Status: "Approved", ... })`).
+   */
+  async records() {
+    const headers = await this.headers();
+    const count = await this.rowCount();
+    const records = [];
+    for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+      const values = await this.rowValues(rowIndex);
+      const record = {};
+      values.forEach((value, columnIndex) => {
+        record[headers[columnIndex] ?? `column${columnIndex}`] = value;
+      });
+      records.push(record);
+    }
+    return records;
+  }
+  /** Rows containing `text` anywhere. Still a locator, so assertions on it auto-retry. */
+  rowsContaining(text) {
+    return this.rows.filter({ hasText: text });
+  }
+  /**
+   * Rows whose cell in a given column matches `value`. Returns a locator (auto-retrying);
+   * only the header lookup is awaited up front.
+   */
+  async rowsByColumn(column, value) {
+    const index = typeof column === "number" ? column : await this.columnIndex(column);
+    return this.rows.filter({
+      has: this.page.locator(`${this.cellSelector}:nth-child(${index + 1})`).filter({ hasText: value })
+    });
+  }
+  /** Waits until the table has at least `min` rows (default 1) — e.g. after a search or load. */
+  async waitForRows(min = 1, timeoutMs = 15e3) {
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      if (await this.rowCount() >= min) return;
+      if (Date.now() >= deadline) {
+        throw new AppError(`Table did not reach ${min} row(s) within ${timeoutMs}ms`, {
+          code: "TABLE_ROWS_TIMEOUT",
+          context: { min, timeoutMs, actual: await this.rowCount() }
+        });
+      }
+      await this.page.waitForTimeout(200);
+    }
+  }
+};
+
+// src/di/container.ts
+var ServiceContainer = class {
+  factories = /* @__PURE__ */ new Map();
+  singletons = /* @__PURE__ */ new Map();
+  register(key, factory) {
+    this.factories.set(key, factory);
+    this.singletons.delete(key);
+  }
+  /** Replaces an existing registration — this is how a project overrides a core-provided service. */
+  override(key, factory) {
+    this.register(key, factory);
+  }
+  resolve(key) {
+    if (this.singletons.has(key)) {
+      return this.singletons.get(key);
+    }
+    const factory = this.factories.get(key);
+    if (!factory) {
+      throw new AppError(`No provider registered for service "${key}"`, { code: "DI_UNRESOLVED" });
+    }
+    const instance = factory(this);
+    this.singletons.set(key, instance);
+    return instance;
+  }
+  has(key) {
+    return this.factories.has(key);
+  }
+};
+
+// src/utils/wait.ts
+async function waitForCondition(predicate, options = {}) {
+  const { timeoutMs = 3e4, intervalMs = 500, message = "Condition was not met within timeout" } = options;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (await predicate()) return;
+    if (Date.now() >= deadline) {
+      throw new AppError(message, { code: "WAIT_TIMEOUT", context: { timeoutMs, intervalMs } });
+    }
+    await sleep(intervalMs);
+  }
+}
+
+// src/data/generators.ts
+var counter = 0;
+var ALPHANUMERIC = "abcdefghijklmnopqrstuvwxyz0123456789";
+function uniqueId(prefix) {
+  counter += 1;
+  const id = `${Date.now().toString(36)}${process.pid.toString(36)}${counter.toString(36)}`;
+  return prefix ? `${prefix}-${id}` : id;
+}
+function uniqueEmail(domain = "example.test", prefix = "qa") {
+  return `${prefix}-${uniqueId()}@${domain}`;
+}
+function randomString(length = 8, charset = ALPHANUMERIC) {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+}
+function randomInt(min, max) {
+  if (min > max) throw new RangeError(`randomInt: min (${min}) must be <= max (${max})`);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomBool() {
+  return Math.random() < 0.5;
+}
+function pickOne(items) {
+  if (items.length === 0) throw new RangeError("pickOne: cannot pick from an empty array");
+  return items[randomInt(0, items.length - 1)];
+}
+function pickSome(items, count) {
+  if (count > items.length) {
+    throw new RangeError(`pickSome: cannot pick ${count} items from an array of ${items.length}`);
+  }
+  const pool = [...items];
+  const picked = [];
+  for (let i = 0; i < count; i++) {
+    const [item] = pool.splice(randomInt(0, pool.length - 1), 1);
+    picked.push(item);
+  }
+  return picked;
+}
+function isoDate(dayOffset = 0, from = /* @__PURE__ */ new Date()) {
+  const date = new Date(from);
+  date.setDate(date.getDate() + dayOffset);
+  return date.toISOString().slice(0, 10);
+}
+
+exports.ApiClient = ApiClient;
+exports.ApiError = ApiError;
+exports.AppConfigSchema = AppConfigSchema;
+exports.AppError = AppError;
+exports.AuthConfigSchema = AuthConfigSchema;
+exports.AuthError = AuthError;
+exports.BaseComponent = BaseComponent;
+exports.BasePage = BasePage;
+exports.ConfigMissingError = ConfigMissingError;
+exports.ConfigValidationError = ConfigValidationError;
+exports.DiagnosticsConfigSchema = DiagnosticsConfigSchema;
+exports.EnvironmentSchema = EnvironmentSchema;
+exports.JwtTokenProvider = JwtTokenProvider;
+exports.KNOWN_ENVIRONMENTS = KNOWN_ENVIRONMENTS;
+exports.NullTokenProvider = NullTokenProvider;
+exports.ReportingConfigSchema = ReportingConfigSchema;
+exports.RetryConfigSchema = RetryConfigSchema;
+exports.ServiceContainer = ServiceContainer;
+exports.StaticTokenProvider = StaticTokenProvider;
+exports.TableComponent = TableComponent;
+exports.TimeoutsSchema = TimeoutsSchema;
+exports.attachJson = attachJson;
+exports.attachScreenshot = attachScreenshot;
+exports.attachText = attachText;
+exports.buildGlobalSetup = buildGlobalSetup;
+exports.buildReporterConfig = buildReporterConfig;
+exports.collectDiagnostics = collectDiagnostics;
+exports.createLogger = createLogger;
+exports.deepMerge = deepMerge;
+exports.defaultEnvFiles = defaultEnvFiles;
+exports.defineE2EConfig = defineE2EConfig;
+exports.exists = exists;
+exports.expect = expect;
+exports.fillFields = fillFields;
+exports.getAllTexts = getAllTexts;
+exports.getInputValue = getInputValue;
+exports.getText = getText;
+exports.isPlainObject = isPlainObject;
+exports.isRetryableStatus = isRetryableStatus;
+exports.isoDate = isoDate;
+exports.linkTestCases = linkTestCases;
+exports.loadConfig = loadConfig;
+exports.loadEnvFiles = loadEnvFiles;
+exports.logger = logger;
+exports.meta = meta;
+exports.pickOne = pickOne;
+exports.pickSome = pickSome;
+exports.pruneUndefined = pruneUndefined;
+exports.randomBool = randomBool;
+exports.randomInt = randomInt;
+exports.randomString = randomString;
+exports.requireEnv = requireEnv;
+exports.resolveTokenProvider = resolveTokenProvider;
+exports.roleStorageState = roleStorageState;
+exports.safeCheck = safeCheck;
+exports.safeClick = safeClick;
+exports.safeDoubleClick = safeDoubleClick;
+exports.safeFill = safeFill;
+exports.safeSelect = safeSelect;
+exports.safeType = safeType;
+exports.scrollIntoView = scrollIntoView;
+exports.sleep = sleep;
+exports.test = test;
+exports.uniqueEmail = uniqueEmail;
+exports.uniqueId = uniqueId;
+exports.uploadFile = uploadFile;
+exports.waitForCondition = waitForCondition;
+exports.waitForVisible = waitForVisible;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map