@testdino/playwright 1.0.1

package/dist/index.js

@@ -0,0 +1,2695 @@
+'use strict';
+
+var crypto = require('crypto');
+var fs = require('fs');
+var WebSocket = require('ws');
+var axios = require('axios');
+var promises = require('fs/promises');
+var execa = require('execa');
+var os = require('os');
+var process$1 = require('process');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/reporter/errors.ts
+var TestDinoServerError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "TestDinoServerError";
+    this.code = code;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var QuotaExhaustedError = class extends TestDinoServerError {
+  details;
+  constructor(message, details) {
+    super("QUOTA_EXHAUSTED", message);
+    this.name = "QuotaExhaustedError";
+    this.details = details;
+  }
+};
+var QuotaExceededError = class extends TestDinoServerError {
+  details;
+  constructor(message, details) {
+    super("QUOTA_EXCEEDED", message);
+    this.name = "QuotaExceededError";
+    this.details = details;
+  }
+};
+function isServerError(error) {
+  return error instanceof TestDinoServerError;
+}
+function isQuotaError(error) {
+  return error instanceof QuotaExhaustedError || error instanceof QuotaExceededError;
+}
+
+// src/streaming/websocket.ts
+var HANDSHAKE_TIMEOUT_MS = 1e4;
+var WebSocketClient = class {
+  ws = null;
+  options;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  isConnecting = false;
+  isClosed = false;
+  pingInterval = null;
+  constructor(options) {
+    this.options = {
+      sessionId: "",
+      maxRetries: 5,
+      retryDelay: 1e3,
+      onConnected: () => {
+      },
+      onDisconnected: () => {
+      },
+      onError: () => {
+      },
+      ...options
+    };
+  }
+  /**
+   * Establish WebSocket connection.
+   * Resolves only after the server sends its 'connected' handshake message,
+   * guaranteeing the server's message handler is registered before events are sent.
+   * Passes sessionId from HTTP auth so the server reuses the existing session.
+   */
+  async connect() {
+    if (this.isConnecting || this.ws?.readyState === WebSocket__default.default.OPEN) {
+      return;
+    }
+    this.isConnecting = true;
+    return new Promise((resolve, reject) => {
+      try {
+        let wsUrl = `${this.options.serverUrl}/stream?token=${this.options.token}`;
+        if (this.options.sessionId) {
+          wsUrl += `&sessionId=${this.options.sessionId}`;
+        }
+        this.ws = new WebSocket__default.default(wsUrl);
+        let serverReady = false;
+        const handshakeTimeout = setTimeout(() => {
+          if (!serverReady) {
+            console.warn(
+              `\u26A0\uFE0F  TestDino: WebSocket handshake timeout \u2014 server did not send 'connected' within ${HANDSHAKE_TIMEOUT_MS}ms. Resolving anyway.`
+            );
+            serverReady = true;
+            this.isConnecting = false;
+            this.options.onConnected();
+            resolve();
+          }
+        }, HANDSHAKE_TIMEOUT_MS);
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          this.startPing();
+        });
+        this.ws.on("message", (data) => {
+          const raw = data.toString();
+          if (!serverReady) {
+            try {
+              const msg = JSON.parse(raw);
+              if (msg.type === "connected") {
+                serverReady = true;
+                clearTimeout(handshakeTimeout);
+                this.isConnecting = false;
+                this.options.onConnected();
+                resolve();
+                return;
+              }
+            } catch {
+            }
+          }
+          this.handleMessage(raw);
+        });
+        this.ws.on("close", (code, reason) => {
+          clearTimeout(handshakeTimeout);
+          if (!serverReady) {
+            this.isConnecting = false;
+            reject(new Error(`WebSocket closed before server ready: code=${code} reason=${reason.toString()}`));
+            return;
+          }
+          this.handleClose(code, reason.toString());
+        });
+        this.ws.on("error", (error) => {
+          clearTimeout(handshakeTimeout);
+          this.isConnecting = false;
+          this.options.onError(error);
+          reject(error);
+        });
+        this.ws.on("pong", () => {
+        });
+      } catch (error) {
+        this.isConnecting = false;
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Send event through WebSocket
+   */
+  async send(event) {
+    if (!this.ws || this.ws.readyState !== WebSocket__default.default.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    return new Promise((resolve, reject) => {
+      this.ws.send(JSON.stringify(event), (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Send multiple events in batch (parallel for speed)
+   */
+  async sendBatch(events) {
+    if (!this.ws || this.ws.readyState !== WebSocket__default.default.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    await Promise.all(events.map((event) => this.send(event)));
+  }
+  /**
+   * Check if WebSocket is connected
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket__default.default.OPEN;
+  }
+  /**
+   * Close WebSocket connection
+   */
+  close() {
+    this.isClosed = true;
+    this.stopPing();
+    this.clearReconnectTimer();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Handle incoming messages
+   */
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      if (message.type === "connected") {
+      } else if (message.type === "ack") {
+      } else if (message.type === "nack") {
+        const nack = message;
+        if (isServerError(nack.error)) {
+          this.options.onError(nack.error);
+        } else if (typeof nack.error === "object" && nack.error !== null) {
+          const errorObj = nack.error;
+          const errorCode = errorObj.code || errorObj.error;
+          if (errorCode === "QUOTA_EXCEEDED" && errorObj.details && typeof errorObj.details === "object") {
+            const details = errorObj.details;
+            this.options.onError(
+              new QuotaExceededError(errorObj.message?.toString() || "Quota exceeded", {
+                planName: details.planName?.toString() || "Unknown",
+                totalTests: Number(details.totalTests) || 0,
+                remaining: Number(details.remaining) || 0,
+                used: Number(details.used) || 0,
+                total: Number(details.total) || 0,
+                resetDate: details.resetDate?.toString(),
+                canPartialSubmit: Boolean(details.canPartialSubmit),
+                allowedCount: Number(details.allowedCount) || 0
+              })
+            );
+          } else if (errorCode === "QUOTA_EXHAUSTED" && errorObj.details && typeof errorObj.details === "object") {
+            const details = errorObj.details;
+            this.options.onError(
+              new QuotaExhaustedError(errorObj.message?.toString() || "Quota exhausted", {
+                planName: details.planName?.toString() || "Unknown",
+                totalLimit: Number(details.totalLimit) || 0,
+                used: Number(details.used) || 0,
+                resetDate: details.resetDate?.toString()
+              })
+            );
+          } else {
+            const errorMessage = errorObj.message?.toString() || errorObj.error?.toString() || JSON.stringify(nack.error);
+            this.options.onError(new Error(`Event rejected: ${errorMessage}`));
+          }
+        } else {
+          const errorMessage = typeof nack.error === "string" ? nack.error : String(nack.error);
+          this.options.onError(new Error(`Event rejected: ${errorMessage}`));
+        }
+      }
+    } catch (error) {
+      console.error("Failed to parse WebSocket message:", error);
+    }
+  }
+  /**
+   * Handle connection close
+   */
+  handleClose(_code, _reason) {
+    this.stopPing();
+    this.options.onDisconnected();
+    if (this.isClosed) {
+      return;
+    }
+    if (this.reconnectAttempts < this.options.maxRetries) {
+      this.scheduleReconnect();
+    } else {
+      this.options.onError(new Error(`WebSocket connection failed after ${this.options.maxRetries} attempts`));
+    }
+  }
+  /**
+   * Schedule reconnection with exponential backoff
+   */
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const delay = this.options.retryDelay * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch((error) => {
+        console.error("Reconnection failed:", error);
+      });
+    }, delay);
+  }
+  /**
+   * Clear reconnection timer
+   */
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  /**
+   * Start ping interval for keep-alive
+   */
+  startPing() {
+    this.stopPing();
+    this.pingInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket__default.default.OPEN) {
+        this.ws.ping();
+      }
+    }, 3e4);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+};
+var HttpClient = class {
+  client;
+  options;
+  constructor(options) {
+    this.options = {
+      maxRetries: 3,
+      retryDelay: 1e3,
+      ...options
+    };
+    this.client = axios__default.default.create({
+      baseURL: this.options.serverUrl,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.options.token}`
+      },
+      timeout: 1e4
+    });
+  }
+  /**
+   * Authenticate with server
+   */
+  async authenticate() {
+    try {
+      const response = await this.client.post("/auth");
+      return response.data;
+    } catch (error) {
+      if (axios__default.default.isAxiosError(error) && error.response?.status === 402) {
+        const quotaError = error.response.data;
+        throw new QuotaExhaustedError(quotaError.message, quotaError.details);
+      }
+      throw new Error(`Authentication failed: ${this.getErrorMessage(error)}`);
+    }
+  }
+  /**
+   * Send events via HTTP (fallback)
+   */
+  async sendEvents(events) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
+      try {
+        await this.client.post("/events", { events });
+        return;
+      } catch (error) {
+        lastError = new Error(this.getErrorMessage(error));
+        if (attempt < this.options.maxRetries - 1) {
+          const delay = this.options.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Failed to send events via HTTP");
+  }
+  /**
+   * Send single event via HTTP
+   */
+  async sendEvent(event) {
+    await this.sendEvents([event]);
+  }
+  /**
+   * Extract error message from various error types
+   */
+  getErrorMessage(error) {
+    if (axios__default.default.isAxiosError(error)) {
+      return error.response?.data?.message || error.message;
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+  /**
+   * Sleep utility for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/streaming/buffer.ts
+var EventBuffer = class {
+  events = [];
+  maxSize;
+  onFlush;
+  isFlushing = false;
+  constructor(options) {
+    this.maxSize = options.maxSize || 10;
+    this.onFlush = options.onFlush || (async () => {
+    });
+  }
+  /**
+   * Add event to buffer
+   * Automatically flushes if buffer reaches max size
+   */
+  async add(event) {
+    this.events.push(event);
+    if (this.events.length >= this.maxSize) {
+      await this.flush();
+    }
+  }
+  /**
+   * Flush all buffered events
+   */
+  async flush() {
+    if (this.isFlushing || this.events.length === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    try {
+      const eventsToFlush = [...this.events];
+      this.events = [];
+      await this.onFlush(eventsToFlush);
+    } catch (error) {
+      console.error("Failed to flush events:", error);
+      throw error;
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Get current buffer size
+   */
+  size() {
+    return this.events.length;
+  }
+  /**
+   * Check if buffer is empty
+   */
+  isEmpty() {
+    return this.events.length === 0;
+  }
+  /**
+   * Clear buffer without flushing
+   */
+  clear() {
+    this.events = [];
+  }
+  /**
+   * Get all events without removing them
+   */
+  getEvents() {
+    return [...this.events];
+  }
+};
+
+// src/metadata/base.ts
+var BaseMetadataCollector = class {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Get collector name
+   */
+  getName() {
+    return this.name;
+  }
+  /**
+   * Collect metadata with error handling and timing
+   */
+  async collect() {
+    try {
+      const data = await this.collectMetadata();
+      return data;
+    } catch (error) {
+      console.warn(
+        `\u26A0\uFE0F  TestDino: ${this.name} metadata collection failed:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      return this.getEmptyMetadata();
+    }
+  }
+  /**
+   * Collect metadata with result tracking
+   */
+  async collectWithResult() {
+    const startTime = Date.now();
+    const collector = this.getName();
+    try {
+      const data = await this.collectMetadata();
+      const duration = Date.now() - startTime;
+      return {
+        data,
+        success: true,
+        duration,
+        collector
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`\u26A0\uFE0F  TestDino: ${collector} metadata collection failed:`, errorMessage);
+      return {
+        data: this.getEmptyMetadata(),
+        success: false,
+        error: errorMessage,
+        duration,
+        collector
+      };
+    }
+  }
+  /**
+   * Utility method to run command with timeout
+   */
+  async withTimeout(promise, timeoutMs, operation) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+  }
+  /**
+   * Utility method to safely parse JSON
+   */
+  safeJsonParse(jsonString, fallback) {
+    try {
+      return JSON.parse(jsonString);
+    } catch {
+      return fallback;
+    }
+  }
+  /**
+   * Utility method to check if a value is non-empty string
+   */
+  isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+  }
+};
+
+// src/metadata/git.ts
+var GitMetadataCollector = class extends BaseMetadataCollector {
+  options;
+  constructor(options = {}) {
+    super("git");
+    this.options = {
+      timeout: options.timeout || 3e3,
+      cwd: options.cwd || process.cwd()
+    };
+  }
+  /**
+   * Collect git metadata
+   */
+  async collectMetadata() {
+    await this.configureGitForCI();
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return this.getEmptyMetadata();
+    }
+    const results = await Promise.all([
+      this.getBranch(),
+      this.getCommitHash(),
+      this.getCommitMessage(),
+      this.getAuthorName(),
+      this.getAuthorEmail(),
+      this.getCommitTimestamp(),
+      this.getRepoUrl(),
+      this.isDirtyWorkingTree()
+    ]);
+    let [branch, hash, message, author, email, timestamp] = results;
+    const repoUrl = results[6];
+    const isDirty = results[7];
+    let prMetadata;
+    if (process.env.GITHUB_EVENT_NAME === "pull_request") {
+      const eventData = await this.readGitHubEventFile();
+      if (eventData?.pull_request) {
+        prMetadata = this.extractPRMetadata(eventData);
+        const headRef = process.env.GITHUB_HEAD_REF;
+        if (this.isNonEmptyString(headRef)) {
+          branch = headRef;
+        }
+        const headSha = eventData.pull_request.head?.sha;
+        if (this.isNonEmptyString(headSha)) {
+          hash = headSha;
+          const realCommit = await this.getCommitInfoFromSha(headSha);
+          if (realCommit) {
+            message = realCommit.message ?? message;
+            author = realCommit.author ?? author;
+            email = realCommit.email ?? email;
+            timestamp = realCommit.timestamp ?? timestamp;
+          }
+        }
+      }
+    }
+    const githubAuthor = await this.resolveGitHubAuthor(hash);
+    return {
+      branch,
+      commit: {
+        hash,
+        message,
+        author: githubAuthor.authorLogin || author,
+        authorId: githubAuthor.authorId,
+        email,
+        timestamp,
+        isDirty
+      },
+      repository: {
+        name: this.extractRepoName(repoUrl),
+        url: repoUrl
+      },
+      ...prMetadata ? { pr: prMetadata } : {}
+    };
+  }
+  /**
+   * Get empty metadata
+   */
+  getEmptyMetadata() {
+    return {};
+  }
+  /**
+   * Configure git for CI environments
+   * Fixes "dubious ownership" errors when workspace is mounted with different ownership
+   */
+  async configureGitForCI() {
+    const isCI = process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true";
+    if (!isCI) return;
+    try {
+      await execa.execa("git", ["config", "--global", "--add", "safe.directory", this.options.cwd], {
+        timeout: this.options.timeout,
+        reject: true
+      });
+    } catch {
+    }
+  }
+  /**
+   * Read and parse the GitHub Actions event file
+   */
+  async readGitHubEventFile() {
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!eventPath) return void 0;
+    try {
+      const content = await this.withTimeout(
+        promises.readFile(eventPath, "utf-8"),
+        this.options.timeout,
+        "GitHub event file read"
+      );
+      return this.safeJsonParse(content, {});
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  TestDino: Failed to read GitHub event data:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Extract PR metadata from GitHub event data
+   */
+  extractPRMetadata(eventData) {
+    const pullRequest = eventData?.pull_request;
+    if (!pullRequest) return void 0;
+    const prMetadata = {};
+    if (this.isNonEmptyString(pullRequest.title)) {
+      prMetadata.title = pullRequest.title;
+    }
+    if (typeof pullRequest.number === "number") {
+      prMetadata.number = pullRequest.number;
+    }
+    if (this.isNonEmptyString(pullRequest.state)) {
+      prMetadata.status = pullRequest.state;
+    }
+    const serverUrl = process.env.GITHUB_SERVER_URL;
+    const repository = process.env.GITHUB_REPOSITORY;
+    if (prMetadata.number && serverUrl && repository) {
+      prMetadata.url = `${serverUrl}/${repository}/pull/${prMetadata.number}`;
+    }
+    if (pullRequest.head?.ref && this.isNonEmptyString(pullRequest.head.ref)) {
+      prMetadata.branch = pullRequest.head.ref;
+    }
+    if (pullRequest.base?.ref && this.isNonEmptyString(pullRequest.base.ref)) {
+      prMetadata.targetBranch = pullRequest.base.ref;
+    }
+    if (pullRequest.user?.login && this.isNonEmptyString(pullRequest.user.login)) {
+      prMetadata.author = pullRequest.user.login;
+    }
+    if (Array.isArray(pullRequest.labels) && pullRequest.labels.length > 0) {
+      const labels = pullRequest.labels.map((label) => label?.name).filter((name) => this.isNonEmptyString(name));
+      if (labels.length > 0) {
+        prMetadata.labels = labels;
+      }
+    }
+    if (typeof pullRequest.merged === "boolean") {
+      prMetadata.merged = pullRequest.merged;
+    }
+    if (typeof pullRequest.mergeable === "boolean") {
+      prMetadata.mergeable = pullRequest.mergeable;
+    }
+    if (this.isNonEmptyString(pullRequest.merge_commit_sha)) {
+      prMetadata.mergeCommitSha = pullRequest.merge_commit_sha;
+    }
+    const hasData = Object.keys(prMetadata).length > 0;
+    return hasData ? prMetadata : void 0;
+  }
+  /**
+   * Get commit details for a specific SHA using git show
+   * Used to resolve real commit data in PR context (instead of merge commit)
+   */
+  async getCommitInfoFromSha(sha) {
+    try {
+      const result = await this.execGit(["show", "-s", "--format=%s%n%an%n%ae%n%aI", sha]);
+      const lines = result.split("\n");
+      if (lines.length < 4) return void 0;
+      return {
+        message: this.isNonEmptyString(lines[0]) ? lines[0] : void 0,
+        author: this.isNonEmptyString(lines[1]) ? lines[1] : void 0,
+        email: this.isNonEmptyString(lines[2]) ? lines[2] : void 0,
+        timestamp: this.isNonEmptyString(lines[3]) ? lines[3] : void 0
+      };
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  TestDino: Failed to get commit info from SHA:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Resolve GitHub author info via the Commits API
+   * Only runs on GitHub Actions where GITHUB_REPOSITORY is available
+   */
+  async resolveGitHubAuthor(commitHash) {
+    const empty = { authorId: "" };
+    if (process.env.GITHUB_ACTIONS !== "true") {
+      return empty;
+    }
+    if (!commitHash) {
+      return empty;
+    }
+    const repository = process.env.GITHUB_REPOSITORY;
+    if (!repository) {
+      return empty;
+    }
+    const url = `https://api.github.com/repos/${repository}/commits/${commitHash}`;
+    try {
+      const headers = {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "testdino-playwright"
+      };
+      const token = process.env.GITHUB_TOKEN;
+      if (token) {
+        headers.Authorization = `token ${token}`;
+      }
+      const response = await this.withTimeout(fetch(url, { headers }), this.options.timeout, "GitHub Commits API");
+      if (!response.ok) {
+        return empty;
+      }
+      const data = await response.json();
+      if (data?.author?.id) {
+        const authorId = String(data.author.id);
+        const authorLogin = this.isNonEmptyString(data.author.login) ? data.author.login : void 0;
+        return { authorId, authorLogin };
+      }
+      return this.resolveGitHubAuthorFromActor();
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  TestDino: Failed to resolve GitHub author from Commits API:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return this.resolveGitHubAuthorFromActor();
+    }
+  }
+  /**
+   * Fallback: resolve GitHub author info from GITHUB_ACTOR via the Users API
+   */
+  async resolveGitHubAuthorFromActor() {
+    const actor = process.env.GITHUB_ACTOR;
+    if (!actor) {
+      return { authorId: "" };
+    }
+    const url = `https://api.github.com/users/${actor}`;
+    try {
+      const response = await this.withTimeout(
+        fetch(url, {
+          headers: {
+            Accept: "application/vnd.github.v3+json",
+            "User-Agent": "testdino-playwright"
+          }
+        }),
+        this.options.timeout,
+        "GitHub Users API"
+      );
+      if (!response.ok) {
+        return { authorId: "" };
+      }
+      const data = await response.json();
+      const authorId = data?.id ? String(data.id) : "";
+      const authorLogin = this.isNonEmptyString(data?.login) ? data.login : actor;
+      return { authorId, authorLogin };
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  TestDino: Failed to resolve GitHub author from GITHUB_ACTOR:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return { authorId: "" };
+    }
+  }
+  /**
+   * Check if current directory is a git repository
+   */
+  async isGitRepository() {
+    try {
+      await this.execGit(["rev-parse", "--git-dir"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get current branch name
+   * Uses: git rev-parse --abbrev-ref HEAD
+   */
+  async getBranch() {
+    try {
+      const result = await this.execGit(["rev-parse", "--abbrev-ref", "HEAD"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get current commit hash (full SHA)
+   * Uses: git rev-parse HEAD
+   */
+  async getCommitHash() {
+    try {
+      const result = await this.execGit(["rev-parse", "HEAD"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get commit message of current HEAD
+   * Uses: git log -1 --pretty=format:%s
+   */
+  async getCommitMessage() {
+    try {
+      const result = await this.execGit(["log", "-1", "--pretty=format:%s"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get commit author name
+   * Uses: git log -1 --pretty=format:%an
+   */
+  async getAuthorName() {
+    try {
+      const result = await this.execGit(["log", "-1", "--pretty=format:%an"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get commit author email
+   * Uses: git log -1 --pretty=format:%ae
+   */
+  async getAuthorEmail() {
+    try {
+      const result = await this.execGit(["log", "-1", "--pretty=format:%ae"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get commit timestamp (ISO format)
+   * Uses: git log -1 --pretty=format:%aI
+   */
+  async getCommitTimestamp() {
+    try {
+      const result = await this.execGit(["log", "-1", "--pretty=format:%aI"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get remote origin URL
+   * Uses: git config --get remote.origin.url
+   */
+  async getRepoUrl() {
+    try {
+      const result = await this.execGit(["config", "--get", "remote.origin.url"]);
+      return this.isNonEmptyString(result) ? result : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Check if working tree has uncommitted changes
+   * Uses: git status --porcelain
+   * Returns true if there are any changes (staged, unstaged, or untracked)
+   */
+  async isDirtyWorkingTree() {
+    try {
+      const result = await this.execGit(["status", "--porcelain"]);
+      return result.trim().length > 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Extract repository name from remote URL
+   * e.g., "https://github.com/user/repo.git" → "repo"
+   */
+  extractRepoName(repoUrl) {
+    if (!repoUrl) return void 0;
+    return repoUrl.split("/").pop()?.replace(".git", "") || void 0;
+  }
+  /**
+   * Execute git command with timeout
+   */
+  async execGit(args) {
+    const { stdout } = await this.withTimeout(
+      execa.execa("git", args, {
+        cwd: this.options.cwd,
+        timeout: this.options.timeout,
+        reject: true
+      }),
+      this.options.timeout,
+      `git ${args.join(" ")}`
+    );
+    return stdout.trim();
+  }
+};
+var CIMetadataCollector = class extends BaseMetadataCollector {
+  constructor(_options = {}) {
+    super("ci");
+  }
+  /**
+   * Collect CI metadata
+   */
+  async collectMetadata() {
+    const provider = this.detectCIProvider();
+    if (!provider) {
+      return {
+        provider: "local",
+        environment: this.collectEnvironment()
+      };
+    }
+    if (provider === "github-actions") {
+      return this.collectGitHubActionsMetadata();
+    }
+    return {
+      provider,
+      environment: this.collectEnvironment()
+    };
+  }
+  /**
+   * Get empty metadata
+   */
+  getEmptyMetadata() {
+    return {};
+  }
+  /**
+   * Detect CI provider from environment variables
+   */
+  detectCIProvider() {
+    const { env } = process;
+    if (env.GITHUB_ACTIONS === "true") {
+      return "github-actions";
+    }
+    return void 0;
+  }
+  /**
+   * Collect GitHub Actions specific metadata
+   */
+  collectGitHubActionsMetadata() {
+    const { env } = process;
+    return {
+      provider: "github-actions",
+      pipeline: {
+        id: env.GITHUB_RUN_ID,
+        name: env.GITHUB_WORKFLOW,
+        url: this.buildPipelineUrl()
+      },
+      build: {
+        number: env.GITHUB_RUN_NUMBER,
+        trigger: env.GITHUB_EVENT_NAME
+      },
+      environment: this.collectEnvironment()
+    };
+  }
+  /**
+   * Build the pipeline URL from GitHub Actions environment variables
+   */
+  buildPipelineUrl() {
+    const { env } = process;
+    const serverUrl = env.GITHUB_SERVER_URL;
+    const repository = env.GITHUB_REPOSITORY;
+    const runId = env.GITHUB_RUN_ID;
+    if (serverUrl && repository && runId) {
+      return `${serverUrl}/${repository}/actions/runs/${runId}`;
+    }
+    return void 0;
+  }
+  /**
+   * Collect runner environment information
+   */
+  collectEnvironment() {
+    try {
+      return {
+        name: os.type(),
+        type: process.platform,
+        os: `${os.type()} ${os.release()}`,
+        node: process.version
+      };
+    } catch {
+      return {};
+    }
+  }
+};
+var SystemMetadataCollector = class extends BaseMetadataCollector {
+  constructor(_options = {}) {
+    super("system");
+  }
+  /**
+   * Collect system metadata
+   */
+  async collectMetadata() {
+    return new Promise((resolve) => {
+      const metadata = {
+        os: this.getOperatingSystem(),
+        cpu: this.getCpuInfo(),
+        memory: this.getMemoryInfo(),
+        nodeVersion: this.getNodeVersion(),
+        platform: this.getPlatform(),
+        hostname: this.getHostname()
+      };
+      resolve(metadata);
+    });
+  }
+  /**
+   * Get empty metadata
+   */
+  getEmptyMetadata() {
+    return {};
+  }
+  /**
+   * Get operating system information
+   * Format: "platform release" (e.g., "darwin 23.1.0", "linux 5.4.0")
+   */
+  getOperatingSystem() {
+    let platformName = "unknown";
+    let releaseVersion = "unknown";
+    try {
+      platformName = os.platform();
+    } catch {
+    }
+    try {
+      releaseVersion = os.release();
+    } catch {
+    }
+    return `${platformName} ${releaseVersion}`;
+  }
+  /**
+   * Get CPU information
+   * Format: "model (X cores)" (e.g., "Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz (12 cores)")
+   */
+  getCpuInfo() {
+    try {
+      const cpuList = os.cpus();
+      if (cpuList.length === 0) {
+        return "unknown";
+      }
+      const model = cpuList[0].model.trim();
+      const coreCount = cpuList.length;
+      return `${model} (${coreCount} cores)`;
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get memory information
+   * Format: "X.X GB" (e.g., "16.0 GB", "8.5 GB")
+   */
+  getMemoryInfo() {
+    try {
+      const totalBytes = os.totalmem();
+      const totalGB = totalBytes / (1024 * 1024 * 1024);
+      return `${totalGB.toFixed(1)} GB`;
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get Node.js version
+   * Returns process.version (e.g., "v18.17.0")
+   */
+  getNodeVersion() {
+    try {
+      return process$1.version;
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get platform identifier
+   * Returns os.platform() (e.g., "darwin", "linux", "win32")
+   */
+  getPlatform() {
+    try {
+      return os.platform();
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get hostname
+   * Returns os.hostname() (e.g., "MacBook-Pro.local")
+   */
+  getHostname() {
+    try {
+      return os.hostname();
+    } catch {
+      return "unknown";
+    }
+  }
+};
+var PlaywrightMetadataCollector = class extends BaseMetadataCollector {
+  options;
+  constructor(options = {}) {
+    super("playwright");
+    this.options = {
+      timeout: options.timeout || 3e3,
+      config: options.config,
+      suite: options.suite,
+      packageJsonPath: options.packageJsonPath
+    };
+  }
+  /**
+   * Collect Playwright metadata
+   */
+  async collectMetadata() {
+    const metadata = {};
+    const version2 = await this.getPlaywrightVersion();
+    if (version2) {
+      metadata.version = version2;
+    }
+    if (this.options.config) {
+      const configMetadata = this.extractConfigMetadata(this.options.config);
+      Object.assign(metadata, configMetadata);
+    }
+    return metadata;
+  }
+  /**
+   * Build skeleton from Suite and include it in CompleteMetadata
+   */
+  buildSkeletonMetadata(suite) {
+    const skeleton = this.buildSkeleton(suite);
+    return { skeleton };
+  }
+  /**
+   * Get empty metadata
+   */
+  getEmptyMetadata() {
+    return {};
+  }
+  /**
+   * Get Playwright version from @playwright/test package.json
+   */
+  async getPlaywrightVersion() {
+    try {
+      const packageJsonPath = this.options.packageJsonPath || this.resolvePlaywrightPackageJson();
+      if (!packageJsonPath) {
+        return void 0;
+      }
+      const packageJsonContent = await this.withTimeout(
+        promises.readFile(packageJsonPath, "utf-8"),
+        this.options.timeout,
+        "Playwright package.json read"
+      );
+      const packageJson = this.safeJsonParse(packageJsonContent, {});
+      return this.isNonEmptyString(packageJson.version) ? packageJson.version : void 0;
+    } catch (error) {
+      console.warn(
+        "\u26A0\uFE0F  TestDino: Failed to read Playwright version:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Resolve @playwright/test package.json path
+   */
+  resolvePlaywrightPackageJson() {
+    try {
+      return __require.resolve("@playwright/test/package.json");
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Extract metadata from Playwright FullConfig
+   */
+  extractConfigMetadata(config) {
+    const metadata = {};
+    if (this.isNonEmptyString(config.configFile)) {
+      metadata.configFile = config.configFile;
+    }
+    if (typeof config.forbidOnly === "boolean") {
+      metadata.forbidOnly = config.forbidOnly;
+    }
+    if (typeof config.fullyParallel === "boolean") {
+      metadata.fullyParallel = config.fullyParallel;
+      metadata.parallel = config.fullyParallel;
+    }
+    if (typeof config.globalTimeout === "number") {
+      metadata.globalTimeout = config.globalTimeout;
+    }
+    if (config.grep) {
+      const patterns = Array.isArray(config.grep) ? config.grep : [config.grep];
+      metadata.grep = patterns.map((p) => p.source);
+    }
+    if (typeof config.maxFailures === "number") {
+      metadata.maxFailures = config.maxFailures;
+    }
+    if (config.metadata && typeof config.metadata === "object") {
+      metadata.metadata = config.metadata;
+    }
+    if (typeof config.workers === "number") {
+      metadata.workers = config.workers;
+    }
+    if (Array.isArray(config.projects) && config.projects.length > 0) {
+      const projectNames = config.projects.map((project) => project.name).filter((name) => this.isNonEmptyString(name));
+      if (projectNames.length > 0) {
+        metadata.projects = projectNames;
+      }
+    }
+    if (config.reportSlowTests && typeof config.reportSlowTests === "object") {
+      metadata.reportSlowTests = {
+        max: config.reportSlowTests.max,
+        threshold: config.reportSlowTests.threshold
+      };
+    }
+    if (this.isNonEmptyString(config.rootDir)) {
+      metadata.rootDir = config.rootDir;
+    }
+    if (config.shard && typeof config.shard.current === "number" && typeof config.shard.total === "number") {
+      metadata.shard = {
+        current: config.shard.current,
+        total: config.shard.total
+      };
+    }
+    if (Array.isArray(config.tags) && config.tags.length > 0) {
+      metadata.tags = config.tags;
+    }
+    if (config.webServer && typeof config.webServer === "object") {
+      metadata.webServer = config.webServer;
+    }
+    return metadata;
+  }
+  /**
+   * Build skeleton from Suite
+   */
+  buildSkeleton(suite) {
+    const totalTests = suite.allTests().length;
+    const suites = this.buildSuiteTree(suite);
+    return {
+      totalTests,
+      suites
+    };
+  }
+  /**
+   * Recursively build suite tree
+   */
+  buildSuiteTree(suite) {
+    const suites = [];
+    for (const childSuite of suite.suites) {
+      const skeletonSuite = {
+        title: childSuite.title,
+        type: childSuite.type === "file" ? "file" : "describe",
+        tests: childSuite.tests.map((test) => this.buildSkeletonTest(test))
+      };
+      if (childSuite.type === "file" && childSuite.location) {
+        skeletonSuite.file = childSuite.location.file;
+      }
+      if (childSuite.location) {
+        skeletonSuite.location = {
+          file: childSuite.location.file,
+          line: childSuite.location.line,
+          column: childSuite.location.column
+        };
+      }
+      if (childSuite.suites.length > 0) {
+        skeletonSuite.suites = this.buildSuiteTree(childSuite);
+      }
+      suites.push(skeletonSuite);
+    }
+    return suites;
+  }
+  /**
+   * Build skeleton test from TestCase
+   */
+  buildSkeletonTest(test) {
+    const skeletonTest = {
+      testId: test.id,
+      title: test.title,
+      location: {
+        file: test.location.file,
+        line: test.location.line,
+        column: test.location.column
+      }
+    };
+    if (test.tags && test.tags.length > 0) {
+      skeletonTest.tags = test.tags;
+    }
+    if (test.expectedStatus) {
+      skeletonTest.expectedStatus = test.expectedStatus;
+    }
+    if (test.annotations && test.annotations.length > 0) {
+      skeletonTest.annotations = test.annotations.map((ann) => ({
+        type: ann.type,
+        description: ann.description
+      }));
+    }
+    return skeletonTest;
+  }
+};
+
+// src/metadata/index.ts
+var DEFAULT_METADATA_OPTIONS = {
+  timeout: 5e3,
+  debug: false
+};
+var MetadataAggregator = class {
+  options;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  collectors = [];
+  playwrightCollector;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_METADATA_OPTIONS, ...options };
+  }
+  /**
+   * Register a metadata collector
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  registerCollector(collector) {
+    this.collectors.push(collector);
+    if (collector instanceof PlaywrightMetadataCollector) {
+      this.playwrightCollector = collector;
+    }
+  }
+  /**
+   * Build skeleton from Suite (if PlaywrightMetadataCollector is registered with a suite)
+   */
+  buildSkeleton(suite) {
+    if (!this.playwrightCollector) {
+      return void 0;
+    }
+    return this.playwrightCollector.buildSkeleton(suite);
+  }
+  /**
+   * Collect metadata from all registered collectors
+   * Uses Promise.allSettled for error isolation
+   */
+  async collectAll() {
+    const startTime = Date.now();
+    if (this.options.debug) {
+      console.log(`\u{1F50D} TestDino: Starting metadata collection with ${this.collectors.length} collectors`);
+    }
+    const settledResults = await Promise.allSettled(
+      this.collectors.map(
+        (collector) => this.withTimeout(collector.collectWithResult(), this.options.timeout, "Metadata collection")
+      )
+    );
+    const results = [];
+    const metadata = {};
+    for (const settledResult of settledResults) {
+      if (settledResult.status === "fulfilled") {
+        const result = settledResult.value;
+        results.push(result);
+        this.aggregateMetadata(metadata, result);
+      } else {
+        const error = settledResult.reason;
+        console.warn("\u26A0\uFE0F  TestDino: Metadata collector promise rejected:", error);
+        results.push({
+          data: {},
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          duration: 0,
+          collector: "unknown"
+        });
+      }
+    }
+    const totalDuration = Date.now() - startTime;
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.length - successCount;
+    if (this.options.debug) {
+      console.log(
+        `\u2705 TestDino: Metadata collection completed in ${totalDuration}ms (${successCount}/${results.length} successful)`
+      );
+    }
+    return {
+      metadata,
+      results,
+      totalDuration,
+      successCount,
+      failureCount
+    };
+  }
+  /**
+   * Aggregate individual collector results into complete metadata
+   */
+  aggregateMetadata(metadata, result) {
+    const { collector, data } = result;
+    switch (collector) {
+      case "git":
+        metadata.git = data;
+        break;
+      case "ci":
+        metadata.ci = data;
+        break;
+      case "system":
+        metadata.system = data;
+        break;
+      case "playwright":
+        metadata.playwright = data;
+        break;
+      default:
+        if (this.options.debug) {
+          console.warn(`\u26A0\uFE0F  TestDino: Unknown metadata collector: ${collector}`);
+        }
+    }
+  }
+  /**
+   * Utility method to run operation with timeout
+   */
+  async withTimeout(promise, timeoutMs, operation) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`${operation} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+  }
+};
+function createMetadataCollector(playwrightConfig, playwrightSuite) {
+  const aggregator = new MetadataAggregator();
+  aggregator.registerCollector(new GitMetadataCollector());
+  aggregator.registerCollector(new CIMetadataCollector());
+  aggregator.registerCollector(new SystemMetadataCollector());
+  aggregator.registerCollector(
+    new PlaywrightMetadataCollector({
+      config: playwrightConfig,
+      suite: playwrightSuite
+    })
+  );
+  return aggregator;
+}
+var SASTokenClient = class {
+  client;
+  options;
+  constructor(options) {
+    this.options = {
+      maxRetries: 2,
+      retryDelay: 1e3,
+      ...options
+    };
+    this.client = axios__default.default.create({
+      baseURL: this.options.serverUrl,
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.options.token
+      },
+      timeout: 1e4
+    });
+  }
+  /**
+   * Request SAS token for artifact uploads
+   * @param expiryHours - Token validity duration (1-48 hours, default 48)
+   * @returns SAS token response with upload instructions
+   */
+  async requestToken(expiryHours = 48) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
+      try {
+        const response = await this.client.post("/api/storage/token", void 0, {
+          params: {
+            expiryHours,
+            permissions: "write,create"
+          }
+        });
+        if (!response.data.success) {
+          throw new Error(response.data.message || "SAS token request failed");
+        }
+        return response.data.data;
+      } catch (error) {
+        lastError = new Error(this.getErrorMessage(error));
+        if (attempt < this.options.maxRetries - 1) {
+          const delay = this.options.retryDelay * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Failed to request SAS token");
+  }
+  /**
+   * Extract error message from various error types
+   */
+  getErrorMessage(error) {
+    if (axios__default.default.isAxiosError(error)) {
+      if (error.response?.status === 401) {
+        return "Invalid API key for artifact uploads";
+      }
+      if (error.response?.status === 403) {
+        return "API key does not have write permission for uploads";
+      }
+      if (error.response?.status === 429) {
+        return "Rate limit exceeded for SAS token requests";
+      }
+      return error.response?.data?.message || error.message;
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+  /**
+   * Sleep utility for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var ArtifactUploader = class {
+  sasToken;
+  options;
+  constructor(sasToken, options = {}) {
+    this.sasToken = sasToken;
+    this.options = {
+      timeout: 6e4,
+      maxRetries: 2,
+      debug: false,
+      ...options
+    };
+  }
+  /**
+   * Upload a single file to Azure Blob Storage
+   * @param attachment - Attachment with path and content type
+   * @param testId - Test identifier for organizing uploads
+   * @returns Upload result with Azure URL or error
+   */
+  async uploadFile(attachment, testId) {
+    const startTime = Date.now();
+    const fileName = path.basename(attachment.path);
+    try {
+      const stats = fs.statSync(attachment.path);
+      const fileSize = stats.size;
+      if (fileSize > this.sasToken.maxSize) {
+        return {
+          name: attachment.name,
+          success: false,
+          error: `File size ${fileSize} bytes exceeds maximum ${this.sasToken.maxSize} bytes`,
+          fileSize,
+          duration: Date.now() - startTime
+        };
+      }
+      const extension = path.extname(fileName).slice(1).toLowerCase();
+      const allowedTypes = this.sasToken.allowedFileTypes;
+      if (allowedTypes.length > 0 && !allowedTypes.includes(extension)) {
+        return {
+          name: attachment.name,
+          success: false,
+          error: `File extension '.${extension}' not in allowed types: ${allowedTypes.join(", ")}`,
+          fileSize,
+          duration: Date.now() - startTime
+        };
+      }
+      const uploadUrl = this.buildUploadUrl(testId, fileName);
+      await this.uploadWithRetry(attachment.path, uploadUrl, attachment.contentType);
+      const publicUrl = this.buildPublicUrl(testId, fileName);
+      if (this.options.debug) {
+        console.log(`\u{1F4E4} Uploaded: ${attachment.name} \u2192 ${publicUrl}`);
+      }
+      return {
+        name: attachment.name,
+        success: true,
+        uploadUrl: publicUrl,
+        fileSize,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (this.options.debug) {
+        console.warn(`\u26A0\uFE0F  Upload failed: ${attachment.name} - ${errorMessage}`);
+      }
+      return {
+        name: attachment.name,
+        success: false,
+        error: errorMessage,
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Upload multiple attachments in parallel
+   * @param attachments - Array of attachments to upload
+   * @param testId - Test identifier for organizing uploads
+   * @returns Array of upload results
+   */
+  async uploadAll(attachments, testId) {
+    if (attachments.length === 0) {
+      return [];
+    }
+    const validAttachments = attachments.filter((a) => a.path);
+    if (validAttachments.length === 0) {
+      return [];
+    }
+    const results = await Promise.allSettled(validAttachments.map((attachment) => this.uploadFile(attachment, testId)));
+    return results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        name: validAttachments[index].name,
+        success: false,
+        error: result.reason?.message || "Upload failed"
+      };
+    });
+  }
+  /**
+   * Build the full upload URL with SAS token
+   * Format: containerUrl/blobPath/uniqueId/testId/fileName?sasToken
+   */
+  buildUploadUrl(testId, fileName) {
+    const { containerUrl, blobPath, uniqueId, sasToken } = this.sasToken;
+    const path = `${blobPath}/${uniqueId}/${this.sanitizeTestId(testId)}/${fileName}`;
+    return `${containerUrl}/${path}?${sasToken}`;
+  }
+  /**
+   * Build public URL without SAS token (for storage in events)
+   * Format: containerUrl/blobPath/uniqueId/testId/fileName
+   */
+  buildPublicUrl(testId, fileName) {
+    const { containerUrl, blobPath, uniqueId } = this.sasToken;
+    const path = `${blobPath}/${uniqueId}/${this.sanitizeTestId(testId)}/${fileName}`;
+    return `${containerUrl}/${path}`;
+  }
+  /**
+   * Sanitize test ID for use in URL path
+   */
+  sanitizeTestId(testId) {
+    return testId.replace(/[^a-zA-Z0-9-_]/g, "_");
+  }
+  /**
+   * Upload file with retry logic
+   */
+  async uploadWithRetry(filePath, uploadUrl, contentType) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
+      try {
+        await this.doUpload(filePath, uploadUrl, contentType);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.options.maxRetries - 1) {
+          const delay = 1e3 * Math.pow(2, attempt);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Upload failed after retries");
+  }
+  /**
+   * Perform actual file upload to Azure
+   */
+  async doUpload(filePath, uploadUrl, contentType) {
+    const fileStream = fs.createReadStream(filePath);
+    const stats = fs.statSync(filePath);
+    await axios__default.default.put(uploadUrl, fileStream, {
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": stats.size,
+        "x-ms-blob-type": "BlockBlob"
+      },
+      timeout: this.options.timeout,
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    });
+  }
+  /**
+   * Sleep utility for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Check if SAS token is still valid
+   */
+  isTokenValid() {
+    const expiresAt = new Date(this.sasToken.expiresAt).getTime();
+    const now = Date.now();
+    return expiresAt > now + 5 * 60 * 1e3;
+  }
+  /**
+   * Get the unique ID for this upload session
+   */
+  getSessionId() {
+    return this.sasToken.uniqueId;
+  }
+};
+
+// src/reporter/index.ts
+var MAX_CONSOLE_CHUNK_SIZE = 1e4;
+var MAX_BUFFER_SIZE = 10;
+var TestdinoReporter = class {
+  config;
+  wsClient = null;
+  httpClient = null;
+  buffer = null;
+  runId;
+  useHttpFallback = false;
+  sequenceNumber = 0;
+  // Shard and timing info for interruption handling
+  shardInfo;
+  runStartTime;
+  // Signal handler management
+  sigintHandler;
+  sigtermHandler;
+  isShuttingDown = false;
+  // Quota tracking
+  quotaExceeded = false;
+  // Session ID from HTTP auth, passed to WebSocket for session reuse
+  sessionId = null;
+  // Artifact upload
+  artifactUploader = null;
+  artifactsEnabled = true;
+  // Default: enabled
+  // Deferred initialization - resolves true on success, false on failure
+  initPromise = null;
+  initFailed = false;
+  constructor(config = {}) {
+    const cliConfig = this.loadCliConfig();
+    this.config = { ...config, ...cliConfig };
+    this.runId = crypto.randomUUID();
+    this.buffer = new EventBuffer({
+      maxSize: MAX_BUFFER_SIZE,
+      onFlush: async (events) => {
+        if (this.initPromise) {
+          const success = await this.initPromise;
+          if (!success) return;
+        }
+        await this.sendEvents(events);
+      }
+    });
+  }
+  /**
+   * Load configuration from CLI temp file if available
+   */
+  loadCliConfig() {
+    const cliConfigPath = process.env.TESTDINO_CLI_CONFIG_PATH;
+    if (!cliConfigPath) {
+      return {};
+    }
+    try {
+      if (!fs.existsSync(cliConfigPath)) {
+        return {};
+      }
+      const configContent = fs.readFileSync(cliConfigPath, "utf-8");
+      const cliConfig = JSON.parse(configContent);
+      const mappedConfig = {};
+      if (cliConfig.token !== void 0 && typeof cliConfig.token === "string") {
+        mappedConfig.token = cliConfig.token;
+      }
+      if (cliConfig.serverUrl !== void 0 && typeof cliConfig.serverUrl === "string") {
+        mappedConfig.serverUrl = cliConfig.serverUrl;
+      }
+      if (cliConfig.debug !== void 0 && typeof cliConfig.debug === "boolean") {
+        mappedConfig.debug = cliConfig.debug;
+      }
+      if (cliConfig.ciRunId !== void 0 && typeof cliConfig.ciRunId === "string") {
+        mappedConfig.ciBuildId = cliConfig.ciRunId;
+      }
+      if (cliConfig.artifacts !== void 0 && typeof cliConfig.artifacts === "boolean") {
+        mappedConfig.artifacts = cliConfig.artifacts;
+      }
+      return mappedConfig;
+    } catch (error) {
+      if (process.env.TESTDINO_DEBUG === "true" || process.env.TESTDINO_DEBUG === "1") {
+        console.warn(
+          "\u26A0\uFE0F  TestDino: Failed to load CLI config:",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+      return {};
+    }
+  }
+  /**
+   * Called once before running tests
+   */
+  async onBegin(config, suite) {
+    if (config && this.isDuplicateInstance(config.reporter)) {
+      if (this.config.debug) {
+        console.log("\u26A0\uFE0F  TestDino: Reporter already configured in playwright.config, skipping duplicate instance");
+      }
+      return;
+    }
+    const token = this.getToken();
+    if (!token) {
+      this.printConfigurationError("Token is required but not provided", [
+        "Set environment variable: export TESTDINO_TOKEN=your-token",
+        'Add to playwright.config.ts: token: "your-token"',
+        "Use CLI wrapper: npx tdpw test --token your-token"
+      ]);
+      return;
+    }
+    if (config?.shard) {
+      this.shardInfo = {
+        current: config.shard.current,
+        total: config.shard.total
+      };
+    }
+    this.runStartTime = Date.now();
+    this.initPromise = this.performAsyncInit(config, suite, token);
+  }
+  /**
+   * Perform all async initialization: metadata, auth, WebSocket, artifacts, run:begin
+   *
+   * Buffer's onFlush callback awaits this promise before transmitting events,
+   * ensuring no data is sent before authentication and connection are established.
+   *
+   * @param config - Playwright FullConfig for metadata collection
+   * @param suite - Playwright Suite for skeleton building
+   * @param token - Authentication token
+   * @returns true on success, false on failure
+   */
+  async performAsyncInit(config, suite, token) {
+    const serverUrl = this.getServerUrl();
+    try {
+      const metadata = await this.collectMetadata(config, suite);
+      this.httpClient = new HttpClient({ token, serverUrl });
+      const auth = await this.httpClient.authenticate();
+      this.sessionId = auth.sessionId;
+      console.log("\u2705 TestDino: Authenticated successfully");
+      if (this.config.debug) {
+        console.log(`\u{1F50C} TestDino: Session ${this.sessionId} \u2014 reusing for WebSocket`);
+      }
+      this.wsClient = new WebSocketClient({
+        token,
+        sessionId: this.sessionId ?? void 0,
+        serverUrl: this.getWebSocketUrl(),
+        onConnected: () => {
+          console.log("\u{1F50C} TestDino: WebSocket connected");
+        },
+        onDisconnected: () => {
+          console.log("\u{1F50C} TestDino: WebSocket disconnected");
+        },
+        onError: (error) => {
+          if (isQuotaError(error)) {
+            if (!this.quotaExceeded) {
+              this.quotaExceeded = true;
+              this.initFailed = true;
+              this.printQuotaError(error);
+            }
+          } else {
+            console.error("\u274C TestDino: WebSocket error:", error.message);
+          }
+        }
+      });
+      try {
+        await this.wsClient.connect();
+      } catch {
+        console.warn("\u26A0\uFE0F  TestDino: WebSocket connection failed, using HTTP fallback");
+        this.useHttpFallback = true;
+      }
+      this.artifactsEnabled = this.config.artifacts !== false;
+      if (this.artifactsEnabled) {
+        await this.initializeArtifactUploader(token, serverUrl);
+      }
+      const beginEvent = {
+        type: "run:begin",
+        runId: this.runId,
+        metadata,
+        ...this.getEventMetadata()
+      };
+      await this.sendEvents([beginEvent]);
+      this.registerSignalHandlers();
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.initFailed = true;
+      if (error instanceof Error && "code" in error && isQuotaError(error)) {
+        this.quotaExceeded = true;
+        this.printQuotaError(error);
+      } else if (errorMessage.includes("Authentication failed") || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+        this.printConfigurationError("Authentication failed - Invalid or expired token", [
+          "Verify your token is correct",
+          "Check if the token has expired",
+          "Generate a new token from TestDino dashboard",
+          `Server URL: ${serverUrl}`
+        ]);
+      } else {
+        this.printConfigurationError(`Failed to initialize TestDino reporter: ${errorMessage}`, [
+          "Check if TestDino server is running and accessible",
+          `Verify server URL is correct: ${serverUrl}`,
+          "Check network connectivity",
+          "Review server logs for details"
+        ]);
+      }
+      return false;
+    }
+  }
+  /**
+   * Called for each test before it starts
+   */
+  async onTestBegin(test, result) {
+    if (!this.initPromise || this.initFailed) return;
+    const event = {
+      type: "test:begin",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Test identification
+      testId: test.id,
+      title: test.title,
+      titlePath: test.titlePath(),
+      // Location information
+      location: {
+        file: test.location.file,
+        line: test.location.line,
+        column: test.location.column
+      },
+      // Test configuration
+      tags: test.tags,
+      expectedStatus: test.expectedStatus,
+      timeout: test.timeout,
+      retries: test.retries,
+      annotations: test.annotations.map((a) => ({
+        type: a.type,
+        description: a.description
+      })),
+      // Execution context
+      retry: result.retry,
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex,
+      repeatEachIndex: test.repeatEachIndex,
+      // Hierarchy information
+      parentSuite: this.extractParentSuite(test.parent),
+      // Timing
+      startTime: result.startTime.getTime()
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called when a test step begins
+   */
+  async onStepBegin(test, result, step) {
+    if (!this.initPromise || this.initFailed) return;
+    const event = {
+      type: "step:begin",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Step Identification
+      testId: test.id,
+      stepId: `${test.id}-${step.titlePath().join("-")}`,
+      title: step.title,
+      titlePath: step.titlePath(),
+      // Step Classification
+      category: step.category,
+      // Location Information
+      location: step.location ? {
+        file: step.location.file,
+        line: step.location.line,
+        column: step.location.column
+      } : void 0,
+      // Hierarchy Information
+      parentStep: step.parent ? this.extractParentStep(step.parent) : void 0,
+      // Timing
+      startTime: step.startTime.getTime(),
+      // Retry Information
+      retry: result.retry,
+      // Worker Information
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called when a test step ends
+   */
+  async onStepEnd(test, result, step) {
+    if (!this.initPromise || this.initFailed) return;
+    const status = step.error ? "failed" : "passed";
+    const event = {
+      type: "step:end",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Step Identification
+      testId: test.id,
+      stepId: `${test.id}-${step.titlePath().join("-")}`,
+      title: step.title,
+      titlePath: step.titlePath(),
+      // Timing
+      duration: step.duration,
+      // Error Information
+      error: this.extractError(step.error),
+      // Status Information
+      status,
+      // Child Steps Summary
+      childSteps: this.extractChildSteps(step),
+      // Attachments Metadata
+      attachments: this.extractAttachments(step),
+      // Annotations
+      annotations: test.annotations.map((a) => ({
+        type: a.type,
+        description: a.description
+      })),
+      // Retry Information
+      retry: result.retry,
+      // Worker Information
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called after each test completes
+   */
+  async onTestEnd(test, result) {
+    if (!this.initPromise || this.initFailed) return;
+    const attachmentsWithUrls = await this.uploadAttachments(result.attachments, test.id);
+    const event = {
+      type: "test:end",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Test Identification
+      testId: test.id,
+      // Status Information
+      status: result.status,
+      outcome: test.outcome(),
+      // Timing
+      duration: result.duration,
+      // Execution Context
+      retry: result.retry,
+      // Worker Information
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex,
+      // Test Metadata
+      annotations: test.annotations.map((a) => ({
+        type: a.type,
+        description: a.description
+      })),
+      // Error Information
+      errors: result.errors.map((e) => this.extractError(e)).filter((e) => e !== void 0),
+      // Step Summary
+      steps: this.extractTestStepsSummary(result),
+      // Attachments Metadata (with Azure URLs when uploaded)
+      attachments: attachmentsWithUrls,
+      // Console Output
+      stdout: result.stdout.length > 0 ? this.extractConsoleOutput(result.stdout) : void 0,
+      stderr: result.stderr.length > 0 ? this.extractConsoleOutput(result.stderr) : void 0
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called after all tests complete
+   */
+  async onEnd(result) {
+    if (this.quotaExceeded) {
+      console.log("\u2705 TestDino: Tests completed (quota limit reached; not streamed to TestDino)");
+      this.wsClient?.close();
+      this.removeSignalHandlers();
+      return;
+    }
+    if (!this.initPromise) return;
+    const success = await this.initPromise;
+    if (!success) {
+      this.buffer?.clear();
+      this.wsClient?.close();
+      this.removeSignalHandlers();
+      return;
+    }
+    const event = {
+      type: "run:end",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Run Status
+      status: result.status,
+      // Timing
+      duration: result.duration,
+      startTime: result.startTime.getTime(),
+      // Shard information
+      shard: this.shardInfo
+    };
+    await this.buffer.add(event);
+    try {
+      await this.buffer.flush();
+      console.log("\u2705 TestDino: All events sent successfully");
+    } catch (error) {
+      console.error("\u274C TestDino: Failed to flush final events:", error);
+    }
+    this.wsClient?.close();
+    this.removeSignalHandlers();
+  }
+  /**
+   * Called on global errors
+   */
+  async onError(error) {
+    if (!this.initPromise || this.initFailed) return;
+    const event = {
+      type: "run:error",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Error Information (with cause support)
+      error: this.extractGlobalError(error)
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called when standard output is produced in worker process
+   */
+  async onStdOut(chunk, test, result) {
+    if (!this.initPromise || this.initFailed) return;
+    const { text, truncated } = this.truncateChunk(chunk);
+    const event = {
+      type: "console:out",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Console Output
+      text,
+      // Test Association (optional)
+      testId: test?.id,
+      retry: result?.retry,
+      // Truncation Indicator
+      truncated
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Called when standard error is produced in worker process
+   */
+  async onStdErr(chunk, test, result) {
+    if (!this.initPromise || this.initFailed) return;
+    const { text, truncated } = this.truncateChunk(chunk);
+    const event = {
+      type: "console:err",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      // Console Error Output
+      text,
+      // Test Association (optional)
+      testId: test?.id,
+      retry: result?.retry,
+      // Truncation Indicator
+      truncated
+    };
+    await this.buffer.add(event);
+  }
+  /**
+   * Indicates whether this reporter outputs to stdout/stderr
+   * Returns false to allow Playwright to add its own terminal output
+   */
+  printsToStdio() {
+    return false;
+  }
+  /**
+   * Send events via WebSocket or HTTP fallback
+   */
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    if (this.config.debug) {
+      for (const event of events) {
+        if (event.type === "test:begin") {
+          const testBeginEvent = event;
+          console.log(
+            `\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testBeginEvent.testId} retry=${testBeginEvent.retry} parallelIndex=${testBeginEvent.parallelIndex} title=${testBeginEvent.title}`
+          );
+        } else if (event.type === "test:end") {
+          const testEndEvent = event;
+          console.log(
+            `\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testEndEvent.testId} retry=${testEndEvent.retry} parallelIndex=${testEndEvent.parallelIndex}`
+          );
+        } else {
+          console.log(`\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId}`);
+        }
+      }
+    }
+    if (!this.useHttpFallback && this.wsClient?.isConnected()) {
+      try {
+        await this.wsClient.sendBatch(events);
+        return;
+      } catch {
+        console.warn("\u26A0\uFE0F  TestDino: WebSocket send failed, switching to HTTP fallback");
+        this.useHttpFallback = true;
+      }
+    }
+    if (this.httpClient) {
+      try {
+        await this.httpClient.sendEvents(events);
+      } catch (error) {
+        console.error("\u274C TestDino: Failed to send events via HTTP:", error);
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get token from config or environment
+   */
+  getToken() {
+    return this.config.token || process.env.TESTDINO_TOKEN;
+  }
+  /**
+   * Get server URL from config or environment
+   */
+  getServerUrl() {
+    const baseUrl = this.config.serverUrl || process.env.TESTDINO_SERVER_URL || "https://api.testdino.com";
+    return baseUrl.endsWith("/api/reporter") ? baseUrl : `${baseUrl}/api/reporter`;
+  }
+  getWebSocketUrl() {
+    const baseUrl = this.config.serverUrl || process.env.TESTDINO_SERVER_URL || "https://api.testdino.com";
+    const wsBaseUrl = baseUrl.replace("/api/reporter", "");
+    return wsBaseUrl.replace("http", "ws");
+  }
+  /**
+   * Collect metadata for the test run
+   */
+  async collectMetadata(playwrightConfig, playwrightSuite) {
+    try {
+      const metadataCollector = createMetadataCollector(playwrightConfig, playwrightSuite);
+      const result = await metadataCollector.collectAll();
+      if (result.failureCount > 0) {
+        console.warn(`\u26A0\uFE0F  TestDino: ${result.failureCount}/${result.results.length} metadata collectors failed`);
+      }
+      const skeleton = metadataCollector.buildSkeleton(playwrightSuite);
+      return {
+        ...result.metadata,
+        skeleton
+      };
+    } catch (error) {
+      console.warn("\u26A0\uFE0F  TestDino: Metadata collection failed:", error instanceof Error ? error.message : String(error));
+      return {};
+    }
+  }
+  /**
+   * Get next sequence number and current timestamp
+   */
+  getEventMetadata() {
+    return {
+      timestamp: Date.now(),
+      sequence: ++this.sequenceNumber
+    };
+  }
+  /**
+   * Extract parent suite information for skeleton mapping
+   */
+  extractParentSuite(parent) {
+    return {
+      title: parent.title,
+      type: parent.type,
+      location: parent.location ? {
+        file: parent.location.file,
+        line: parent.location.line,
+        column: parent.location.column
+      } : void 0
+    };
+  }
+  /**
+   * Extract parent step information for step hierarchy mapping
+   */
+  extractParentStep(parent) {
+    return {
+      title: parent.title,
+      category: parent.category,
+      location: parent.location ? {
+        file: parent.location.file,
+        line: parent.location.line,
+        column: parent.location.column
+      } : void 0
+    };
+  }
+  /**
+   * Extract child steps summary for step:end event
+   */
+  extractChildSteps(step) {
+    return {
+      count: step.steps.length,
+      steps: step.steps.map((child) => ({
+        title: child.title,
+        status: child.error ? "failed" : "passed"
+      }))
+    };
+  }
+  /**
+   * Extract error details from TestError (shared by step:end, test:end, and error events)
+   */
+  extractError(error) {
+    if (!error) return void 0;
+    return {
+      message: error.message || String(error),
+      stack: error.stack,
+      snippet: error.snippet,
+      value: error.value,
+      location: error.location ? {
+        file: error.location.file,
+        line: error.location.line,
+        column: error.location.column
+      } : void 0
+    };
+  }
+  /**
+   * Extract global error details with cause support (for error events)
+   */
+  extractGlobalError(error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      snippet: error.snippet,
+      value: error.value,
+      location: error.location ? {
+        file: error.location.file,
+        line: error.location.line,
+        column: error.location.column
+      } : void 0,
+      // Handle nested error cause (v1.49+)
+      cause: error.cause ? {
+        message: error.cause.message,
+        stack: error.cause.stack,
+        snippet: error.cause.snippet,
+        value: error.cause.value,
+        location: error.cause.location ? {
+          file: error.cause.location.file,
+          line: error.cause.location.line,
+          column: error.cause.location.column
+        } : void 0
+      } : void 0
+    };
+  }
+  /**
+   * Print a prominent configuration error banner
+   */
+  printConfigurationError(message, solutions) {
+    const border = "\u2550".repeat(70);
+    console.error("");
+    console.error(border);
+    console.error("  \u274C TestDino Reporter Configuration Error");
+    console.error(border);
+    console.error(`  ${message}`);
+    console.error("");
+    console.error("  Solutions:");
+    solutions.forEach((solution, index) => {
+      console.error(`    ${index + 1}. ${solution}`);
+    });
+    console.error(border);
+    console.error("");
+  }
+  /**
+   * Print quota error with plan details and upgrade information
+   * @param error - Quota error (QUOTA_EXHAUSTED or QUOTA_EXCEEDED)
+   */
+  printQuotaError(error) {
+    const border = "\u2550".repeat(70);
+    const errorData = error;
+    const details = errorData.details;
+    const planName = details?.planName || "Unknown";
+    const resetDate = details?.resetDate;
+    let message = "Execution quota exceeded";
+    message += `
+
+  Current Plan: ${planName}`;
+    if (errorData.code === "QUOTA_EXHAUSTED") {
+      message += `
+  Monthly Limit: ${details.totalLimit || "Unknown"} executions`;
+      message += `
+  Used: ${details.used || "Unknown"} executions`;
+      if (resetDate) {
+        message += `
+  Limit Resets: ${new Date(resetDate).toLocaleDateString()}`;
+      }
+    } else if (errorData.code === "QUOTA_EXCEEDED") {
+      const exceeded = details;
+      message += `
+  Monthly Limit: ${exceeded.total || "Unknown"} executions`;
+      message += `
+  Used: ${exceeded.used || "Unknown"} executions`;
+      const remaining = (exceeded.total ?? 0) - (exceeded.used ?? 0);
+      message += `
+  Remaining: ${remaining} executions`;
+      message += `
+  Tests in this run: ${exceeded.totalTests || "Unknown"}`;
+      if (resetDate) {
+        message += `
+  Limit Resets: ${new Date(resetDate).toLocaleDateString()}`;
+      }
+    }
+    console.error("");
+    console.error(border);
+    console.error("  \u274C TestDino Execution Limit Reached");
+    console.error(border);
+    console.error(`  ${message}`);
+    console.error("");
+    console.error("  Solutions:");
+    console.error("    1. Upgrade your plan to increase monthly limit");
+    console.error("    2. Wait for monthly limit reset");
+    console.error("    3. Visit https://testdino.com/pricing for plan options");
+    console.error(border);
+    console.error("");
+  }
+  /**
+   * Truncate console chunk to max size and convert Buffer to string
+   */
+  truncateChunk(chunk) {
+    let convertedText;
+    if (Buffer.isBuffer(chunk)) {
+      convertedText = chunk.toString("utf-8");
+    } else {
+      convertedText = chunk;
+    }
+    if (convertedText.length > MAX_CONSOLE_CHUNK_SIZE) {
+      return {
+        text: convertedText.substring(0, MAX_CONSOLE_CHUNK_SIZE) + "\n[truncated]",
+        truncated: true
+      };
+    }
+    return { text: convertedText };
+  }
+  /**
+   * Extract attachment metadata for step:end event
+   */
+  extractAttachments(step) {
+    return step.attachments.map((a) => ({
+      name: a.name,
+      contentType: a.contentType,
+      path: a.path
+      // undefined for in-memory attachments
+    }));
+  }
+  /**
+   * Extract steps summary for test:end event
+   */
+  extractTestStepsSummary(result) {
+    return {
+      total: result.steps.length,
+      passed: result.steps.filter((s) => !s.error).length,
+      failed: result.steps.filter((s) => s.error).length
+    };
+  }
+  /**
+   * Extract console output for test:end event
+   */
+  extractConsoleOutput(output) {
+    return output.map((item) => typeof item === "string" ? item : item.toString());
+  }
+  /**
+   * Check if this is a duplicate instance of TestdinoReporter
+   * This happens when the CLI injects our reporter via --reporter flag,
+   * but the user already has TestdinoReporter configured in playwright.config
+   *
+   * @param reporters - The resolved reporters array from FullConfig
+   * @returns true if there are multiple TestdinoReporter instances, false otherwise
+   */
+  isDuplicateInstance(reporters) {
+    const count = this.countTestdinoReporters(reporters);
+    return count > 1;
+  }
+  /**
+   * Count how many TestdinoReporter instances are in the reporters array
+   *
+   * @param reporters - The resolved reporters array from FullConfig
+   * @returns Number of TestdinoReporter instances found
+   */
+  countTestdinoReporters(reporters) {
+    if (!reporters || !Array.isArray(reporters)) {
+      return 0;
+    }
+    let count = 0;
+    for (const reporter of reporters) {
+      if (Array.isArray(reporter) && reporter.length > 0) {
+        const reporterName = reporter[0];
+        if (this.isTestdinoReporter(reporterName)) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  /**
+   * Check if a reporter name/path matches TestdinoReporter
+   *
+   * @param value - Reporter name, path, or class reference
+   * @returns true if this is our reporter, false otherwise
+   */
+  isTestdinoReporter(value) {
+    if (typeof value !== "string") {
+      return false;
+    }
+    return value.includes("@testdino/playwright") || value.includes("TestdinoReporter") || value.endsWith("testdino-playwright");
+  }
+  /**
+   * Register signal handlers for graceful shutdown on interruption
+   */
+  registerSignalHandlers() {
+    this.sigintHandler = () => {
+      if (this.sigintHandler) {
+        process.removeListener("SIGINT", this.sigintHandler);
+      }
+      if (this.sigtermHandler) {
+        process.removeListener("SIGTERM", this.sigtermHandler);
+      }
+      this.handleInterruption("SIGINT", 130);
+    };
+    this.sigtermHandler = () => {
+      if (this.sigintHandler) {
+        process.removeListener("SIGINT", this.sigintHandler);
+      }
+      if (this.sigtermHandler) {
+        process.removeListener("SIGTERM", this.sigtermHandler);
+      }
+      this.handleInterruption("SIGTERM", 143);
+    };
+    process.on("SIGINT", this.sigintHandler);
+    process.on("SIGTERM", this.sigtermHandler);
+  }
+  /**
+   * Remove signal handlers (called on normal completion or after handling interruption)
+   */
+  removeSignalHandlers() {
+    if (this.sigintHandler) {
+      process.removeListener("SIGINT", this.sigintHandler);
+    }
+    if (this.sigtermHandler) {
+      process.removeListener("SIGTERM", this.sigtermHandler);
+    }
+  }
+  /**
+   * Handle process interruption by sending run:end event with interrupted status
+   * @param signal - The signal that triggered the interruption (SIGINT or SIGTERM)
+   * @param exitCode - The exit code to use when exiting
+   */
+  handleInterruption(signal, exitCode) {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    console.log(`
+\u26A0\uFE0F  TestDino: Received ${signal}, sending interruption event...`);
+    if (!this.initPromise) {
+      process.exit(exitCode);
+    }
+    const event = {
+      type: "run:end",
+      runId: this.runId,
+      ...this.getEventMetadata(),
+      status: "interrupted",
+      duration: this.runStartTime ? Date.now() - this.runStartTime : 0,
+      startTime: this.runStartTime ?? Date.now(),
+      shard: this.shardInfo
+    };
+    const keepAlive = setInterval(() => {
+    }, 100);
+    const forceExitTimer = setTimeout(() => {
+      clearInterval(keepAlive);
+      console.error("\u274C TestDino: Force exit - send timeout exceeded");
+      this.wsClient?.close();
+      process.exit(exitCode);
+    }, 3e3);
+    const sendAndExit = async () => {
+      try {
+        await Promise.race([this.sendInterruptionEvent(event), this.timeoutPromise(2500, "Send timeout")]);
+        console.log("\u2705 TestDino: Interruption event sent");
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C TestDino: Failed to send interruption event: ${errorMsg}`);
+      } finally {
+        clearTimeout(forceExitTimer);
+        clearInterval(keepAlive);
+        this.wsClient?.close();
+        process.exit(exitCode);
+      }
+    };
+    sendAndExit().catch(() => {
+      clearTimeout(forceExitTimer);
+      clearInterval(keepAlive);
+      process.exit(exitCode);
+    });
+  }
+  /**
+   * Send interruption event directly without buffering
+   * Uses optimized path for speed during shutdown
+   */
+  async sendInterruptionEvent(event) {
+    if (!this.useHttpFallback && this.wsClient?.isConnected()) {
+      try {
+        await this.wsClient.send(event);
+        return;
+      } catch {
+        console.warn("\u26A0\uFE0F  WebSocket send failed, trying HTTP");
+      }
+    }
+    if (this.httpClient) {
+      try {
+        await this.httpClient.sendEvent(event);
+      } catch (error) {
+        throw new Error(`HTTP send failed: ${error}`);
+      }
+    } else {
+      throw new Error("No client available");
+    }
+  }
+  /**
+   * Create a promise that rejects after a timeout
+   * @param ms - Timeout in milliseconds
+   * @param message - Error message for timeout
+   */
+  timeoutPromise(ms, message) {
+    return new Promise((_, reject) => setTimeout(() => reject(new Error(message)), ms));
+  }
+  /**
+   * Initialize artifact uploader by requesting SAS token
+   * Gracefully handles failures - uploads disabled if SAS token request fails
+   */
+  async initializeArtifactUploader(token, serverUrl) {
+    try {
+      const baseServerUrl = this.getBaseServerUrl(serverUrl);
+      const sasTokenClient = new SASTokenClient({
+        token,
+        serverUrl: baseServerUrl
+      });
+      const sasToken = await sasTokenClient.requestToken();
+      this.artifactUploader = new ArtifactUploader(sasToken, {
+        debug: this.config.debug
+      });
+      if (this.config.debug) {
+        console.log("\u{1F4E4} TestDino: Artifact uploads enabled");
+      }
+    } catch (error) {
+      console.warn("\u26A0\uFE0F  TestDino: Artifact uploads disabled -", error instanceof Error ? error.message : String(error));
+      this.artifactsEnabled = false;
+      this.artifactUploader = null;
+    }
+  }
+  /**
+   * Upload attachments and return with Azure URLs
+   * If uploads disabled or failed, returns attachments with local paths
+   */
+  async uploadAttachments(attachments, testId) {
+    if (!this.artifactsEnabled || !this.artifactUploader) {
+      return attachments.map((a) => ({
+        name: a.name,
+        contentType: a.contentType,
+        path: a.path
+      }));
+    }
+    const fileAttachments = attachments.filter((a) => !!a.path).map((a) => ({
+      name: a.name,
+      contentType: a.contentType,
+      path: a.path
+    }));
+    if (fileAttachments.length === 0) {
+      return attachments.map((a) => ({
+        name: a.name,
+        contentType: a.contentType,
+        path: a.path
+      }));
+    }
+    const uploadResults = await this.artifactUploader.uploadAll(fileAttachments, testId);
+    const uploadMap = /* @__PURE__ */ new Map();
+    for (const result of uploadResults) {
+      uploadMap.set(result.name, result);
+    }
+    return attachments.map((a) => {
+      const uploadResult = uploadMap.get(a.name);
+      if (uploadResult?.success && uploadResult.uploadUrl) {
+        return {
+          name: a.name,
+          contentType: a.contentType,
+          path: uploadResult.uploadUrl
+        };
+      }
+      return {
+        name: a.name,
+        contentType: a.contentType,
+        path: a.path
+      };
+    });
+  }
+  /**
+   * Get base server URL without /api/reporter suffix
+   */
+  getBaseServerUrl(serverUrl) {
+    return serverUrl.replace(/\/api\/reporter$/, "");
+  }
+};
+
+module.exports = TestdinoReporter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map